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

呃呃呃，其实没看懂题目，好歹我也过了六级，题目意思是找下一个大一点的全排列，输入形式我当时也没看明白，以为输入 123 ， 321 ， 115 三组同时输入要计算结果，最开始想着交换两个数字就可以了，后面又加了排序，不过发现自己的算法和正解就差了那么一点，但不对就是不对，看了这篇文章才知道自己错那了，点击打开链接，思想复制它的一下：

首先，关于什么是全排列不做解释。如果一个排列为A，下一个排列为A_NEXT，那么A_NEXT一定与A有尽可能长的公共前缀。

看具体例子，一个排列为124653，如何找到它的下一个排列，因为下一个排列一定与124653有尽可能长的前缀，所以，脑洞大开一下，从后面往前看这个序列，如果后面的若干个数字有下一个排列，问题就得到了解决。

第一步：找最后面1个数字的下一个全排列。

124653，显然最后1个数字3不具有下一个全排列。

第二步：找最后面2个数字的下一个全排列。

124653，显然最后2个数字53不具有下一个全排列。

第三步：找最后面3个数字的下一个全排列。

124653，显然最后3个数字653不具有下一个全排列。

------插曲：到这里相信大家已经看出来，如果一个序列是递减的，那么它不具有下一个排列。

第四步：找最后面4个数字的下一个全排列。

124653，我们发现显然最后4个数字4653具有下一个全排列。因为它不是递减的，例如6453，5643这些排列都在4653的后面。

我们总结上面的操作，并总结出重复上面操作的两种终止情况：

1：从后向前比较相邻的两个元素，直到前一个元素小于后一个元素，停止

2：如果已经没有了前一个元素，则说明这个排列是递减的，所以这个排列是没有下一个排列的。

124653这个排列终止情况是上面介绍的第一种，从后向前比较相邻的2个元素，遇到4<6的情况停止。

并且我们可以知道：

1：124653和它的下一个排列的公共前缀为12(因为4653存在下一个排列，所以前面的数字12保持不变)

2：4后面的元素是递减的(上面介绍的终止条件是前一个元素小于后一个元素，这里是4<6)

现在，我们开始考虑如何找到4653的下个排列，首先明确4后面的几个数字中至少有一个大于4.

4肯定要和653这3个数字中大于4的数字中(6，5)的某一个进行交换。这里就是4要和6，5中的某一个交换，很明显要和5交换，如果找到这样的元素呢，因为我们知道4后面的元素是递减的，所以在653中从后面往前查找，找到第一个大于4的数字，这就是需要和4进行交换的数字。这里我们找到了5，交换之后得到的临时序列为5643.，交换后得到的643也是一个递减序列。

所以得到的4653的下一个临时序列为5643，但是既然前面数字变大了(4653--->5643)，后面的自然要变为升序才行，变换5643得到5346.

所以124653的下一个序列为125643.

#include <iostream> 
#include <vector> 
#include <stdlib.h>
#include <string> 
#include <algorithm>
using namespace std; 

class Solution {
public:
	void nextPermutation(vector<int>& nums) {
		int numsSize = nums.size();
		if (!numsSize) return;
		int changeIndex, pointRight;
		bool flag = false;
		int IntTemp;
		pointRight = numsSize - 1;

		while (!flag && pointRight >= 1)   //从后向前比较相邻的两个元素，直到前一个元素小于后一个元素，停止
		{
			if (nums[pointRight] > nums[pointRight - 1])
			{
				flag = true;
				break;
			}
			pointRight--;
		}
		pointRight--;

		if (flag) //如果存在下一个排列
		{
			IntTemp = INT_MAX;
			for (int i = pointRight + 1; i < numsSize; ++i)  // 查找记录节点之后比它大的里面最小的位置
			{
				if (nums[i]>nums[pointRight] && nums[i] < IntTemp)
				{
					IntTemp = nums[i];
					changeIndex = i;
				}
			}
			IntTemp = nums[changeIndex];   //交换这两个数
			nums[changeIndex] = nums[pointRight];
			nums[pointRight] = IntTemp;

			if (pointRight + 1 < numsSize - 1)
				qsort(nums, pointRight + 1, numsSize - 1);   // 将后面的变成升序
		}
		else
		{
			qsort(nums, 0, numsSize - 1); //  如果已经没有了前一个元素，则说明这个排列是递减的，所以这个排列是没有下一个排列的。所以下一个就是整个序列的升序
		}


	}
private:	void qsort(vector<int> & nums, int left, int right)   //快速排序  
	{
		if (left < right)
		{
			int i = left;
			int j = right;
			int temp = nums[left];
			while (i < j)
			{
				while (i < j && nums[j] >= temp) j--;

				if (i < j)
				{
					nums[i] = nums[j];
					i++;
				}
				while (i < j && nums[i] <= temp) i++;
				if (i < j)
				{
					nums[j] = nums[i];
					j--;
				}
			}
			nums[i] = temp;
			qsort(nums, left, i - 1);
			qsort(nums, i + 1, right);
		}

	}
};
int main()
{ 
	vector<int > haha = { 0,1,1,0,4,4 };
	Solution a;
	a.nextPermutation(haha);
	for (int i = 0; i < haha.size(); ++i)
		cout << haha[i] << ",";
	system("pause");
	return 0; 
}