Skip to content
Related Articles

Related Articles

Improve Article

Lexicographical ordering using Heap Sort

  • Difficulty Level : Expert
  • Last Updated : 29 Aug, 2021
Geek Week

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++




// 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;
 
        // Initializing 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);
}

Java




// 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;
 
        // Initializing 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

Python3




# 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;
 
        # Initializing 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

C#




// 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;
 
        // Initializing 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
Output: 
apple banana berries lichi orange pineapple

 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :