Open In App

Sort string of characters

Improve
Improve
Like Article
Like
Save
Share
Report

Given a string of lowercase characters from ‘a’ – ‘z’. We need to write a program to print the characters of this string in sorted order.

Examples: 

Input : bbccdefbbaa 
Output : aabbbbccdef
Input : geeksforgeeks
Output : eeeefggkkorss

Recommended Practice

A simple approach will be to use sorting algorithms like quick sort or merge sort and sort the input string and print it. 

Implementation:

C++




// C++ program to sort a string of characters
#include<bits/stdc++.h>
using namespace std;
 
// function to print string in sorted order
void sortString(string &str)
{
   sort(str.begin(), str.end());
   cout << str;
}
 
// Driver program to test above function
int main()
{
    string s = "geeksforgeeks";
    sortString(s);
    return 0;
}


C




#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
// comparison function for qsort
int compare(const void *a, const void *b)
{
    return (*(char *)a - *(char *)b);
}
 
// function to print string in sorted order
void sortString(char *str)
{
    int n = strlen(str);
    qsort(str, n, sizeof(char), compare);
    printf("%s", str);
}
 
// Driver program to test above function
int main()
{
    char s[] = "geeksforgeeks";
    sortString(s);
    return 0;
}


Java




// Java program to sort a string of characters
 
import java.util.Arrays;
 
class GFG {
 
// function to print string in sorted order
    static void sortString(String str) {
        char []arr = str.toCharArray();
        Arrays.sort(arr);
        System.out.print(String.valueOf(arr));
    }
 
// Driver program to test above function
    public static void main(String[] args) {
        String s = "geeksforgeeks";
        sortString(s);
    }
}
// This code is contributed by Rajput-Ji


C#




// C# program to sort a string of characters
using System;   
public class GFG {
 
// function to print string in sorted order
    static void sortString(String str) {
        char []arr = str.ToCharArray();
        Array.Sort(arr);
        Console.WriteLine(String.Join("",arr));
    }
 
// Driver program to test above function
    public static void Main() {
        String s = "geeksforgeeks";
        sortString(s);
    }
}
// This code is contributed by 29AjayKumar


Javascript




<script>
    // javascript program to sort a string of characters
 
    let MAX_CHAR = 26;
 
    // function to print string in sorted order
    function sortString(str)
    {
     
        // Hash array to keep count of characters.
        // Initially count of all characters is
        // initialized to zero.
        let charCount = new Array(MAX_CHAR);
        charCount.fill(0);
 
        // Traverse string and increment
        // count of characters
        for (let i = 0; i < str.length; i++)
 
            // 'a'-'a' will be 0, 'b'-'a' will be 1,
            // so for location of character in count
            // array we will do str[i]-'a'.
            charCount[str[i].charCodeAt()-'a'.charCodeAt()]++;   
 
        // Traverse the hash array and print
        // characters
        for (let i=0;i<MAX_CHAR;i++)
            for (let j=0;j<charCount[i];j++)
                 document.write(String.fromCharCode('a'.charCodeAt()+i) );
    }
 
    let s = "geeksforgeeks";   
    sortString(s);   
     
    // This code is contributed by vaibhavrabadiya117.
</script>


Python3




# Python3 program to sort a string
# of characters
 
# function to print string in
# sorted order
def sortString(str) :
    str = ''.join(sorted(str))
    print(str)
 
# Driver Code
s = "geeksforgeeks"
sortString(s)
 
# This code is contributed by Smitha


Output

eeeefggkkorss

Time Complexity: O(n log n), where n is the length of string.
Auxiliary Space: O( 1 ).

An efficient approach will be to observe first that there can be a total of 26 unique characters only. So, we can store the count of occurrences of all the characters from ‘a’ to ‘z’ in a hashed array. The first index of the hashed array will represent character ‘a’, second will represent ‘b’ and so on. Finally, we will simply traverse the hashed array and print the characters from ‘a’ to ‘z’ the number of times they occurred in input string.

Below is the implementation of above idea: 

Implementation:

C++




// C++ program to sort a string of characters
#include<bits/stdc++.h>
using namespace std;
 
const int MAX_CHAR = 26;
 
// function to print string in sorted order
void sortString(string &str)
{
    // Hash array to keep count of characters.
    // Initially count of all characters is
    // initialized to zero.
    int charCount[MAX_CHAR] = {0};
     
    // Traverse string and increment
    // count of characters
    for (int i=0; i<str.length(); i++)
 
        // 'a'-'a' will be 0, 'b'-'a' will be 1,
        // so for location of character in count
        // array we will do str[i]-'a'.
        charCount[str[i]-'a']++;   
     
    // Traverse the hash array and print
    // characters
    for (int i=0;i<MAX_CHAR;i++)
        for (int j=0;j<charCount[i];j++)
            cout << (char)('a'+i);
}
 
// Driver program to test above function
int main()
{
    string s = "geeksforgeeks";   
    sortString(s);   
    return 0;
}


C




// C program to sort a string of characters
#include <stdio.h>
#include <string.h>
 
// function to swap two characters in the string
void swap(char* a, char* b)
{
    char temp = *a;
    *a = *b;
    *b = temp;
}
 
// function to partition the string and return the pivot
// index
int partition(char* str, int low, int high)
{
    char pivot = str[high]; // choose the last character as
                            // the pivot
    int i = low - 1; // index of the smaller element
 
    // loop through the sub-array to partition it around the
    // pivot
    for (int j = low; j <= high - 1; j++) {
        // if the current character is smaller than or equal
        // to the pivot
        if (str[j] <= pivot) {
            i++; // increment the index of the smaller
                 // element
            swap(&str[i], &str[j]); // swap the current
                                    // character with str[i]
        }
    }
    swap(&str[i + 1],
         &str[high]); // swap the pivot with str[i + 1]
    return i + 1; // return the pivot index
}
 
// function to sort the string using the Quick Sort
// algorithm
void quickSort(char* str, int low, int high)
{
    if (low < high) {
        int pivotIndex = partition(
            str, low, high); // partition the string and get
                             // the pivot index
        quickSort(str, low,
                  pivotIndex
                      - 1); // sort the left sub-array
        quickSort(str, pivotIndex + 1,
                  high); // sort the right sub-array
    }
}
 
int main()
{
    char str[] = "geeksforgeeks";
    int n = strlen(str);
 
    quickSort(str, 0, n - 1);
 
    printf("Sorted string: %s\n", str);
    return 0;
}


Java




// Java program to sort
// a string of characters
public class SortString{
    static final int MAX_CHAR = 26;
 
    // function to print string in sorted order
    static void sortString(String str) {
 
        // Hash array to keep count of characters.
        int letters[] = new int[MAX_CHAR];
 
        // Traverse string and increment
        // count of characters
        for (char x : str.toCharArray()) {
 
            // 'a'-'a' will be 0, 'b'-'a' will be 1,
            // so for location of character in count
            // array we will do str[i]-'a'.
            letters[x - 'a']++;
        }
 
        // Traverse the hash array and print
        // characters
        for (int i = 0; i < MAX_CHAR; i++) {
            for (int j = 0; j < letters[i]; j++) {
                System.out.print((char) (i + 'a'));
            }
        }
    }
 
    // Driver program to test above function
    public static void main(String[] args) {
        sortString("geeksforgeeks");
    }
}
// This code is contributed
// by Sinuhe


C#




// C# program to sort
// a string of characters
using System;
 
class GFG
{
     
    // Method to sort a
    // string alphabetically
    public static string sortString(string inputString)
    {
         
        // convert input
        // string to char array
        char[] tempArray = inputString.ToCharArray();
 
        // sort tempArray
        Array.Sort(tempArray);
 
        // return new sorted string
        return new string(tempArray);
    }
 
    // Driver Code
    public static void Main(string[] args)
    {
        string inputString = "geeksforgeeks";
 
        Console.WriteLine(sortString(inputString));
    }
}
 
// This code is contributed by Shrikant13


Javascript




<script>
 
// JavaScript program to sort
// a string of characters
 
let MAX_CHAR = 26;
 
// function to print string in sorted order
function sortString(str)
{
// Hash array to keep count of characters.
    let letters=new Array(MAX_CHAR);
    for(let i=0;i<MAX_CHAR;i++)
    {
        letters[i]=0;
    }
     
     // Traverse string and increment
        // count of characters
    for(let x=0;x<str.length;x++)
    {
        // 'a'-'a' will be 0, 'b'-'a' will be 1,
            // so for location of character in count
            // array we will do str[i]-'a'.
            letters[str[x].charCodeAt(0) - 'a'.charCodeAt(0)]++;
    }
    // Traverse the hash array and print
        // characters
        for (let i = 0; i < MAX_CHAR; i++) {
            for (let j = 0; j < letters[i]; j++) {
                document.write(String.fromCharCode
                (i + 'a'.charCodeAt(0)));
            }
        }
}
 
// Driver program to test above function
sortString("geeksforgeeks");
 
 
// This code is contributed by rag2127
 
</script>


Python3




# Python 3 program to sort a string
# of characters
 
MAX_CHAR = 26
 
# function to print string in sorted order
def sortString(str):
     
    # Hash array to keep count of characters.
    # Initially count of all characters is
    # initialized to zero.
    charCount = [0 for i in range(MAX_CHAR)]
     
    # Traverse string and increment
    # count of characters
    for i in range(0, len(str), 1):
         
        # 'a'-'a' will be 0, 'b'-'a' will be 1,
        # so for location of character in count
        # array we will do str[i]-'a'.
        charCount[ord(str[i]) - ord('a')] += 1
     
    # Traverse the hash array and print
    # characters
    for i in range(0, MAX_CHAR, 1):
        for j in range(0, charCount[i], 1):
            print(chr(ord('a') + i), end = "")
 
# Driver Code
if __name__ == '__main__':
    s = "geeksforgeeks"
    sortString(s)
     
# This code is contributed by
# Sahil_Shelangia


Output

eeeefggkkorss

Time Complexity: O(Max_CHAR*n) which becomes O(n) as MAX_CHAR is  constant,So Overall Time Complexity:- O(n) where n is the length of the string.  
Auxiliary Space: O( 1 ).

 



Last Updated : 29 Feb, 2024
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads