Pancake Sorting in Java

In this section, we will learn about pancake sorting in Java. In pancake sorting, one has to sort the array by performing only one operation, and that operation is:

flipArr(arr, j): Reverse the array arr from index 0 to j.

Generally, in other sorting algorithms, the attempt is to sort the elements of an array with minimum comparisons of elements. However, in pancake sorting, we focus on sorting the elements of the array with the minimum reversals.

Steps Involved in Pancake Sorting

The following are the steps involved in pancake sorting.

Begin from the current size, which is equal to s and then reduce the current size by 1 while it is more than 1. Suppose the current size is represented by the currSize. Now, do the following for each and every currSize.
- Search of the index where the maximum element sits in the arr[0… currSize - 1]. Suppose that index be 'idx'
- Invoke flipArr(arr, idx)
- Invoke flipArr(arr, currSize - 1)

Implementation

The following code shows the implementation of pancake sorting using the steps defined above.

FileName: PancakeSortingExample.java

public class PancakeSortingExample 
{
// Reverses arr[0 ... j] 
public void flipArr(int arr[], int j)
{
int t, begin = 0;
while (begin < j)
{
t = arr[begin];
arr[begin] = arr[j];
arr[j] = t;
begin = begin + 1;
j = j - 1;
}
}
// Returning the index of the
// element, which is maximum in
// arr[0 ... s - 1]
public int findMax(int arr[], int s)
{
int idx, j;
for (idx = 0, j = 0; j < s; ++j)
{
if (arr[j] > arr[idx])
{
idx = j;
}
}
return idx;
}
// The main method that sorts the given array 
// using the flip operations
public int pancakeSorting(int arr[], int s)
{
// Starting from the complete
// array and one by one
// reducing the current size by 1
for (int currSize = s; currSize > 1; --currSize)
{
// Find index of the
// maximum element in
// arr[0..curr_size-1]
int idx = findMax(arr, currSize);
// Moving the maximum element
// to the end of the current array
// if it is not already at te end
if (idx != currSize - 1)
{
// To move at the end,
// first we have to move the maximum
// element to the beginning
flipArr(arr, idx);
// Now, we are moving the maximum number to end by
// reversing the current array
flipArr(arr, currSize - 1);
}
}
return 0;
}
// a utility method to display the array arr[]
public void displayArray(int arr[], int s)
{
for (int j = 0; j < s; j++)
{
System.out.print(arr[j] + " ");
}
System.out.println("");
}
// main method 
public static void main (String argvs[])
{
int arr[] = {23, 100, 210, 101, 112, 66, 27, 67, 809};
int s = arr.length;

// creating an object of the class PancakeSortingExample
PancakeSortingExample obj = new PancakeSortingExample();
System.out.println("Input Array is: ");
obj.displayArray(arr, s);
obj.pancakeSorting(arr, s);
System.out.println(" \nAfter sorting the array is: ");
obj.displayArray(arr, s);
}
}

Output:

Input Array is: 
23 100 210 101 112 66 27 67 809 

After sorting the array is: 
23 27 66 67 100 101 112 210 809

Explanation:

We have done something similar to Selection Sort. We put the maximum element at the last of the array, and then we have reduced the current size of the array by 1. The reduction of the current size continues till the whole array gets sorted.

Next TopicPrint Matrix Diagonally in Java

← prev next →