首先理解整数的字典序，字典序排列总是优先让“较小的”元素出现在前面。字典序的排列规则类似于字典中的单词排列方式，从左到右逐位比较，较小的数字优先出现。按照正整数元素排列的字典序，如果将每个排列视为一个整数值，那么这些排列确实是以升序排列的。

例如，对于数组 [1, 2, 3, 4]，字典序排列如下：

1. [1, 2, 3, 4] → 1234
2. [1, 2, 4, 3] → 1243
3. [1, 3, 2, 4] → 1324
4. [1, 3, 4, 2] → 1342
5. [1, 4, 2, 3] → 1423
6. [1, 4, 3, 2] → 1432
7. [2, 1, 3, 4] → 2134
8. [2, 1, 4, 3] → 2143
9. [2, 3, 1, 4] → 2314
10. [2, 3, 4, 1] → 2341
11. [2, 4, 1, 3] → 2413
12. [2, 4, 3, 1] → 2431
13. [3, 1, 2, 4] → 3124
14. [3, 1, 4, 2] → 3142
15. [3, 2, 1, 4] → 3214
16. [3, 2, 4, 1] → 3241
17. [3, 4, 1, 2] → 3412
18. [3, 4, 2, 1] → 3421
19. [4, 1, 2, 3] → 4123
20. [4, 1, 3, 2] → 4132
21. [4, 2, 1, 3] → 4213
22. [4, 2, 3, 1] → 4231
23. [4, 3, 1, 2] → 4312
24. [4, 3, 2, 1] → 4321

如果只有一个元素，下一个排列是其本身。

java 实现代码

class Solution {
    public void nextPermutation(int[] nums) {
        int n = nums.length;
        if(n < 2) return; //由于返回类型是void，所以如果只有一个元素，下一个排列是其本身。
        int i = n - 2; // i 是从右往左第一个两个相邻元素中前面的元素小于后面的元素时，前面这个元素的索引位置
        while(i >= 0 && nums[i] >= nums[i + 1]) {
            i--;
        }
        if(i >= 0) {
            //寻找比nums[i]大的最小元素
            int j = n - 1;//此时i右端所有元素相当于是逆序递减排列，
            //所以j从最右端开始遍历，第一个比i大的元素就是比nums[i]大的最小元素
            while(nums[j] <= nums[i]) {
                j--;
            }
            //交换nums[j] 和 nums[i]
            swap(nums, i, j); // swap交换数组nums下标i和j上的元素

        }
        //如果是字典序最大的排序此时, i == -1, i + 1 == 0
        reverse(nums, i + 1, n - 1); //理解从 i + 1 开始
    }
    private void reverse(int[] nums, int start, int end) {
        while(start < end) {
            swap(nums, start, end);
            start++;
            end--;
        }
    }
    private void swap(int[] nums, int i, int j) { //交换数组下标i和j上的元素
        int temp;
        temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
}