lintcode(4)——下一个排列、上一个排列

原创于 2019-04-19 19:44:35 发布 · 350 阅读

0 ·

CC 4.0 BY-SA版权

C++ 专栏收录该内容

43 篇文章

订阅专栏

本文深入探讨了寻找整数数组下一个排列和上一个排列的算法原理及实现，通过具体实例说明如何通过调整数组元素顺序得到目标排列，适用于算法理解和面试准备。

52. 下一个排列

给定一个整数数组来表示排列，找出其之后的一个排列。

样例

例1:
输入:[1]
输出:[1]
例2:
输入:[1,3,2,3]
输出:[1,3,3,2]
例3:
输入:[4,3,2,1]
输出:[1,2,3,4]
注意事项

排列中可能包含重复的整数

先解释一下“字典序”：对于数字1、2、3......n的排列，不同排列的先后关系是从左到右逐个比较对应的数字的先后来决定的。

一个序列，这里，为了简单，就当做是正整数的序列吧，它有自己的排列方式，比较有规则的是两种：

1. 升序：由小到大，依次排列，如1, 2, 3, 4

2. 降序：由大到小，依次排列，如4, 3, 2, 1

在“字典序”中，我们将升序记为第一个排列，而将降序记为最后一个排列，显然，对于上面这个有4个元素的数组来说，一共有4!个排列，也就是说，除了我上面写出来的两个，还有22个排列。这些排列的顺序，就是“字典序”。

首先，先给两个概念：

1. 高位：越靠左越高

2. 低位：越靠右越低

也就是说，一个排列中，如果元素A在元素B的左边，则说A是高位，B是低位。而“字典序”就是一个不断增大高位数值，减小低位数值的过程。比如排列1, 2, 3三个整数，字典序的排列是这样的：

(1) 1, 2, 3

(2) 1, 3, 2

(3) 2, 1, 3

(4) 2, 3, 1

(5) 3, 1, 2

(6) 3, 2, 1

从(1)到(6)就是不断增加高位数值的过程。

class Solution {
public:
    vector<int> nextPermutation(vector<int> &nums) {
        // write your code here
        int i = nums.size() - 2;  
        while (i >= 0 && nums[i] >= nums[i + 1]) //从右往左，找出第一个左边小于右边的数A
        {  
            i--;  
        }  
        if (i < 0) 
        {  
            reverse(nums.begin(), nums.end() - 1);  
        }  
        else 
        {  
            int j = i + 2;  
            while (j < nums.size() && nums[j] > nums[i]) //从右往左，找出第一个大于A的数
            {  
                j++;  
            }  
            j--;  
              
            nums[i] ^= nums[j];  //采用异或运算实现两数交换
            nums[j] ^= nums[i];  
            nums[i] ^= nums[j];  
              
            reverse(nums.begin() + i + 1, nums.end() - 1);  //将A后面的数据从小到大排序,即翻转该部分数据
        }  
        return nums;
    }
    private:  
    void reverse(vector<int>::iterator i1, vector<int>::iterator i2) {  
        while (i1 < i2) 
        {  
            *i1 ^= *i2;  
            *i2 ^= *i1;  
            *i1 ^= *i2;  
       
            i1++;  
            i2--;  
        }  
    }
};

51. 上一个排列

给定一个整数数组来表示排列，找出其上一个排列。

样例

例1:
输入:[1]
输出:[1]
例2:
输入:[1,3,2,3]
输出:[1,2,3,3]
例3:
输入:[1,2,3,4]
输出:[4,3,2,1]
注意事项

排列中可能包含重复的整数

因为求取的是上一个排列，所以，我们找寻的目的是找到一个数值高的高位，将其数值变低，这一点与“下一个排列”是相反的。所以，可以这样寻找：从右往左，找第一个不是降序的位置：例如，[2, 1, 3]，3到1，降序；1到2，升序。于是定位需要改变的高位为数值2所在的位置。然后再从右往左寻找第一个比这个高位数值小的数，交换。这里，我们找到了1，于是，交换1和2，变成[1, 2, 3]；最后，与“下一个排列”同理，因为只是上“一”个，所以，需要将高位之后的部分数组按降序排列。此处[1, 2, 3] -> [1, 3, 2]. 整个过程完成。

class Solution {
public:
    vector<int> previousPermuation(vector<int> &nums) {
        // write your code here
        int i = nums.size() - 2;  
        while (i >= 0 && nums[i] <= nums[i + 1]) 
        {  
            i--;  
        }  
        if (i < 0) 
        {  
            reverse(nums.begin(), nums.end() - 1);  
        }  
        else 
        {  
            int j = i + 2;  
            while (j < nums.size() && nums[j] < nums[i]) 
            {  
                j++;  
            }  
            j--;  
              
            nums[i] ^= nums[j];  //采用异或运算实现两数交换
            nums[j] ^= nums[i];  
            nums[i] ^= nums[j];  
              
            reverse(nums.begin() + i + 1, nums.end() - 1); 
        }  
        return nums;
    }
    private:  
    void reverse(vector<int>::iterator i1, vector<int>::iterator i2) {  
        while (i1 < i2) 
        {  
            *i1 ^= *i2;  
            *i2 ^= *i1;  
            *i1 ^= *i2;  
       
            i1++;  
            i2--;  
        }  
    }
};