leetcode(31) - Next Permutation

【题目】

Implement next permutation, which rearranges numbers into the lexicographically next greater permutation of numbers.

If such arrangement is not possible, it must rearrange it as the lowest possible order (ie, sorted in ascending order).

The replacement must be in-place, do not allocate extra memory.

Here are some examples. Inputs are in the left-hand column and its corresponding outputs are in the right-hand column.
1,2,3 → 1,3,2
3,2,1 → 1,2,3
1,1,5 → 1,5,1

【解析】

其实就是排量生成算法字典序法生成当前排列的下一个排列。

之前写过全排列生成算法 【LeetCode】Permutations 解题报告 

差别就是上面那个全排列是从小到大逐个生成的，不会出现代码中第2步。

[java] view plain copy

1. public class Solution {  
2.     public void nextPermutation(int[] num) {  
3.         //1.找到最后一个升序位置pos  
4.         int pos = -1;  
5.         for (int i = num.length - 1; i > 0; i--) {  
6.             if (num[i] > num[i - 1]) {  
7.                 pos = i - 1;  
8.                 break;  
9.             }  
10.         }  
11.           
12.         //2.如果不存在升序，即这个数是最大的，那么反排这个数组  
13.         if (pos < 0) {  
14.             reverse(num, 0, num.length - 1);  
15.             return;  
16.         }  
17.           
18.         //3.存在升序，那么找到pos之后最后一个比它大的位置  
19.         for (int i = num.length - 1; i > pos; i--) {  
20.             if (num[i] > num[pos]) {  
21.                 int tmp = num[i];  
22.                 num[i] = num[pos];  
23.                 num[pos] = tmp;  
24.                 break;  
25.             }  
26.         }  
27.           
28.         //4.反排pos之后的数  
29.         reverse(num, pos + 1, num.length - 1);  
30.     }  
31.       
32.     public void reverse(int[] num, int begin, int end) {  
33.         int l = begin, r = end;  
34.         while (l < r) {  
35.             int tmp = num[l];  
36.             num[l] = num[r];  
37.             num[r] = tmp;  
38.             l++;  
39.             r--;  
40.         }  
41.     } 
    

 

算法描述：

1、从尾部开始往前寻找两个相邻的元素

第1个元素i，第2个元素j（从前往后数的），且i<j

2、再从尾往前找第一个大于i的元素k。将i、k对调

3、[j,last)范围的元素置逆（颠倒排列）

 

运行过程:

next: 01234

-> i=3,j=4

-> k=4,对调后01243

-> j指向最后一个元素，故结果为01243

 

next: 01243

-> i=2,j=4

-> k=3,对调后01342

-> j指向4，颠倒后为01324 即结果

 

...

next: 01432

-> i=1,j=4

-> k=2,对调后02431

-> j指向4，颠倒02134

=============自己写的如下=============

void reverse(int *nums, int start, int end){
    int i=start, j=end, tmp;
    while(i < j){
        tmp=nums[i];
        nums[i]=nums[j];
        nums[j]=tmp;
        i++;
        j--;
    }
}

void nextPermutation(int* nums, int numsSize) {
    int pos=numsSize-1, found=0, tmp;
    
    while(pos-1 >=0){    // 
        if(nums[pos] > nums[pos-1]){
            
            found=1;
            break;
        }
        pos--;
    }
    
    if(found==0) {
        reverse(nums, 0, numsSize-1);
    } else {
        
        for (int i=numsSize-1; i>pos-1; i--){
            if(nums[i]>nums[pos-1]){
                tmp=nums[i];
                nums[i]=nums[pos-1];
                nums[pos-1]=tmp;
                break;
            }    
        }

        reverse(nums, pos, numsSize-1);
    }
    
}