Sort an Array of Strings in Lexicographical order
Last Updated :
19 Apr, 2025
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 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 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# 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 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 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 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# 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 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.
Similar Reads
Sort an array of strings lexicographically based on prefix Given an array of strings arr[] of size N, the task is to sort the array of strings in lexicographical order and if while sorting for any two string A and string B, if string A is prefix of string B then string B should come in the sorted order. Examples: Input: arr[] = {"sun", "moon", "mock"}Â Outpu
7 min read
Sort a list of strings in lexicographical order in Python We are given a list of strings and our task is to sort them in lexicographical order, which means alphabetical order either from A to Z (ascending) or Z to A (descending). This is a common operation when organizing or comparing strings in Python. For example:Input: ["banana", "apple", "cherry", "dat
2 min read
PHP Sort array of strings in natural and standard orders You are given an array of strings. You have to sort the given array in standard way (case of alphabets matters) as well as natural way (alphabet case does not matter).Input : arr[] = {"Geeks", "for", "geeks"}Output : Standard sorting: Geeks for geeks Natural sorting: for Geeks geeks Input : arr[] =
2 min read
Sort a string lexicographically by reversing a substring Given a string S consisting of N lowercase characters, the task is to find the starting and the ending indices ( 0-based indexing ) of the substring of the given string S that needed to be reversed to make the string S sorted. If it is not possible to sort the given string S by reversing any substri
12 min read
Sort file names in lexicographical order of their extensions Given an array of strings Files[], representing name of some files, the task is to sort the array based on the lexicographical order of the extensions of the file names. If more than one files have the same extension, then sort them in lexicographically. Examples: Input: files[] = {"ajay.cpp", "pchy
4 min read
Lexicographical concatenation of all substrings of a string Given a string, find the concatenation of all substrings in lexicographic order.Examples:Input : s = "abc"Output : aababcbbccThe substrings of s in lexicographic order are "a", "b", "c", "ab", "abc", "bc". Concatenation of substrings is "a"+"ab"+"abc"+"b"+"bc"+"c" = "aababcbbcc".Input : s = "cba"Out
7 min read
Lexicographic rank of a string using STL You are given a string, find its rank among all its permutations sorted lexicographically. Examples:Input : str[] = "acb"Output : Rank = 2Input : str[] = "string"Output : Rank = 598Input : str[] = "cba"Output : Rank = 6We have already discussed solutions to find Lexicographic rank of string In this
4 min read
Lexicographic rank of a string among all its substrings Given string str, the task is to find the rank of the given string among all its substrings arranged lexicographically. Examples: Input: S = "enren"Output: 7Explanation:All the possible substrings in the sorted order are {"e", "e", "en", "en", "enr", "enre", "enren", "n", "n", "nr", "nre", "nren", "
10 min read
How to sort an Array of Strings in Java Array Of StringsTo sort an array of strings in Java, we can use Arrays.sort() function. Java // A sample Java program to // sort an array of strings // in ascending and descending // orders using Arrays.sort(). import java.util.Arrays; import java.util.Collections; // Driver Class public class SortE
3 min read
Lexicographic rank of a String Given a string str, find its rank among all its permutations when sorted lexicographically.Note: The characters in string are all unique.Examples:Input: str = "acb"Output: 2Explanation: If all the permutations of the string are arranged lexicographically they will be "abc", "acb", "bac", "bca", "cab
15+ min read