LeetCode - 969 煎饼翻面- 数组翻转排序【排序】

969. 煎饼排序

示例 1：

输入：[3,2,4,1]
输出：[4,2,4,3]
解释：
我们执行 4 次煎饼翻转，k 值分别为 4，2，4，和 3。
初始状态 arr = [3, 2, 4, 1]
第一次翻转后（k = 4）：arr = [1, 4, 2, 3]
第二次翻转后（k = 2）：arr = [4, 1, 2, 3]
第三次翻转后（k = 4）：arr = [3, 2, 1, 4]
第四次翻转后（k = 3）：arr = [1, 2, 3, 4]，此时已完成排序。 

示例 2：

输入：[1,2,3]
输出：[]
解释：
输入已经排序，因此不需要翻转任何内容。
请注意，其他可能的答案，如 [3，3] ，也将被判断为正确。

提示：

• 1 <= arr.length <= 100
• 1 <= arr[i] <= arr.length
• arr 中的所有整数互不相同（即，arr 是从 1 到 arr.length 整数的一个排列）

思路

  题意：多次转置数组使其变为有序数组。

  方法：一开始的想法是从有序数组向原始数组还原，每次通过转置将数组末尾确定下来：若两数组末尾元素不同，则找到有序数组中对应元素的位置，将其转置到起始位置，再将其转置到与原始数组对应元素位置。最后将转换方式逆序。

            后来发现，可以直接寻找原始数组的最大元素，将其转置到数组末尾（转置到起始位置，再转到末尾），再寻找剩余元素的最大值。

代码

方法一

class Solution {
    public void reverse(int[] result,int start,int end){
        while(start < end){
            int tmp = result[start];
            result[start] = result[end];
            result[end] = tmp;
            start++;
            end--;
        }
    }

    public int find(int[] result, int num) {
        for (int i = 0; i < result.length; i++)
            if (result[i] == num)
                return i;
        return 0;
    }

    public List<Integer> pancakeSort(int[] arr) {
        List<Integer> method = new ArrayList<>();
        int[] result = new int[arr.length];
        for (int i = 0; i < arr.length; i++)
            result[i] = arr[i];
        Arrays.sort(result);
        for (int i = result.length - 1; i >= 0; i--) {
            if (result[i] != arr[i]){
                int pos = find(result, arr[i]);
                if (pos != 0) {
                    reverse(result, 0, pos);
                    method.add(pos+1);
                }
                reverse(result, 0, i);
                method.add(i+1);
            }
        }
        Collections.reverse(method);
        return method;
    }
}

方法二

class Solution {
    public void reverse(int[] result,int start,int end){
        while(start < end){
            int tmp = result[start];
            result[start] = result[end];
            result[end] = tmp;
            start++;
            end--;
        }
    }

    public int findMax(int[] result, int end) {
        int max = result[0];
        int maxIndex = 0;
        for (int i = 1; i <= end; i++)
            if (result[i] > max) {
                max = result[i];
                maxIndex = i;
            }
        return maxIndex;
    }

    public List<Integer> pancakeSort(int[] arr) {
        List<Integer> method = new ArrayList<>();
        int maxIndex = 0;
        for (int i = arr.length - 1; i >= 0; i--) {
            maxIndex = findMax(arr, i);
            if (maxIndex != i) {
                if (maxIndex != 0) {
                    reverse(arr, 0, maxIndex);
                    method.add(maxIndex+1);
                }
                reverse(arr, 0, i);
                method.add(i+1);
            }
        }
        return method;
    }
}

运行结果