How to sort array in alphabetical order without using Array.sort:Java

Question

I want to sort values of an array in alphabetical order in Java.I am stuck at going over the array again and get the output. My intention is to : Go over the words array, Find the largest string (lexicographically), Once it is found, insert the word at the end of the sortedWords array, Shift the sortedArray's index by one position to the left, Reduce the original array by removing the word already found, Loop again to find the next word....

Thanks for your help.

Following is what I have done so far.

public class Main {

public static void main(String[] args) {
    String[] words = {"bob","alice","keith","zoe","sarah","gary"};
    String[] sortedWords = new String[words.length];

    // Copy of the original array
    for(int i = 0; i < sortedWords.length;i++){
        sortedWords[i]= words[i];
    }


    for (int i = 0; i < words.length - 1; i++) {
    int currentSize = words.length;
    int position = 0;
    boolean found = false;
    while (position < currentSize && !found) {
        if (words[i].equals(largestAlphabetically(words))) {
            found = true;

        } else {
            position++;
        }
    }

        if(found){
            insertAtEnd(words,largestAlphabetically(words));
            shiftLeft(sortedWords,i);
            shorterArray(words);

        }

    }
    for(int i = 0;i < sortedWords.length;i++){
        System.out.println(sortedWords[i]);
    }

}


/**
 * This method inserts the largest string lexicographically at the end of the array
 * @param words
 * @param wordToInsert
 * @return an array with string at the end
 */

public static String [] insertAtEnd(String[] words, String wordToInsert) {

    for (int i = 0; i < words.length; i++) {
        int currentSize = words.length - 1;
        wordToInsert = largestAlphabetically(words);
        if (currentSize < words.length) {
            currentSize++;
            words[currentSize - 1] = wordToInsert;
        }
    }
    return words;
}

/**
 * This method determines the largest string in an array
 * @param words
 * @return largest string lexicographically
 */
public static String largestAlphabetically(String[] words) {
    String searchedValue = words[0];
    for (int i = 0; i < words.length; i++) {

        for (int j = 0; j < words.length; j++) {
            if (words[i].compareToIgnoreCase(words[j]) < 0) {
                searchedValue = words[j];
            }
        }
    }
    return searchedValue;
}

/**
 * To shift the array index to the left
 * @param dest
 * @param from
 */

public static void shiftLeft(String[] dest, int from) {
    for (int i = from + 1; i < dest.length; i++) {
        dest[i - 1] = dest[i];
    }
    dest[dest.length - 1] = dest[0];
}

/**
 * Remove the largest word from a string while maintaining the order of the array
 * @param words
 * @return return a shorter array
 */
public static String [] shorterArray(String[] words) {
    String [] shorterArray = new String[words.length];
    int currentSize = words.length;
    String searchedValue = largestAlphabetically(words);
    int position = 0;
    boolean found = false;
    while (position < currentSize && !found) {
        if (words[position] == searchedValue) {
            found = true;

        } else {
            position++;
        }
    }
    if (found) {
        for (int i = position + 1; i < currentSize; i++) {
            words[i - 1] = words[i];

        }
        currentSize--;
        shorterArray = words;
    }

    return shorterArray;

}

}

Answer 1

 public boolean isSorted(String[] a) {
        for (int i = 0; i < a.length; i++) {
            if (a[i - 1].compareTo(a[i]) > 0) {
                return false;
            }
        }
        return true;
    }

Answer 2

//Use a generic algorithm which can sort any type of data. //Selection sort

public class Selection {
static public void sort(Comparable...a){
    int N = a.length;
    for(int i=0;i<N;i++){
        int min = i;
        for(int j=i+1;j<N;j++){
            if(less(a[j],a[min]))
                min = j;
            swap(a,i,min);
        }
    }
}

static private boolean less(Comparable a,Comparable b){
    return a.compareTo(b)<0;//return true if a is a-b<0;meaning a is less than b
}

static private void swap(Comparable[] a,int i,int j){
    Comparable temp = a[i];
    a[i] = a[j];
    a[j] = temp;
}

static public boolean isSorted(Comparable...a){
    int N = a.length;
    for(int i=1;i<N;i++){
        if(less(a[i],a[i-1]))//if a[i]<a[i-1] then the array is not in order. Eg. a[1]=5,a[(1-1=0)]=6 then the isNotSorted
            return false;
    }
    return true;
}

}

Now using a test client

public class MainClass{
    String[] words = {"bob","alice","keith","zoe","sarah","gary"};
    for(String word:words){System.out.println(e+" ");}//print the words before sorting
    words.sort(words);
    for(String word:words){System.out.println(e+" ");}//print the words after sorting
}

This algorithm can sort any type of data you want. eg. String,Integer and any data type that implements Comparable

Answer 3

I don't know why you don't want to use Arrays.sort() or Collections.sort(), anyway if you really want to implement a simple sorting algorithm you can start from insertion sort as suggested in some comments. Here is a simple implementation:

String[] words = {"bob","alice","keith","zoe","sarah","gary"};
for(int i = 0; i < words.length; i++)
{
    int smallest = i;
    for(int j = i + 1; j < words.length; j++) // here you find the index of the minimum String between the strings in the unsorted side of the array
    {
        if(words[j].compareTo(words[i]) < 0)
            smallest = j;
    }
    //put the new minimum in the i-th position.
    String aux = words[i];
    words[i] = words[smallest];
    words[smallest] = aux;
}
for(int i = 0; i < words.length; i++)
{
    System.out.println(words[i]);
}

Note that this is in-place sorting so you don't need an auxiliary array. Hope it is clear

Answer 4

Simple implementation can be like this:

String[] words = {"bob","alice","keith","zoe","sarah","gary"};

boolean isSwapped = false;
do {
    isSwapped = false;
    for(int i=0;i<words.length-1;i++){
        if(words[i].compareTo(words[i+1])>0){
            String temp = words[i+1];
            words[i+1] = words[i];
            words[i] = temp;
            isSwapped = true;
        }
    }
}while((isSwapped));

Answer 5

A heap sort seems to be the best way to sort your string of arrays in lexicographical order. A binary max heap would be the way to go. In Java, it can be implemented using PriorityQueue.

I had written a BinaryMinHeap using a self-written interface of a PriorityQueue. You will find the project here. [Please take care not to copy any code without citation.]

Does that answer your question?

Answer 6

You can compare two strings like this:

"a".compareTo("b"); // returns a negative number, here -1
"a".compareTo("a"); // returns  0
"b".compareTo("a"); // returns a positive number, here 1

So you can write a small Blubblesort. Link: https://en.wikipedia.org/wiki/Bubble_sort