煎饼分类

给定一个未排序的数组，对给定的数组进行排序。只允许对数组执行以下操作。

flip(arr, i): Reverse array from 0 to i 

与传统的排序算法尝试以尽可能少的比较进行排序不同，传统排序算法的目的是对序列进行尽可能少的反向排序。
这个想法是做类似于选择排序的事情。我们在末尾将最大元素一一放置，并将当前数组的大小减小一。
以下是详细步骤。假设给定的数组为arr []，数组的大小为n。

• 从等于n的当前大小开始，并在当前大小大于1时将其减小一。令当前大小为curr_size。对每个curr_size执行以下操作
  • 在arr [0..curr_szie-1]中查找最大元素的索引。令索引为“ mi”
  • 呼叫翻页(arr，mi)
  • 调用flip(arr，curr_size-1)

请参见以下视频，以直观了解上述算法。
http://www.youtube.com/embed/kk-_DDgoXfk

C

// C program to
// sort array using
// pancake sort
#include 
#include 
 
/* Reverses arr[0..i] */
void flip(int arr[], int i)
{
    int temp, start = 0;
    while (start < i) {
        temp = arr[start];
        arr[start] = arr[i];
        arr[i] = temp;
        start++;
        i--;
    }
}
 
// Returns index of the
// maximum element in
// arr[0..n-1]
int findMax(int arr[], int n)
{
    int mi, i;
    for (mi = 0, i = 0; i < n; ++i)
        if (arr[i] > arr[mi])
            mi = i;
    return mi;
}
 
// The main function that
// sorts given array using
// flip operations
void pancakeSort(int* arr, int n)
{
    // Start from the complete
    // array and one by one
    // reduce current size
    // by one
    for (int curr_size = n; curr_size > 1;
                                 --curr_size)
    {
        // Find index of the
        // maximum element in
        // arr[0..curr_size-1]
        int mi = findMax(arr, curr_size);
 
        // Move the maximum
        // element to end of
        // current array if
        // it's not already
        // at the end
        if (mi != curr_size - 1) {
            // To move at the end,
            // first move maximum
            // number to beginning
            flip(arr, mi);
 
            // Now move the maximum
            // number to end by
            // reversing current array
            flip(arr, curr_size - 1);
        }
    }
}
 
// A utility function to print
// n array of size n
void printArray(int arr[], int n)
{
    for (int i = 0; i < n; ++i)
        printf("%d ", arr[i]);
}
 
// Driver program to test above function
int main()
{
    int arr[] = { 23, 10, 20, 11, 12, 6, 7 };
    int n = sizeof(arr) / sizeof(arr[0]);
 
    pancakeSort(arr, n);
 
    puts("Sorted Array ");
    printArray(arr, n);
 
    return 0;
}

CPP

// C++ program to
// sort array using
// pancake sort
#include
using namespace std;
 
/* Reverses arr[0..i] */
void flip(int arr[], int i)
{
    int temp, start = 0;
    while (start < i)
    {
        temp = arr[start];
        arr[start] = arr[i];
        arr[i] = temp;
        start++;
        i--;
    }
}
 
// Returns index of the
// maximum element in
// arr[0..n-1]
int findMax(int arr[], int n)
{
int mi, i;
for (mi = 0, i = 0; i < n; ++i)
    if (arr[i] > arr[mi])
            mi = i;
return mi;
}
 
// The main function that
// sorts given array using
// flip operations
void pancakeSort(int *arr, int n)
{
    // Start from the complete
    // array and one by one
    // reduce current size
    // by one
    for (int curr_size = n; curr_size > 1;
                               --curr_size)
    {
        // Find index of the
        // maximum element in
        // arr[0..curr_size-1]
        int mi = findMax(arr, curr_size);
 
        // Move the maximum
        // element to end of
        // current array if
        // it's not already
        // at the end
        if (mi != curr_size-1)
        {
            // To move at the end,
            // first move maximum
            // number to beginning
            flip(arr, mi);
 
            // Now move the maximum
            // number to end by
            // reversing current array
            flip(arr, curr_size-1);
        }
    }
}
 
// A utility function to print
// n array of size n
void printArray(int arr[], int n)
{
    for (int i = 0; i < n; ++i)
        cout<< arr[i]<<" ";
}
 
// Driver program to test above function
int main()
{
    int arr[] = {23, 10, 20, 11, 12, 6, 7};
    int n = sizeof(arr)/sizeof(arr[0]);
 
    pancakeSort(arr, n);
 
    cout<<"Sorted Array "<

---

Java

// Java program to
// sort array using
// pancake sort
import java.io.*;
 
class PancakeSort {
 
    /* Reverses arr[0..i] */
    static void flip(int arr[], int i)
    {
        int temp, start = 0;
        while (start < i)
        {
            temp = arr[start];
            arr[start] = arr[i];
            arr[i] = temp;
            start++;
            i--;
        }
    }
 
    // Returns index of the
    // maximum element in
    // arr[0..n-1]
    static int findMax(int arr[], int n)
    {
        int mi, i;
        for (mi = 0, i = 0; i < n; ++i)
            if (arr[i] > arr[mi])
                mi = i;
        return mi;
    }
 
    // The main function that
    // sorts given array using
    // flip operations
    static int pancakeSort(int arr[], int n)
    {
        // Start from the complete
        // array and one by one
        // reduce current size by one
        for (int curr_size = n; curr_size > 1;
                                 --curr_size)
        {
            // Find index of the
            // maximum element in
            // arr[0..curr_size-1]
            int mi = findMax(arr, curr_size);
 
            // Move the maximum element
            // to end of current array
            // if it's not already at
            // the end
            if (mi != curr_size-1)
            {
                // To move at the end,
                // first move maximum
                // number to beginning
                flip(arr, mi);
 
                // Now move the maximum
                // number to end by
                // reversing current array
                flip(arr, curr_size-1);
            }
        }
        return 0;
    }
 
    /* Utility function to print array arr[] */
    static void printArray(int arr[], int arr_size)
    {
        for (int i = 0; i < arr_size; i++)
            System.out.print(arr[i] + " ");
        System.out.println("");
    }
 
    /* Driver function to check for above functions*/
    public static void main (String[] args)
    {
        int arr[] = {23, 10, 20, 11, 12, 6, 7};
        int n = arr.length;
         
        pancakeSort(arr, n);
         
        System.out.println("Sorted Array: ");
        printArray(arr, n);
    }
}
/* This code is contributed by Devesh Agrawal*/

Python3

# Python3 program to
# sort array using
# pancake sort
 
# Reverses arr[0..i] */
def flip(arr, i):
    start = 0
    while start < i:
        temp = arr[start]
        arr[start] = arr[i]
        arr[i] = temp
        start += 1
        i -= 1
 
# Returns index of the maximum
# element in arr[0..n-1] */
def findMax(arr, n):
    mi = 0
    for i in range(0,n):
        if arr[i] > arr[mi]:
            mi = i
    return mi
 
# The main function that
# sorts given array
# using flip operations
def pancakeSort(arr, n):
     
    # Start from the complete
    # array and one by one
    # reduce current size
    # by one
    curr_size = n
    while curr_size > 1:
        # Find index of the maximum
        # element in
        # arr[0..curr_size-1]
        mi = findMax(arr, curr_size)
 
        # Move the maximum element
        # to end of current array
        # if it's not already at
        # the end
        if mi != curr_size-1:
            # To move at the end,
            # first move maximum
            # number to beginning
            flip(arr, mi)
 
            # Now move the maximum
            # number to end by
            # reversing current array
            flip(arr, curr_size-1)
        curr_size -= 1
 
# A utility function to
# print an array of size n
def printArray(arr, n):
    for i in range(0,n):
        print ("%d"%( arr[i]),end=" ")
 
# Driver program
arr = [23, 10, 20, 11, 12, 6, 7]
n = len(arr)
pancakeSort(arr, n);
print ("Sorted Array ")
printArray(arr,n)
 
# This code is contributed by shreyanshi_arun.

C#

// C# program to sort array using
// pancake sort
using System;
 
class GFG {
 
    // Reverses arr[0..i]
    static void flip(int []arr, int i)
    {
        int temp, start = 0;
        while (start < i)
        {
            temp = arr[start];
            arr[start] = arr[i];
            arr[i] = temp;
            start++;
            i--;
        }
    }
 
    // Returns index of the
    // maximum element in
    // arr[0..n-1]
    static int findMax(int []arr, int n)
    {
        int mi, i;
        for (mi = 0, i = 0; i < n; ++i)
            if (arr[i] > arr[mi])
                mi = i;
                 
        return mi;
    }
 
    // The main function that
    // sorts given array using
    // flip operations
    static int pancakeSort(int []arr, int n)
    {
         
        // Start from the complete
        // array and one by one
        // reduce current size by one
        for (int curr_size = n; curr_size > 1;
                                  --curr_size)
        {
             
            // Find index of the
            // maximum element in
            // arr[0..curr_size-1]
            int mi = findMax(arr, curr_size);
 
            // Move the maximum element
            // to end of current array
            // if it's not already at
            // the end
            if (mi != curr_size - 1)
            {
                // To move at the end,
                // first move maximum
                // number to beginning
                flip(arr, mi);
 
                // Now move the maximum
                // number to end by
                // reversing current array
                flip(arr, curr_size - 1);
            }
        }
         
        return 0;
    }
 
    // Utility function to print
    // array arr[]
    static void printArray(int []arr,
                           int arr_size)
    {
        for (int i = 0; i < arr_size; i++)
            Console.Write(arr[i] + " ");
             
        Console.Write("");
    }
 
    // Driver function to check for
    // above functions
    public static void Main ()
    {
        int []arr = {23, 10, 20, 11, 12, 6, 7};
        int n = arr.Length;
         
        pancakeSort(arr, n);
         
        Console.Write("Sorted Array: ");
        printArray(arr, n);
    }
}
 
// This code is contributed by nitin mittal.

PHP

 $arr[$mi])
                $mi = $i;
    return $mi;
}
 
// The main function that
// sorts given array using
// flip operations
function pancakeSort(&$arr, $n)
{
    // Start from the complete
    // array and one by one
    // reduce current size
    // by one
    for ($curr_size = $n; $curr_size > 1;
                              --$curr_size)
    {
        // Find index of the
        // maximum element in
        // arr[0..curr_size-1]
        $mi = findMax($arr, $curr_size);
 
        // Move the maximum
        // element to end of
        // current array if
        // it's not already
        // at the end
        if ($mi != $curr_size-1)
        {
            // To move at the end,
            // first move maximum
            // number to beginning
            flip($arr, $mi);
 
            // Now move the maximum
            // number to end by
            // reversing current array
            flip($arr, $curr_size-1);
        }
    }
}
 
// A utility function to print
// n array of size n
function printArray($arr, $n)
{
    for ($i = 0; $i < $n; ++$i)
        print($arr[$i]." ");
}
 
// Driver code
$arr = array(23, 10, 20, 11, 12, 6, 7);
$n = count($arr);
 
pancakeSort($arr, $n);
 
echo("Sorted Array \n");
printArray($arr, $n);
 
return 0;
     
// This code is contributed by chandan_jnu
?>

输出：

Sorted Array
6 7 10 11 12 20 23