Related Articles

# Lexicographical ordering using Heap Sort

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

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 ``#include ``using` `namespace` `std;` `// Used for index in heap``int` `x = -1;` `// Predefining the heap array``string heap;` `// 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;` `        ``// Taking output of``        ``// the minimum element``        ``cout << k << ``" "``;` `        ``// Set first element``        ``// as a last one``        ``heap = 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);` `    ``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;` `// 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;` `        ``// Taking output of``        ``// the minimum element``        ``Console.Write(k + ``" "``);` `        ``// Set first element``        ``// as a last one``        ``heap = 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