煎饼排序

给你一个整数数组 arr ，请使用煎饼翻转完成对数组的排序。

一次煎饼翻转的执行过程如下：

选择一个整数 k ，1 <= k <= arr.length
反转子数组 arr[0...k-1]（下标从 0 开始）例如，arr = [3,2,1,4] ，选择 k = 3 进行一次煎饼翻转，反转子数组 [3,2,1] ，得到 arr = [1,2,3,4] 。

以数组形式返回能使 arr 有序的煎饼翻转操作所对应的 k 值序列。任何将数组排序且翻转次数在 10 * arr.length 范围内的有效答案都将被判断为正确。

示例 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 整数的一个排列）

来源：力扣（LeetCode）链接：leetcode-cn.com/problems/pa… 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

我们先找到最大的值，记录这个值的下标(假设下标为2)，把下标为0一直到下标为2的值进行翻转

然后就把最大的值翻转到arr下标为0的地方

如图：

然后定义一个变量，记录我们已经找到了一个最大值了。

上图，我们进行了3，4的翻转得到[1，3，2，4]

然后继续找最大值，此时4不参与找值了，所以我们找到的最大值是3，3翻转到前面，然后再翻转到4的前面，要进行2，3的翻转，此时我们已经翻转了[3,4,2,3],得到的图是

此时2是最大值，且在下标0的位置，所以我们不需要把2翻转到数组首位，直接把2翻转到3的前面即可，进行2的翻转，得到的翻转为[3,4,2,3,2]

得到的图是：

至此，翻转完毕，return[3,4,2,3,2]即可

代码


var pancakeSort = function (arr) {
    // 定一个数组，存翻转个数
    let List = [];
    // 定一个变量，存最大值
    let num = 0;
    // 定一个变量，存最大值的下标
    let numIndex = 0;
    // 记录翻转到后面的最大值个数
    let reverseNum = 0;
    while (reverseNum < arr.length) {
        // 第一步，先找最大值
        for (let i = 0; i < arr.length - reverseNum; i++) {
            if (arr[i] > num) {
                num = arr[i];
                numIndex = i;
            }
        }
        if (numIndex != 0) {
            // 首数组不是最大值,才需要把最大值翻转到前面
            List.push(numIndex + 1);
            let j = []
            for (let i = 0; i < numIndex + 1; i++) {
                j.unshift(arr[i])
            }
            for (let i = 0; i < numIndex + 1; i++) {
                arr[i] = j[i]
            }
        }
        // 第二步，进行翻转
        if (reverseNum + 1 != arr.length) {
            let k = []
            for (let i = 0; i < arr.length - reverseNum; i++) {
                k.unshift(arr[i])
            }
            for (let i = 0; i < arr.length - reverseNum; i++) {
                arr[i] = k[i]
            }
            List.push(arr.length - reverseNum);
        }
        reverseNum++;
        num = 0;
        numIndex = 0;
    }
    return List;
};

更简便的代码↓


var pancakeSort = function (arr) {
    let ans = [],
        max;
    while (arr.length > 1) {
        max = getMaxIndex(arr);
        max > 0 && (ans.push(max + 1));
        reverse(arr, max);
        reverse(arr, arr.length - 1);
        ans.push(arr.length);
        arr.pop();
    }
    return ans;
};

// 找到最大数的下标
function getMaxIndex(nums) {
    let max = 0;
    for (let i = 0; i < nums.length; i++) {
        if (nums[i] > nums[max]) {
            max = i;
        }
    }
    return max;
}

// 翻转前K个数
var reverse = function (arr, k) {
    if (k < 1) {
        return
    }
    let i = 0,
        j = k;
    while (i < j) {
        [arr[i], arr[j]] = [arr[j], arr[i]]
        i++;
        j--;
    }
}