title: Sorting a String Array alphabetically by Selection Sort?
body: <p>Im working on a program that alphabetically sorts a string array using compareTo method and selection sort.</p>
  
  <hr>
  
  <p>Im having an issue within my <strong>minimumPosition</strong> method below. The method is designed to take the smallest element in a tail region of the array so that the selection sort program can conveniently sort the list.</p>
  
  <p>My issue is that when I sort the list and print it via the tester it prints it out reverse alphabetically with a decrepency in-front. e.g. (c ,z,x,y...,b,a) <em>opposed to</em> (a,b,c.. y,x,z)</p>
  
  <pre><code>/**
     SelectionSorter class sorts an array of Strings alphabetically.
     It uses the selection sort algorithm.
  
   */
  public class SelectionSorter
  {
      private String[] a;
      /**
         Constructs the selection sorter
         @param anArray the array to sort
       */
      public SelectionSorter4 (String[] anArray)
      {
          a = anArray;
      }
  
  
      /**
         Sorts the array managed by this selection sorter
       */
      public void sort ()
      {
          for (int i = 0 ; i &lt; a.length - 1 ; i++)
          {
              int minPos = minimumPosition (i);
              swap (minPos, i);
          }
      }
  
  
      /**
         Finds the smallest element in a tail region of the array.
         The elements are String objects in this case, and the
         comparison is based on the compareTo method of String.
         @param from the first position of the tail region
         @return the position of the smallest element in tail region
       */
      private int minimumPosition (int from)
  {
  
      String holder = a [from];
      int position = from;
      for (int i = from ; i &lt; a.length ; i++)
      {
          if (a [i].compareTo (holder) &gt; 0)
          {
              holder = a [i];
              position = i;
          }
  
      }
      return position;                
  }
  
          /**
             Swaps two entries of the array
             @param i the first position to swap
             @param j the second position to swap
           */
          private void swap (int i, int j)
          {
  
              String temp = a [i];
              a [i] = a [j];
              a [j] = temp;
  
          }
      }
  </code></pre>
  
  <p>Tester class: Relevant but there are no issues here. </p>
  
  <pre><code>    /**
         Tests the SelectionSorter4 class which sorts an array of Strings
         alphabetically.
       */
      import java.util.* ;
  
      public class SelectionSorterTester
      {
          public static void main(String[] args)
          {
              String[] a = randomStringArray(40, 6) ; 
              SelectionSorter sorter = new SelectionSorter(a) ;
  
              System.out.println(toString(a)) ;
              sorter.sort() ;
              System.out.println("----------Sorted:") ;
              System.out.println(toString(a)) ;
              System.out.println("--------------------------------") ;
          }
          /**
             Returns a string representation of the array of Strings
             @param array the array to make a string from
             @return a string like [a1, a2, ..., a_n]
           */
          public static String toString(String[] array)
          {
              String result = "[" ;
              for (int i = 0 ; i &lt; array.length - 1; i++) {
                  result += array[i] + ", " ;
              }
              result += array[array.length - 1] + "]" ;
              return result ;
          }
          /**
             Creates an array filled with random Strings.
             @param length the length of the array
             @param n the number of possible letters in a string
             @return an array filled with length random values
           */
          public static String[] randomStringArray(int length, int n)
          {
              final int LETTERS = 26 ;
              String[] a = new String[length] ;
              Random random = new Random(53) ;
              for (int i = 0 ; i &lt; length ; i++) {
                  String temp = "" ;
                  int wordLength = 1 + random.nextInt(n) ;
                  for (int j = 0 ; j &lt; wordLength ; j++) {
                      char ch = (char)('a' + random.nextInt(LETTERS)) ;
                      temp += ch ;
                  }
                  a[i] = temp ;
              }
              return a ;
          }
      }
  </code></pre>
  
  <p>I think the issue lies within the minimumPosition method but it looks correct to me.</p>