Sort an Array of Strings in Lexicographical order
Last Updated :
19 Apr, 2025
Improve
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++ 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++ 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.
