Lexicographical ordering using Heap Sort

Given an array arr[] of strings. The task is to sort the array in lexicographical order using Heap Sort.

Examples:

Input: arr[] = { “banana”, “apple”, “mango”, “pineapple”, “orange” }
Output: apple banana mango orange pineapple



Input: arr[] = { “CAB”, “ACB”, “ABC”, “CBA”, “BAC” }
Output: ABC, ACB, BAC, BCA, CAB, CBA

Approach: The basic idea is to use Heap sort and here the min-heap is being used to print in the lexicographical order.

Below is the implementation of the approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation to print
// the string in Lexicographical order
#include <iostream>
#include <string>
using namespace std;
  
// Used for index in heap
int x = -1;
  
// Predefining the heap array
string heap[1000];
  
// Defining formation of the heap
void heapForm(string k)
{
    x++;
  
    heap[x] = k;
  
    int child = x;
  
    string tmp;
  
    int index = x / 2;
  
    // Iterative heapiFy
    while (index >= 0) {
  
        // Just swapping if the element
        // is smaller than already
        // stored element
        if (heap[index] > heap[child]) {
  
            // Swapping the current index
            // with its child
            tmp = heap[index];
            heap[index] = heap[child];
            heap[child] = tmp;
            child = index;
  
            // Moving upward in the
            // heap
            index = index / 2;
        }
        else {
            break;
        }
    }
}
  
// Defining heap sort
void heapSort()
{
    int left1, right1;
  
    while (x >= 0) {
        string k;
        k = heap[0];
  
        // Taking output of
        // the minimum element
        cout << k << " ";
  
        // Set first element
        // as a last one
        heap[0] = heap[x];
  
        // Decrement of the
        // size of the string
        x = x - 1;
  
        string tmp;
  
        int index = 0;
  
        int length = x;
  
        // Initilizing the left
        // and right index
        left1 = 1;
  
        right1 = left1 + 1;
  
        while (left1 <= length) {
  
            // Process of heap sort
            // If root element is
            // minimum than its both
            // of the child then break
            if (heap[index] <= heap[left1]
                && heap[index] <= heap[right1]) {
                break;
            }
  
            // Otherwise checking that
            // the child which one is
            // smaller, swap them with
            // parent element
            else {
  
                // Swapping
                if (heap[left1] < heap[right1]) {
                    tmp = heap[index];
                    heap[index] = heap[left1];
                    heap[left1] = tmp;
                    index = left1;
                }
  
                else {
                    tmp = heap[index];
                    heap[index] = heap[right1];
                    heap[right1] = tmp;
                    index = right1;
                }
            }
  
            // Changing the left index
            // and right index
            left1 = 2 * left1;
            right1 = left1 + 1;
        }
    }
}
  
// Utility function
void sort(string k[], int n)
{
  
    // To heapiFy
    for (int i = 0; i < n; i++) {
        heapForm(k[i]);
    }
  
    // Calling heap sort function
    heapSort();
}
  
// Driver Code
int main()
{
    string arr[] = { "banana", "orange", "apple",
                   "pineapple", "berries", "lichi" };
  
    int n = sizeof(arr) / sizeof(arr[0]);
  
    sort(arr, n);
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation to print
// the string in Lexicographical order
class GFG
{
  
// Used for index in heap
static int x = -1;
  
// Predefining the heap array
static String []heap = new String[1000];
  
// Defining formation of the heap
static void heapForm(String k)
{
    x++;
  
    heap[x] = k;
  
    int child = x;
  
    String tmp;
  
    int index = x / 2;
  
    // Iterative heapiFy
    while (index >= 0
    {
  
        // Just swapping if the element
        // is smaller than already
        // stored element
        if (heap[index].compareTo(heap[child]) > 0
        {
  
            // Swapping the current index
            // with its child
            tmp = heap[index];
            heap[index] = heap[child];
            heap[child] = tmp;
            child = index;
  
            // Moving upward in the
            // heap
            index = index / 2;
        }
        else 
        {
            break;
        }
    }
}
  
// Defining heap sort
static void heapSort()
{
    int left1, right1;
  
    while (x >= 0)
    {
        String k;
        k = heap[0];
  
        // Taking output of
        // the minimum element
        System.out.print(k + " ");
  
        // Set first element
        // as a last one
        heap[0] = heap[x];
  
        // Decrement of the
        // size of the string
        x = x - 1;
  
        String tmp;
  
        int index = 0;
  
        int length = x;
  
        // Initilizing the left
        // and right index
        left1 = 1;
  
        right1 = left1 + 1;
  
        while (left1 <= length) 
        {
  
            // Process of heap sort
            // If root element is
            // minimum than its both
            // of the child then break
            if (heap[index].compareTo(heap[left1]) <= 0 && 
                heap[index].compareTo(heap[right1]) <= 0)
            {
                break;
            }
  
            // Otherwise checking that
            // the child which one is
            // smaller, swap them with
            // parent element
            else
            {
  
                // Swapping
                if (heap[left1].compareTo(heap[right1])< 0)
                {
                    tmp = heap[index];
                    heap[index] = heap[left1];
                    heap[left1] = tmp;
                    index = left1;
                }
  
                else 
                {
                    tmp = heap[index];
                    heap[index] = heap[right1];
                    heap[right1] = tmp;
                    index = right1;
                }
            }
  
            // Changing the left index
            // and right index
            left1 = 2 * left1;
            right1 = left1 + 1;
        }
    }
}
  
// Utility function
static void sort(String k[], int n)
{
  
    // To heapiFy
    for (int i = 0; i < n; i++) 
    {
        heapForm(k[i]);
    }
  
    // Calling heap sort function
    heapSort();
}
  
// Driver Code
public static void main(String[] args)
{
    String arr[] = {"banana", "orange", "apple",
                    "pineapple", "berries", "lichi" };
  
    int n = arr.length;
  
    sort(arr, n);
}
  
// This code is contributed by Rajput-Ji

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 implementation to print
# the string in Lexicographical order
  
# Used for index in heap
x = -1;
  
# Predefining the heap array
heap = [0] * 1000;
  
# Defining formation of the heap
def heapForm(k):
    global x;
    x += 1;
  
    heap[x] = k;
  
    child = x;
  
    index = x // 2;
  
    # Iterative heapiFy
    while (index >= 0):
  
        # Just swapping if the element
        # is smaller than already
        # stored element
        if (heap[index] > heap[child]):
  
            # Swapping the current index
            # with its child
            tmp = heap[index];
            heap[index] = heap[child];
            heap[child] = tmp;
            child = index;
  
            # Moving upward in the
            # heap
            index = index // 2;
  
        else:
            break;
  
# Defining heap sort
def heapSort():
    global x;
    while (x >= 0):
        k = heap[0];
  
        # Taking output of
        # the minimum element
        print(k, end = " ");
  
        # Set first element
        # as a last one
        heap[0] = heap[x];
  
        # Decrement of the
        # size of the string
        x = x - 1;
  
        tmp = -1;
  
        index = 0;
  
        length = x;
  
        # Initilizing the left
        # and right index
        left1 = 1;
  
        right1 = left1 + 1;
  
        while (left1 <= length):
  
            # Process of heap sort
            # If root element is
            # minimum than its both
            # of the child then break
            if (heap[index] <= heap[left1] and 
                heap[index] <= heap[right1]):
                break;
  
            # Otherwise checking that
            # the child which one is
            # smaller, swap them with
            # parent element
            else:
  
                # Swapping
                if (heap[left1] < heap[right1]):
                    tmp = heap[index];
                    heap[index] = heap[left1];
                    heap[left1] = tmp;
                    index = left1;
  
                else:
                    tmp = heap[index];
                    heap[index] = heap[right1];
                    heap[right1] = tmp;
                    index = right1;
  
            # Changing the left index
            # and right index
            left1 = 2 * left1;
            right1 = left1 + 1;
  
# Utility function
def sort(k, n):
      
    # To heapiFy
    for i in range(n):
        heapForm(k[i]);
  
    # Calling heap sort function
    heapSort();
  
# Driver Code
if __name__ == '__main__':
    arr = ["banana", "orange", "apple",
           "pineapple", "berries", "lichi"];
  
    n = len(arr);
  
    sort(arr, n);
  
# This code is contributed by PrinciRaj1992

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation to print
// the string in Lexicographical order
using System;
      
class GFG
{
  
// Used for index in heap
static int x = -1;
  
// Predefining the heap array
static String []heap = new String[1000];
  
// Defining formation of the heap
static void heapForm(String k)
{
    x++;
  
    heap[x] = k;
  
    int child = x;
  
    String tmp;
  
    int index = x / 2;
  
    // Iterative heapiFy
    while (index >= 0) 
    {
  
        // Just swapping if the element
        // is smaller than already
        // stored element
        if (heap[index].CompareTo(heap[child]) > 0) 
        {
  
            // Swapping the current index
            // with its child
            tmp = heap[index];
            heap[index] = heap[child];
            heap[child] = tmp;
            child = index;
  
            // Moving upward in the
            // heap
            index = index / 2;
        }
        else
        {
            break;
        }
    }
}
  
// Defining heap sort
static void heapSort()
{
    int left1, right1;
  
    while (x >= 0)
    {
        String k;
        k = heap[0];
  
        // Taking output of
        // the minimum element
        Console.Write(k + " ");
  
        // Set first element
        // as a last one
        heap[0] = heap[x];
  
        // Decrement of the
        // size of the string
        x = x - 1;
  
        String tmp;
  
        int index = 0;
  
        int length = x;
  
        // Initilizing the left
        // and right index
        left1 = 1;
  
        right1 = left1 + 1;
  
        while (left1 <= length) 
        {
  
            // Process of heap sort
            // If root element is
            // minimum than its both
            // of the child then break
            if (heap[index].CompareTo(heap[left1]) <= 0 && 
                heap[index].CompareTo(heap[right1]) <= 0)
            {
                break;
            }
  
            // Otherwise checking that the child 
            // which one is smaller, swap them with
            // parent element
            else
            {
  
                // Swapping
                if (heap[left1].CompareTo(heap[right1]) < 0)
                {
                    tmp = heap[index];
                    heap[index] = heap[left1];
                    heap[left1] = tmp;
                    index = left1;
                }
  
                else
                {
                    tmp = heap[index];
                    heap[index] = heap[right1];
                    heap[right1] = tmp;
                    index = right1;
                }
            }
  
            // Changing the left index
            // and right index
            left1 = 2 * left1;
            right1 = left1 + 1;
        }
    }
}
  
// Utility function
static void sort(String []k, int n)
{
  
    // To heapiFy
    for (int i = 0; i < n; i++) 
    {
        heapForm(k[i]);
    }
  
    // Calling heap sort function
    heapSort();
}
  
// Driver Code
public static void Main(String[] args)
{
    String []arr = {"banana", "orange", "apple",
                    "pineapple", "berries", "lichi" };
  
    int n = arr.Length;
  
    sort(arr, n);
}
  
// This code is contributed by Rajput-Ji

chevron_right


Output:

apple banana berries lichi orange pineapple


My Personal Notes arrow_drop_up

Computer science engeineering student from IIIT,kalyani

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Improved By : Rajput-Ji, princiraj1992