Pancake sorting

Given an unsorted array, the task is to sort the given array. You are allowed to do only following operation on array. 

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

Examples:

Input: arr[] = { 23, 10, 20, 11, 12, 6, 7 }
Output: { 6, 7, 10, 11, 12, 20, 23}

Input: arr[] = { 0, 1, 1, 0, 0 }
Output: { 0, 0, 0, 1, 1 }

Approach: Unlike a traditional sorting algorithm, which attempts to sort with the fewest comparisons possible, the goal is to sort the sequence in as few reversals as possible. 

The idea is to do something similar to Selection Sort. We one by one place maximum element at the end and reduce the size of current array by one. 

Following are the detailed steps. Let given array be arr[] and size of array be n. 

• Start from current size equal to n and reduce current size by one while it's greater than 1. Let the current size be curr_size. 
• Do following for every curr_size
  • Find index of the maximum element in arr[0 to curr_szie-1]. Let the index be 'mi'
  • Call flip(arr, mi)
  • Call flip(arr, curr_size - 1)

See following video for visualization of the above algorithm.
https://www.youtube.com/embed/kk-_DDgoXfk

Below is the implementation:

Sorted Array 
6 7 10 11 12 20 23 

Time Complexity: O(n²), Total O(n) flip operations are performed in above code
Auxiliary Space: O(1)

Recursive Approach 

Another approach to implement pancake sort in C++ is by using a recursive algorithm .

Approach :

Step 1: Define a function to flip a subarray of the given array. This function takes two arguments: the array to be flipped, and the index of the last element of the subarray to be flipped.

Step 2: Define a function to find the index of the maximum element in a given subarray of the array. This function takes two arguments: the array to be searched, and the index of the last element of the subarray to be searched.

Step 3: Iterate over the input array from the end towards the beginning, and for each element i, do the following:

• Find the index of the maximum element in the subarray arr[0:i].
• If the maximum element is not already at the end of the subarray, flip the subarray arr[0:max_index].
• Flip the entire subarray arr[0:i] to move the element i to its correct position.

Step 4: Repeat Step 3 for the subarray arr[0:n-1], arr[0:n-2], ..., arr[0:1] until the entire array is sorted.

Implementation Of above approach:

Sorted Array: 6 7 10 11 12 20 23 

Complexity Analysis:

• The time complexity of pancake sort is O(n²), where n is the size of the input array. The worst case occurs when the input array is reverse sorted. 
• The space complexity is O(1) since the sorting is done in-place.
   

References: 
https://en.wikipedia.org/wiki/Pancake_sorting