java string quicksort code example

Example 1: is it possible to quick sort a string in java

public class StringQuickSort {

    String names[];
    int length;

    public static void main(String[] args) {
        StringQuickSort sorter = new StringQuickSort();
        String words[] = {"zz", "aa", "cc", "hh", "bb", "ee", "ll"}; // the strings need to be sorted are put inside this array
        sorter.sort(words);

        for (String i : words) {
            System.out.print(i);
            System.out.print(" ");
        }
    }

    void sort(String array[]) {
        if (array == null || array.length == 0) {
            return;
        }
        this.names = array;
        this.length = array.length;
        quickSort(0, length - 1);
    }

    void quickSort(int lowerIndex, int higherIndex) {
        int i = lowerIndex;
        int j = higherIndex;
        String pivot = this.names[lowerIndex + (higherIndex - lowerIndex) / 2];

        while (i <= j) {
            while (this.names[i].compareToIgnoreCase(pivot) < 0) {
                i++;
            }

            while (this.names[j].compareToIgnoreCase(pivot) > 0) {
                j--;
            }

            if (i <= j) {
                exchangeNames(i, j);
                i++;
                j--;
            }
        }
        //call quickSort recursively
        if (lowerIndex < j) {
            quickSort(lowerIndex, j);
        }
        if (i < higherIndex) {
            quickSort(i, higherIndex);
        }
    }

    void exchangeNames(int i, int j) {
        String temp = this.names[i];
        this.names[i] = this.names[j];
        this.names[j] = temp;
    }
}

Example 2: how to quicksort a string array in java

package com.javacodegeeks.sorting.quicksort;
 
public class QuicksortStringExample {
 
    private static String []a;
    public static void main(String[] args) {
        // Get an String array
        a = new String[]{"X","E","C","A"};
         
        // prints the given array
        printArray();
         
        // sort the array
        sort();
         
        System.out.println("");
         
        //prints the sorted array
        printArray();
         
    }
     
    // This method sort an array internally and internally calls quickSort 
    public static void sort(){
        int left = 0;
        int right = a.length-1;
             
        quickSort(left, right);
    }
     
    // This method is used to sort the array using quicksort algorithm.
    // It takes left and the right end of the array as two cursors
    private static void quickSort(int left,int right){
         
        // If both cursor scanned the complete array quicksort exits
        if(left >= right)
            return;
         
        // Pivot using median of 3 approach
        String pivot = getMedian(left, right);
        int partition = partition(left, right, pivot);
         
        // Recursively, calls the quicksort with the different left and right parameters of the sub-array
        quickSort(0, partition-1);
        quickSort(partition+1, right);
    }
     
    // This method is used to partition the given array and returns the integer which points to the sorted pivot index
    private static int partition(int left,int right,String pivot){
        int leftCursor = left-1;
        int rightCursor = right;
        while(leftCursor < rightCursor){
        while(((Comparable<String>)a[++leftCursor]).compareTo(pivot) < 0);
        while(rightCursor > 0 && ((Comparable<String>)a[--rightCursor]).compareTo(pivot) > 0);
            if(leftCursor >= rightCursor){
                break;
            }else{
                swap(leftCursor, rightCursor);
            }
        }
        swap(leftCursor, right);
        return leftCursor;
    }
     
    public static String getMedian(int left,int right){
        int center = (left+right)/2;
         
        if(((Comparable<String>)a[left]).compareTo(a[center]) > 0)
            swap(left,center);
         
        if(((Comparable<String>)a[left]).compareTo(a[right]) > 0)
            swap(left, right);
         
        if(((Comparable<String>)a[center]).compareTo(a[right]) > 0)
            swap(center, right);
         
        swap(center, right);
        return a[right];
    }
     
    // This method is used to swap the values between the two given index
    public static void swap(int left,int right){
        String temp = a[left];
        a[left] = a[right];
        a[right] = temp;
    }
     
    public static void printArray(){
        for(String i : a){
            System.out.print(i+" ");
        }
    }
     
}

Tags:

Java Example