Java 选择排序交换未按预期工作

Question

我的任务：创建一个适用于字符串和整数的选择排序。

您好，我想知道是否有人可以告诉我为什么我的列表不会排序，无论我输入什么列表，都会以相同的顺序被吐出。一般来说，我是 StackOverflow 和 JavaProgramming 的新手。对于我目前所犯的任何新手错误，我深表歉意。

public class selectionSort {
    public static void main(String[] args) {
        sort(args);
        printArray(args);
    }

    public static void sort(String[] array) {
        int outer = 0;
        while (outer < array.length - 1) {
            outer++;
            int minimumIndex = outer;
            int inner = outer + 1;
            while (inner < array.length) {
                inner++;
                if (inner < minimumIndex) {
                    minimumIndex = inner;
                }
            }
            //exchange
            String temp = array[minimumIndex];
            array[minimumIndex] = array[outer];
            array[outer] = temp;
        }
    }

    public static void printArray(String[] array) {
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

Answer 1

你不是在比较数组中字符串的值：

            if (inner < minimumIndex) {
                minimumIndex = inner;
            }

也许你需要这个（如果你想通过字符串的int 值对字符串进行排序）：

            if (Integer.parseInt(array[inner]) < Integer.parseInt(array[minimumIndex])) {
                minimumIndex = inner;
            }

测试代码：

public static void sort(String[] array) {
    int outer = 0;
    while (outer < array.length - 1) {
        int minimumIndex = outer;
        int inner = outer + 1;
        while (inner < array.length) {
            if (Integer.parseInt(array[inner]) < Integer.parseInt(array[minimumIndex])) {
                minimumIndex = inner;
            }
            inner++;
        }
        //exchange
        String temp = array[minimumIndex];
        array[minimumIndex] = array[outer];
        array[outer] = temp;
        outer++;
    }
}

如果要按String排序：

            if (array[inner].compareTo(array[minimumIndex]) < 0) {
                minimumIndex = inner;
            }

Answer 2

Java Array 有一个称为 sort() 的内置操作。哪个会为您进行排序。

Arrays.sort(array);

所以你的代码可以重写为，

//import Arrays module
import java.util.Arrays;

public class selectionSort {
    public static void main(String[] args) {
        sort(args);
        printArray(args);
    }

    public static void sort(String[] array) {
        //sort your array
        Arrays.sort(array);
    }
    public static void printArray(String[] array) {
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

有关数组的更多信息，请查看http://docs.oracle.com/javase/7/docs/api/java/util/Arrays.html

Answer 3

好吧，如果你想自己做排序，你可以用一个整数数组来做，

public class sorting {

    public static void main(String arg[])throws Exception{

        for(int s = 0; s <= arg.length - 1; s++){

            for(int k = 0; k <= arg.length - 2; k++){

                if(j[k] > j[k+1]){ //comparing array values

                    int temp = 0;
                    temp = j[k]; //storing value of array in temp variable 
                    j[k] = j[k+1]; //swaping values
                    j[k+1] = temp; //now storing temp value in array
                }    //end if block             
            }  // end inner loop    
        }
        //end outer loop
        for(int s = 0; s <= j.length - 1; s++){
            System.out.println(j[s]); //retrieving values of array in ascending order 
        }   
    }
}

Answer 4

希望对你有帮助

// 1. Find the minimum value in the list.
// 2. Swap the minimum value with the value in the first position.
// 3. move the insertion point for the minimum along one.
// 4. Repeat the steps above for the remainder of the list

public static void yoursort(String[]array) {
    int currentIndex = 0;
    while(currentIndex < array.length-1) {
        currentIndex++;
        int indexOfMinimum = currentIndex;           
        int candidateMinIndex = currentIndex + 1;
        while(candidateMinIndex < array.length) {
            candidateMinIndex++;
            if(candidateMinIndex < indexOfMinimum) {
                indexOfMinimum = candidateMinIndex;
            }
        }
        swap(array, currentIndex, indexOfMinimum);
    }
}

public static void mysort(String[]array) {
    int currentIndex = 0;
    while(currentIndex < array.length-1) { // dont need to do the last one
        int indexOfMinimum = findIndexOfMinimum(array, currentIndex);
        swap(array, currentIndex, indexOfMinimum);
        currentIndex++;
    }
}

protected static int findIndexOfMinimum(String[] array, int startIndex) {
    int indexOfMinimum = startIndex; // start off asumming next is minimum
    int candidateIndex = startIndex + 1; // can shift candidate along to second element.
    while(candidateIndex < array.length) {  
        // compare candidate and minimum
        if ( array[candidateIndex].compareTo(array[indexOfMinimum]) < 0 ) {
            // ie array[candidateIndex] before/smaller array[indexOfMinimum] 
            indexOfMinimum = candidateIndex;        
        }                    
        candidateIndex++;
    }
    return indexOfMinimum;
}

protected static void swap(String[] array, int toIndex, int fromIndex) {
    if ( toIndex == fromIndex ) {
        // fast return if swapping with self.
        return;
    }

    String temp = array[toIndex];
    array[toIndex] = array[fromIndex];
    array[toIndex] = temp;
}

请注意，您实际上并没有比较数组中的元素，只是比较它们的索引。如果将代码提取到方法中，我认为您会发现事情会简单得多。