leetcode 969——煎饼排序

最新推荐文章于 2022-02-21 13:00:46 发布

原创最新推荐文章于 2022-02-21 13:00:46 发布 · 270 阅读

0 ·

CC 4.0 BY-SA版权

笔记专栏收录该内容

6 篇文章

订阅专栏

本文介绍了一种基于煎饼翻转的排序算法，通过一系列的翻转操作将数组排序，并详细解析了其背后的逻辑和代码实现，展示了如何通过两次反转确定最大值的位置。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目：

给定数组 A，我们可以对其进行煎饼翻转：我们选择一些正整数 k <= A.length，然后反转 A 的前 k 个元素的顺序。我们要执行零次或多次煎饼翻转（按顺序一次接一次地进行）以完成对数组 A 的排序。

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

示例 1：

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

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

提示：

1 <= A.length <= 100
A[i] 是 [1, 2, …, A.length] 的排列

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

题目分析：
目的:对数组A进行排序
返回值：k值数组

思路：
我们先从给定数组中找到最大值的下表，然后反转，就把该数放到数组的最前面，然后执行一次k=size的反转，就把最大值放到的数组的最后，这样我们就能确定一个数的位置。循环执行就可以得到答案。

如[3,2,4,1] 找到最大值4
下标为2，k=3
反转后得到[4,2,3,1]
k=size
反转后得到[1,3,2,4]

具体代码实现：

class Solution {
   public List<Integer> pancakeSort(int[] A) {
       List<Integer> list = new ArrayList<Integer>();
       int size = A.length;
       int temp;
       
       //根据提示可以知道A[i]是连续数列，所以最大值从 size-1 ——> 1
       for(int i=size;i>1;i--){
           temp = findIndex(A,i);
           //记录下k值
           list.add(temp);
           list.add(i);
           //两次反转确定最大值
           reverse(A,1,temp);
           reverse(A,1,i);
       }
       return list;
    }
    
    //找出指定值的下标
    private int findIndex(int[] A,int value){
        for(int i=0;i<A.length;i++){
            if(A[i] == value){
                return i+1;
            }
        }
        return 0;
    }
    
   //进行反转
    private void reverse(int[] arr, int s, int e) {
        s--;
        e--;
        while(s < e) {
            int tmp = arr[s];
            arr[s] = arr[e];
            arr[e] = tmp;
            s++;
            e--;
        }
    }
}

总结：
不是最优的解法，但是思路比较简单，容易理解。实际在团队开发中也一样，可读性可理解性和性能要兼顾。