Previous Permuation

Question

Problem Statement

Given a list of integers, which denote a permutation.

Find the previous permutation in ascending order.

Example

For [1,3,2,3], the previous permutation is [1,2,3,3]

For [1,2,3,4], the previous permutation is [4,3,2,1]

Note

The list may contains duplicate integers.

题解

和前一题 Next Permutation 非常类似，这里找上一个排列，仍然使用字典序算法，大致步骤如下：

  1. 从后往前寻找索引满足 a[k] > a[k + 1], 如果此条件不满足，则说明已遍历到最后一个。
  2. 从后往前遍历，找到第一个比a[k]小的数a[l], 即a[k] > a[l].
  3. 交换a[k]与a[l].
  4. 反转k + 1 ~ n之间的元素。

为何不从前往后呢？因为只有从后往前才能保证得到的是相邻的排列，可以举个实际例子自行分析。

Python

  1. class Solution:
  2.     # @param num :  a list of integer
  3.     # @return : a list of integer
  4.     def previousPermuation(self, num):
  5.         if num is None or len(num) <= 1:
  6.             return num
  7.         # step1: find nums[i] > nums[i + 1], Loop backwards
  8.         i = 0
  9.         for i in xrange(len(num) - 2, -1, -1):
  10.             if num[i] > num[i + 1]:
  11.                 break
  12.             elif i == 0:
  13.                 # reverse nums if reach maximum
  14.                 num = num[::-1]
  15.                 return num
  16.         # step2: find nums[i] > nums[j], Loop backwards
  17.         j = 0
  18.         for j in xrange(len(num) - 1, i, -1):
  19.             if num[i] > num[j]:
  20.                 break
  21.         # step3: swap betwenn nums[i] and nums[j]
  22.         num[i], num[j] = num[j], num[i]
  23.         # step4: reverse between [i + 1, n - 1]
  24.         num[i + 1:len(num)] = num[len(num) - 1:i:-1]
  26.         return num

C++

  1. class Solution {
  2. public:
  3.     /**
  4.      * @param nums: An array of integers
  5.      * @return: An array of integers that's previous permuation
  6.      */
  7.     vector<int> previousPermuation(vector<int> &nums) {
  8.         if (nums.empty() || nums.size() <= 1) {
  9.             return nums;
  10.         }
  11.         // step1: find nums[i] > nums[i + 1]
  12.         int i = 0;
  13.         for (i = nums.size() - 2; i >= 0; --i) {
  14.             if (nums[i] > nums[i + 1]) {
  15.                 break;
  16.             } else if (0 == i) {
  17.                 // reverse nums if reach minimum
  18.                 reverse(nums, 0, nums.size() - 1);
  19.                 return nums;
  20.             }
  21.         }
  22.         // step2: find nums[i] > nums[j]
  23.         int j = 0;
  24.         for (j = nums.size() - 1; j > i; --j) {
  25.             if (nums[i] > nums[j]) break;
  26.         }
  27.         // step3: swap betwenn nums[i] and nums[j]
  28.         int temp = nums[i];
  29.         nums[i] = nums[j];
  30.         nums[j] = temp;
  31.         // step4: reverse between [i + 1, n - 1]
  32.         reverse(nums, i + 1, nums.size() - 1);
  34.         return nums;
  35.     }
  37. private:
  38.     void reverse(vector<int>& nums, int start, int end) {
  39.         for (int i = start, j = end; i < j; ++i, --j) {
  40.             int temp = nums[i];
  41.             nums[i] = nums[j];
  42.             nums[j] = temp;
  43.         }
  44.     }
  45. };

Java

  1. public class Solution {
  2.     /**
  3.      * @param nums: A list of integers
  4.      * @return: A list of integers that's previous permuation
  5.      */
  6.     public ArrayList<Integer> previousPermuation(ArrayList<Integer> nums) {
  7.         ArrayList<Integer> perm = new ArrayList<Integer>(nums);
  8.         if (nums == null || nums.size() == 0) return perm;
  10.         // step1: search the first num[k] > num[k+1] backward
  11.         int k = -1;
  12.         for (int i = perm.size() - 2; i >= 0; i--) {
  13.             if (perm.get(i) > perm.get(i + 1)) {
  14.                 k = i;
  15.                 break;
  16.             }
  17.         }
  18.         // if current rank is the smallest, reverse it to largest, return
  19.         if (k == -1) {
  20.             reverse(perm, 0, perm.size() - 1);
  21.             return perm;
  22.         }
  24.         // step2: search the first perm[k] > perm[l] backward
  25.         int l = perm.size() - 1;
  26.         while (l > k && perm.get(l) >= perm.get(k)) {
  27.             l--;
  28.         }
  30.         // step3: swap perm[k] with perm[l]
  31.         Collections.swap(perm, k, l);
  33.         // step4: reverse between k+1 and perm.length-1;
  34.         reverse(perm, k + 1, perm.size() - 1);
  36.         return perm;
  37.     }
  39.     private void reverse(List<Integer> nums, int lb, int ub) {
  40.         for (int i = lb, j = ub; i < j; i++, j--) {
  41.             Collections.swap(nums, i, j);
  42.         }
  43.     }
  44. }

源码分析

和 Permutation 一小节类似，这里只需要注意在step 1中i == -1时需要反转之以获得最大的序列。对于有重复元素，只要在 step1和 step2中判断元素大小时不取等号即可。

复杂度分析

最坏情况下，遍历两次原数组，反转一次数组，时间复杂度为 O(n), 使用了 temp 临时变量，空间复杂度可认为是 O(1).