31. Next Permutation --LeetCode

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




这题个人感觉挺有意思的，题意是给一个数组,可以按由小到大的顺序进行排列组合,又对所有组合进行排序，由小到大。如给定一个数组{1，2，3}

则其组合有 1,2,3->1,3,2->2,1,3->2,3,1->3,1,2->3,2,1;这样链表的形式，而需要返回的，便是给定数组在排序中的下一个数组。

这题另一方面也是一种动态规划的思路，由局部解推断全局解，从末尾开始推断，这串数组有套规律，当末尾最小子数组不为逆序时，则仅对这一段子数组进行操作，便可以得到全局解。

扫描二维码关注公众号，回复： 4929314 查看本文章

	    public void nextPermutation(int[] nums) {
	    	int[] arr = new int[nums.length];
	    	for(int i =0;i<arr.length;i++)
	    		arr[i]=0;
	    	int length=0;
	        for(int i=nums.length-1;i>=0;i--,length++)
	        {
	        	if(i!=nums.length-1&&nums[i+1]>nums[i])
	        	{
	        		arr[length] = nums[i];
	        		length++;
	        		break;
	        	}
	        	arr[length] = nums[i];
	        }

获取子数组方式如上，不过具体子数组操作方式我一开始还没弄明白，后来按照人为习惯去找，将子数组的首位与子数组后的数组中大于其的最小数交换，在对除首位数的子数组进行升序排序。

	        int temp=Integer.MAX_VALUE;
	        int index=length-1;
	        for(int i=0;i<length;i++)
	        {
	        	if(arr[i]<temp&&arr[i]>arr[length-1])
	        	{
	        		temp=arr[i];
	        		index=i;
	        	}
	        }
	        int tempNum = arr[index];
	        nums[nums.length-index-1] = nums[nums.length-length];
	        nums[nums.length-length] = tempNum;
	        Arrays.sort(nums,nums.length-length+1,nums.length);

整体代码：

    public void nextPermutation(int[] nums) {
    	int[] arr = new int[nums.length];
    	for(int i =0;i<arr.length;i++)
    		arr[i]=0;
    	int length=0;
        for(int i=nums.length-1;i>=0;i--,length++)
        {
        	if(i!=nums.length-1&&nums[i+1]>nums[i])
        	{
        		arr[length] = nums[i];
        		length++;
        		break;
        	}
        	arr[length] = nums[i];
        }
        int[] tempArr = Arrays.copyOf(nums,nums.length);
        Arrays.sort(tempArr);
        if(Arrays.equals(tempArr, arr))
        {
        	Arrays.sort(nums);
        	return;
        }
        int temp=Integer.MAX_VALUE;
        int index=length-1;
        for(int i=0;i<length;i++)
        {
        	if(arr[i]<temp&&arr[i]>arr[length-1])
        	{
        		temp=arr[i];
        		index=i;
        	}
        }
        int tempNum = arr[index];
        nums[nums.length-index-1] = nums[nums.length-length];
        nums[nums.length-length] = tempNum;
        Arrays.sort(nums,nums.length-length+1,nums.length);
    }

其实整道题明白规律后就不怎么难，大部分时间是在debug，数组的下标与遍历方式一直在变动，需要从头遍历，从尾遍历，也需要从中间遍历。