字符串排序

Question

So I am trying to sort an array of strings with an algorithm.

NOTE: For this assignment I am not allowed to use any of the built in sort functions.

public boolean insert(String s)
{
  boolean result = false;
  int index = 0;
  int k = 0;
  String temp = "";

  if (numUsed < values.length)
  {
    if (index == 0) 
    {
      values[index] = s;
    }    
    else 
    {
      index = 0;
      while (values[index].compareTo(s) < 0);
      k = index;
      while (k < numUsed)
      {
        values[k + 1] = values[k];
      }
      values[index] = s;
    }
    numUsed++;
    result = true;
  }
}

Given the input of "apples", "cats", and "bees" the output is in the same order that it was input. No matter what I do it just never seems to sort.

Can someone help me find the problem?

Answer 1

Start by going back to basics. Imagine you have a large pile of index cards randomly sorted in front of you, and you need to alphabetize them. A simple but workable method is to first find all the words starting with A, and putting those in a separate pile (hint: how can you mimic a separate pile in your program?). Then you go though the first pile, find all the words starting with B, and putting those in the back of your sorted pile (another hint).

I'd recommend putting your current code aside and starting fresh. Write a loop that goes through the unsorted array, and finds the word closest to the beginning of the dictionary. Here's some psuedocode to get you started with that:

String leastSoFar = "ZZZZZZ";
for each String in values:
    compare the string to leastSoFar
    if the string is closer to the start of the dictionary than leastSoFar:
        leastSoFar = ???? //I'll let you fill those in

Answer 2

Sorting a collection and adding elements to a collection are, often, two separate functions. It is, of course, possible to add elements to a collection in a manner such that the elements are sorted ... but this is a very different task from simply sorting an array of elements.

If you are simply trying to implement a simple sorting algorithm, a simple (but not optimal) algorithm that is easy to code is the "delayed replacement sort". Pseudocode fpr the algorithm to sort into ascending order is described succinctly below:

 Begin DELAYEDSORT
     For ITEM=1 to maximum number of items in list-1
        LOWEST=ITEM
        For N=ITEM+1 to maximum number of items in list
           Is entry at position N lower than entry at position LOWEST?
              If so, LOWEST=N
        Next N
        Is ITEM different from LOWEST
           If so, swap entry at LOWEST with entry in ITEM
     Next ITEM
  End DELAYEDSORT

The delayed replacement sorting algorithm is simple to understand and easy to code. It is typically faster than the bubble sort (fewer swaps), but still has bad time complexity O(n^2) and so it is not appropriate for sorting very large datasets.

If you really want to add items to a sorted collection, then you can add the new item to the end of your collection, and resort it using the above. If you are working with data sets larger than a few hundred or thousand elements, then efficiency will be poor.

An alternate solution that still has O(n^2) time complexity but which can be adapted to combine the adding and sorting is the "insertion sort" whose pseudocode appears below:

// The values in A[i] are checked in-order, starting at the second one
for i ← 1 to i ← length(A)
  {
    // at the start of the iteration, A[0..i-1] are in sorted order
    // this iteration will insert A[i] into that sorted order
    // save A[i], the value that will be inserted into the array on this iteration
    valueToInsert ← A[i]
    // now mark position i as the hole; A[i]=A[holePos] is now empty
    holePos ← i
    // keep moving the hole down until the valueToInsert is larger than 
    // what's just below the hole or the hole has reached the beginning of the array
    while holePos > 0 and valueToInsert < A[holePos - 1]
      { //value to insert doesn't belong where the hole currently is, so shift 
        A[holePos] ← A[holePos - 1] //shift the larger value up
        holePos ← holePos - 1       //move the hole position down
      }
    // hole is in the right position, so put valueToInsert into the hole
    A[holePos] ← valueToInsert
    // A[0..i] are now in sorted order
  }