# Lexicographical ordering using Heap Sort

• Difficulty Level : Expert
• Last Updated : 28 Mar, 2022

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[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"``, ``"litchi"` `};` `    ``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`

My Personal Notes arrow_drop_up