java - 通过选择排序按字母顺序对字符串数组进行排序？

Question

我正在开发一个程序，该程序使用compareTo方法和选择排序按字母顺序对字符串数组进行排序。

<小时/>

我在下面的minimumPosition方法中遇到问题。该方法旨在取数组尾部区域中的最小元素，以便选择排序程序可以方便地对列表进行排序。

我的问题是，当我对列表进行排序并通过测试仪打印它时，它会按字母顺序反向打印，并在前面有一个递减。例如(c ,z,x,y...,b,a) 反对 (a,b,c.. y,x,z)

/**
   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 < 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 < a.length ; i++)
    {
        if (a [i].compareTo (holder) > 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;

        }
    }

测试人员类别:相关，但这里没有问题。

    /**
       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 < 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 < length ; i++) {
                String temp = "" ;
                int wordLength = 1 + random.nextInt(n) ;
                for (int j = 0 ; j < wordLength ; j++) {
                    char ch = (char)('a' + random.nextInt(LETTERS)) ;
                    temp += ch ;
                }
                a[i] = temp ;
            }
            return a ;
        }
    }

我认为问题出在minimumPosition方法中，但对我来说它看起来是正确的。

Answer 1

如果你想要升序，

改变

 if (a [i].compareTo (holder) > 0)

至

 if (a [i].compareTo (holder) < 0)

Compares this object with the specified object for order. Returns a negative integer, zero, or a positive integer as this object is less than, equal to, or greater than the specified object.

了解更多:Comparable#compareTo(..)