刷题——LeetCode 31. 下一个排列

题目

整数数组的一个 排列 就是将其所有成员以序列或线性顺序排列。

例如，arr = [1,2,3] ，以下这些都可以视作 arr 的排列：[1,2,3]、[1,3,2]、[3,1,2]、[2,3,1] 。
整数数组的 下一个排列 是指其整数的下一个字典序更大的排列。更正式地，如果数组的所有排列根据其字典顺序从小到大排列在一个容器中，那么数组的
下一个排列
就是在这个有序容器中排在它后面的那个排列。如果不存在下一个更大的排列，那么这个数组必须重排为字典序最小的排列（即，其元素按升序排列）。

例如，arr = [1,2,3] 的下一个排列是 [1,3,2] 。 类似地，arr = [2,3,1] 的下一个排列是 [3,1,2] 。
而 arr = [3,2,1] 的下一个排列是 [1,2,3] ，因为 [3,2,1] 不存在一个字典序更大的排列。 给你一个整数数组
nums ，找出 nums 的下一个排列。

必须 原地 修改，只允许使用额外常数空间。

示例 1：

输入：nums = [1,2,3] 输出：[1,3,2] 示例 2：

输入：nums = [3,2,1] 输出：[1,2,3] 示例 3：

输入：nums = [1,1,5] 输出：[1,5,1]

提示：

1 <= nums.length <= 100 0 <= nums[i] <= 100

解题思路：

  /** 解题思路：
   *  1. 查找位置： 倒序查找，找到一个当前位置元素小于后边一个元素的位置
   *  2. 查找最小值： 在后续元素中查找比当前元素大的最小值
   *  2. 交换： 交换当前位置与min值的数值
   *  3. 排序： 将当前位置之后的其他元素进行有小到大的排序即可
   *  4. 特殊位置：
   * 循环了所有元素，没有发现当前位置的元素均大于气候元素，只需将其倒置即可
   */

解答方案：

void Solution::nextPermutation(vector<int>& nums) {
  /// 1. find pos
  vector<int>::reverse_iterator c, last_min;
  bool is_find_pos = false;
  for (c = nums.rbegin() + 1; c != nums.rend(); c++) {  // main pointer
    // find min: c-1-> nums.rbegin()

    int count = 0;
    for (auto i = nums.rbegin(); i < c; i++) {
      if (*i > *c) {
        if (count == 0) {
          last_min = i;
        } else if (*last_min > *i) {
          last_min = i;
        }
        count++;
      }
    }

    // compare min and current point value
    // overchange those element
    if (*c < *(c - 1)) {
      auto temp = *c;
      *c = *last_min;
      *last_min = temp;

      // sort after the pointer element begin small to big

      for (auto i = nums.rbegin(); i < c - 1; i++) {
        for (auto j = nums.rbegin(); j < c - 1 - (i - nums.rbegin()); j++) {
          if (*j < *(j + 1)) {
            // over change
            auto temp = *(j + 1);
            *(j + 1) = *j;
            *j = temp;
          }
        }
      }

      break;
    }
  }

  // deal with other question
  if (c == nums.rend()) {
    for (auto k = 0; k < nums.size() / 2; k++) {
      auto temp = nums[k];
      nums[k] = nums[nums.size() - k - 1];
      nums[nums.size() - k - 1] = temp;
    }
  }
}

最新做法：

class Solution {
public:
    void nextPermutation(vector<int>& nums) {
    // 倒序查询前一个比后一个小的数
    int i = nums.size() - 2;
    while (i >= 0 && nums[i] >= nums[i + 1]) {
        i--;
    }

    // 当前位置到结束位置至今的数均为倒序，所以直接查找比当前位置的数字大的第一个数即可
    // 然后进行交换

    if (i >= 0) {
        int j = nums.size() - 1;
        while (j >= 0 && nums[i] >= nums[j]) {
        j--;
        }
        swap(nums[i], nums[j]);
    }
    // 当前位置的数，交换之后仍然是倒序排列，所以只需要倒序即可
    reverse(nums.begin() + i + 1, nums.end());
    }

};

总结：

1. 没有分析到，交换之后的数列仍然是倒序
2. 查找比当前位置较大的最小值方法比较欠妥