Open In App

Sort an Array of Strings in Lexicographical order

Last Updated : 19 Apr, 2025
Comments
Improve
Suggest changes
Like Article
Like
Report

Given an array of strings arr[] of size n, the task is to sort all the strings in lexicographical order.

Examples:

Input: arr[] = [“banana”, “apple”, “cherry”]
Output: [“apple”, “banana”, “cherry”]
Explanation: All strings are sorted alphabetically. “apple” comes before “banana”, and “banana” before “cherry”.

Input: arr[] = [“dog”, “cat”, “bat”]
Output: [“bat”, “cat”, “dog”]
Explanation: “bat” is the smallest, followed by “cat”, and then “dog” in lexicographical order.

Input: arr[] = [“geeks”, “for”, “geeksforgeeks”] 
Output: [“for”, “geeks”, “geeksforgeeks”]

Using Inbuilt Sort – O(n*m*log(n)) Time and O(1) Space [m : Average Length]

The idea is to use inbuilt sort function that are optimized and handle string comparisons character by character. This eliminates the need for writing custom comparison logic. Strings are sorted based on their ASCII values, where uppercase letters come before lowercase.

C++ 
// C++ program to sort strings in lexicographical
//  order Using Inbuilt Sort
#include <bits/stdc++.h>
using namespace std;

// Function to sort strings lexicographically
vector<string> sortStrings(vector<string>& arr) {

    // Use inbuilt sort to arrange strings
    sort(arr.begin(), arr.end());

    return arr;
}

// Function to print the result in required format
void printArray(vector<string>& arr) {
    cout << "[";
    for (int i = 0; i < arr.size(); i++) {
        cout << arr[i];
        if (i < arr.size() - 1) {
            cout << ", ";
        }
    }
    cout << "]";
}

// Driver code
int main() {

    vector<string> arr = {"geeksforgeeks", "geeks", "for"};

    vector<string> res = sortStrings(arr);

    printArray(res);

    return 0;
}
Java 
// Java program to sort strings in lexicographical
// order Using Inbuilt Sort
import java.util.*;

class GfG {

    // Function to sort strings lexicographically
    static String[] sortStrings(String[] arr) {

        // Use inbuilt sort to arrange strings
        Arrays.sort(arr);

        return arr;
    }

    // Function to print the result in required format
    static void printArray(String[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);
            if (i < arr.length - 1) {
                System.out.print(", ");
            }
        }
        System.out.print("]");
    }

    // Driver code
    public static void main(String[] args) {

        String[] arr = {"geeksforgeeks", "geeks", "for"};

        String[] res = sortStrings(arr);

        printArray(res);
    }
}
Python 
# Python program to sort strings in lexicographical
# order Using Inbuilt Sort

# Function to sort strings lexicographically
def sortStrings(arr):

    # Use inbuilt sort to arrange strings
    arr.sort()

    return arr

# Function to print the result in required format
def printArray(arr):
    print("[", end="")
    for i in range(len(arr)):
        print(arr[i], end="")
        if i < len(arr) - 1:
            print(", ", end="")
    print("]")

# Driver code
if __name__ == '__main__':

    arr = ["geeksforgeeks", "geeks", "for"]

    res = sortStrings(arr)

    printArray(res)
C# 
// C# program to sort strings in lexicographical
// order Using Inbuilt Sort
using System;

class GfG {

    // Function to sort strings lexicographically
    public static string[] sortStrings(string[] arr) {

        // Use inbuilt sort to arrange strings
        Array.Sort(arr);

        return arr;
    }

    // Function to print the result in required format
    public static void printArray(string[] arr) {
        Console.Write("[");
        for (int i = 0; i < arr.Length; i++) {
            Console.Write(arr[i]);
            if (i < arr.Length - 1) {
                Console.Write(", ");
            }
        }
        Console.Write("]");
    }

    // Driver code
    public static void Main() {

        string[] arr = {"geeksforgeeks", "geeks", "for"};

        string[] res = sortStrings(arr);

        printArray(res);
    }
}
JavaScript 
// JavaScript program to sort strings in lexicographical
// order Using Inbuilt Sort

// Function to sort strings lexicographically
function sortStrings(arr) {

    // Use inbuilt sort to arrange strings
    arr.sort();

    return arr;
}

// Function to print the result in required format
function printArray(arr) {
    let output = "[";
    for (let i = 0; i < arr.length; i++) {
        output += arr[i];
        if (i < arr.length - 1) {
            output += ", ";
        }
    }
    output += "]";
    console.log(output);
}

// Driver code
let arr = ["geeksforgeeks", "geeks", "for"];

let res = sortStrings(arr);

printArray(res);

Output
[for, geeks, geeksforgeeks]

Time Complexity: O(n*m*log(n)), where n is number of strings, m is average length.
Space Complexity: O(1), in-place sort uses constant extra space.

Using Merge Sort – O(n*m*log(n)) Time and O(n) Space

The idea is to sort a list of strings in lexicographical order using the Merge Sort technique. The thought process is based on divide-and-conquer, where the array is recursively divided until single elements remain.

C++ 
// C++ program to sort strings in lexicographical
// order using Merge Sort
#include <bits/stdc++.h>
using namespace std;

// Merge two sorted halves
void merge(vector<string>& arr, int left, 
                     int mid, int right) {

    int n1 = mid - left + 1;
    int n2 = right - mid;

    vector<string> leftArr(n1);
    vector<string> rightArr(n2);

    // Copy data to temporary arrays
    for (int i = 0; i < n1; i++) {
        leftArr[i] = arr[left + i];
    }
    for (int j = 0; j < n2; j++) {
        rightArr[j] = arr[mid + 1 + j];
    }

    int i = 0, j = 0, k = left;

    // Merge the two arrays back into arr
    while (i < n1 && j < n2) {
        if (leftArr[i] <= rightArr[j]) {
            arr[k++] = leftArr[i++];
        } else {
            arr[k++] = rightArr[j++];
        }
    }

    // Copy remaining elements
    while (i < n1) {
        arr[k++] = leftArr[i++];
    }
    while (j < n2) {
        arr[k++] = rightArr[j++];
    }
}

// Recursive merge sort function
void mergeSort(vector<string>& arr, int left, int right) {
    
    if (left < right) {
        int mid = left + (right - left) / 2;

        // Sort first and second halves
        mergeSort(arr, left, mid);
        mergeSort(arr, mid + 1, right);

        // Merge sorted halves
        merge(arr, left, mid, right);
    }
}

// Function to sort strings lexicographically
vector<string> sortStrings(vector<string>& arr) {
    mergeSort(arr, 0, arr.size() - 1);
    return arr;
}

// Function to print the result in required format
void printArray(vector<string>& arr) {
    cout << "[";
    for (int i = 0; i < arr.size(); i++) {
        cout << arr[i];
        if (i < arr.size() - 1) {
            cout << ", ";
        }
    }
    cout << "]";
}

// Driver code
int main() {

    vector<string> arr = {"geeksforgeeks", "geeks", "for"};

    vector<string> res = sortStrings(arr);

    printArray(res);

    return 0;
}
Java 
// Java program to sort strings in lexicographical
// order using Merge Sort
import java.util.*;

class GfG {

    // Merge two sorted halves
    static void merge(String[] arr, int left,
                      int mid, int right) {

        int n1 = mid - left + 1;
        int n2 = right - mid;

        String[] leftArr = new String[n1];
        String[] rightArr = new String[n2];

        // Copy data to temporary arrays
        for (int i = 0; i < n1; i++) {
            leftArr[i] = arr[left + i];
        }
        for (int j = 0; j < n2; j++) {
            rightArr[j] = arr[mid + 1 + j];
        }

        int i = 0, j = 0, k = left;

        // Merge the two arrays back into arr
        while (i < n1 && j < n2) {
            if (leftArr[i].compareTo(rightArr[j]) <= 0) {
                arr[k++] = leftArr[i++];
            } else {
                arr[k++] = rightArr[j++];
            }
        }

        // Copy remaining elements
        while (i < n1) {
            arr[k++] = leftArr[i++];
        }
        while (j < n2) {
            arr[k++] = rightArr[j++];
        }
    }

    // Recursive merge sort function
    static void mergeSort(String[] arr, int left, int right) {

        if (left < right) {
            int mid = left + (right - left) / 2;

            // Sort first and second halves
            mergeSort(arr, left, mid);
            mergeSort(arr, mid + 1, right);

            // Merge sorted halves
            merge(arr, left, mid, right);
        }
    }

    // Function to sort strings lexicographically
    static String[] sortStrings(String[] arr) {
        mergeSort(arr, 0, arr.length - 1);
        return arr;
    }

    // Function to print the result in required format
    static void printArray(String[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);
            if (i < arr.length - 1) {
                System.out.print(", ");
            }
        }
        System.out.print("]");
    }

    public static void main(String[] args) {

        String[] arr = {"geeksforgeeks", "geeks", "for"};

        String[] res = sortStrings(arr);

        printArray(res);
    }
}
Python 
# Python program to sort strings in lexicographical
# order using Merge Sort

# Merge two sorted halves
def merge(arr, left, mid, right):

    n1 = mid - left + 1
    n2 = right - mid

    leftArr = arr[left:left + n1]
    rightArr = arr[mid + 1:mid + 1 + n2]

    i = j = 0
    k = left

    # Merge the two arrays back into arr
    while i < n1 and j < n2:
        if leftArr[i] <= rightArr[j]:
            arr[k] = leftArr[i]
            i += 1
        else:
            arr[k] = rightArr[j]
            j += 1
        k += 1

    # Copy remaining elements
    while i < n1:
        arr[k] = leftArr[i]
        i += 1
        k += 1

    while j < n2:
        arr[k] = rightArr[j]
        j += 1
        k += 1

# Recursive merge sort function
def mergeSort(arr, left, right):

    if left < right:
        mid = left + (right - left) // 2

        # Sort first and second halves
        mergeSort(arr, left, mid)
        mergeSort(arr, mid + 1, right)

        # Merge sorted halves
        merge(arr, left, mid, right)

# Function to sort strings lexicographically
def sortStrings(arr):
    mergeSort(arr, 0, len(arr) - 1)
    return arr

# Function to print the result in required format
def printArray(arr):
    print("[", end="")
    for i in range(len(arr)):
        print(arr[i], end="")
        if i < len(arr) - 1:
            print(", ", end="")
    print("]")

# Driver code
if __name__ == '__main__':

    arr = ["geeksforgeeks", "geeks", "for"]

    res = sortStrings(arr)

    printArray(res)
C# 
// C# program to sort strings in lexicographical
// order using Merge Sort
using System;

class GfG {

    // Merge two sorted halves
    static void merge(string[] arr, int left,
                      int mid, int right) {

        int n1 = mid - left + 1;
        int n2 = right - mid;

        string[] leftArr = new string[n1];
        string[] rightArr = new string[n2];

        // Copy data to temporary arrays
        for (int i = 0; i < n1; i++) {
            leftArr[i] = arr[left + i];
        }
        for (int j = 0; j < n2; j++) {
            rightArr[j] = arr[mid + 1 + j];
        }

        int k = left, x = 0, y = 0;

        // Merge the two arrays back into arr
        while (x < n1 && y < n2) {
            if (String.Compare(leftArr[x], rightArr[y]) <= 0) {
                arr[k++] = leftArr[x++];
            } else {
                arr[k++] = rightArr[y++];
            }
        }

        // Copy remaining elements
        while (x < n1) {
            arr[k++] = leftArr[x++];
        }
        while (y < n2) {
            arr[k++] = rightArr[y++];
        }
    }

    // Recursive merge sort function
    static void mergeSort(string[] arr, int left, int right) {

        if (left < right) {
            int mid = left + (right - left) / 2;

            // Sort first and second halves
            mergeSort(arr, left, mid);
            mergeSort(arr, mid + 1, right);

            // Merge sorted halves
            merge(arr, left, mid, right);
        }
    }

    // Function to sort strings lexicographically
    static string[] sortStrings(string[] arr) {
        mergeSort(arr, 0, arr.Length - 1);
        return arr;
    }

    // Function to print the result in required format
    static void printArray(string[] arr) {
        Console.Write("[");
        for (int i = 0; i < arr.Length; i++) {
            Console.Write(arr[i]);
            if (i < arr.Length - 1) {
                Console.Write(", ");
            }
        }
        Console.Write("]");
    }

    static void Main() {

        string[] arr = {"geeksforgeeks", "geeks", "for"};

        string[] res = sortStrings(arr);

        printArray(res);
    }
}
JavaScript 
// JavaScript program to sort strings in lexicographical
// order using Merge Sort

// Merge two sorted halves
function merge(arr, left, mid, right) {

    let n1 = mid - left + 1;
    let n2 = right - mid;

    let leftArr = arr.slice(left, left + n1);
    let rightArr = arr.slice(mid + 1, mid + 1 + n2);

    let i = 0, j = 0, k = left;

    // Merge the two arrays back into arr
    while (i < n1 && j < n2) {
        if (leftArr[i] <= rightArr[j]) {
            arr[k++] = leftArr[i++];
        } else {
            arr[k++] = rightArr[j++];
        }
    }

    // Copy remaining elements
    while (i < n1) {
        arr[k++] = leftArr[i++];
    }

    while (j < n2) {
        arr[k++] = rightArr[j++];
    }
}

// Recursive merge sort function
function mergeSort(arr, left, right) {

    if (left < right) {
        let mid = Math.floor(left + (right - left) / 2);

        // Sort first and second halves
        mergeSort(arr, left, mid);
        mergeSort(arr, mid + 1, right);

        // Merge sorted halves
        merge(arr, left, mid, right);
    }
}

// Function to sort strings lexicographically
function sortStrings(arr) {
    mergeSort(arr, 0, arr.length - 1);
    return arr;
}

// Function to print the result in required format
function printArray(arr) {
    let output = "[";
    for (let i = 0; i < arr.length; i++) {
        output += arr[i];
        if (i < arr.length - 1) {
            output += ", ";
        }
    }
    output += "]";
    console.log(output);
}

// Driver code
let arr = ["geeksforgeeks", "geeks", "for"];

let res = sortStrings(arr);

printArray(res);

Output
[for, geeks, geeksforgeeks]

Time Complexity: O(n*m*log(n)), where n is number of strings, m is average length.
Space Complexity: O(n), extra space used during merge process.



Next Article
Difference Between heapq and PriorityQueue in Python

A
aashutoshparoha
Improve
Article Tags :
Practice Tags :

Similar Reads

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox