leetcode/Next Permutation

package com.wj;

/*
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
给出数组的下一个字典序，如果不存在，输出此数组的升序序列
*/
public class Solution {
    public void nextPermutation(int[] a) {
        /*
        从尾到头，找到找到第一个数a[flag]<a[flag+1]
        比如1 5 8 7 4 ，找到5。如果没找到，直接输出整个数组排序后序列。
        找到在flag后找第一个比a[flag]大的数总最小的一个，
        */
        if (a == null || a.length == 1) {
            return;
        }
        int len = a.length;
        int flag = -1;
        //从后向前找到开始下降为位置。
        for (int i = len - 1; i > 0; i--) {
            if (a[i - 1] < a[i]) {
                flag = i - 1;
                break;
            }
        }
        if (flag == -1) {
        /*没找到，说明整个数组为逆序，直接从新排序数组就OK。
        下面其实可以不用快排，因为已经知道逆序了。直接首尾交换就OK*/
            partSort(a, 0, len - 1);
            return;
        } else {
            //找到了flag，将flag后的数组排序，排序了交换第一个比a[flag]大的数与a[flag]
            partSort(a, flag + 1, len - 1);
            for (int i = flag + 1; i <= len - 1; i++) {
                if (a[i] > a[flag]) {//交换
                    int tmp = a[i];
                    a[i] = a[flag];
                    a[flag] = tmp;
                    return;
                }
            }
        }
        return;
    }

    //快排的部分排序，将数组的固定部分排序.由于已经倒叙,所以其实不用快排,首尾指针,交换.
    private void partSort(int arr[], int left, int right) {   //挖坑填数
        if (left >= right) {
            return;
        }

        int flag = arr[left];
        int i = left;
        int j = right;
        while (i < j) {
            while (arr[j] >= flag && i < j) {
                j--;
            }
            //所以交换结束后,需要为第一个基准元素找位置,这个位置就是现在i的位置.
            while (arr[i] <= flag && i < j) {
                i++;
            }
            if (i < j) {
                swap(arr, i, j);
            }
        }
        swap(arr, left, i);
        partSort(arr, left, i - 1);
        partSort(arr, i + 1, right);
    }

    private void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}