Java 选择排序交换未按预期工作
Java Selection Sort Exchange not working as desired
我的任务:创建一个适用于字符串和整数的选择排序。
您好,我想知道是否有人可以告诉我为什么我的列表无法排序,无论我输入什么列表,都会以相同的顺序吐出来。一般来说,我是 Whosebug 和 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]);
}
}
}
您没有比较数组中字符串的值:
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++;
}
}
如果要按字符串排序:
if (array[inner].compareTo(array[minimumIndex]) < 0) {
minimumIndex = inner;
}
Java 数组有一个名为 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
好吧,如果你想自己做排序,你可以用整数数组来做,
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
}
}
}
希望对您有所帮助
// 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;
}
请注意,您实际上并不是在比较数组中的元素,只是比较它们的索引。如果将代码提取到方法中,我认为您会发现事情要简单得多。
我的任务:创建一个适用于字符串和整数的选择排序。
您好,我想知道是否有人可以告诉我为什么我的列表无法排序,无论我输入什么列表,都会以相同的顺序吐出来。一般来说,我是 Whosebug 和 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]);
}
}
}
您没有比较数组中字符串的值:
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++;
}
}
如果要按字符串排序:
if (array[inner].compareTo(array[minimumIndex]) < 0) {
minimumIndex = inner;
}
Java 数组有一个名为 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
好吧,如果你想自己做排序,你可以用整数数组来做,
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
}
}
}
希望对您有所帮助
// 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;
}
请注意,您实际上并不是在比较数组中的元素,只是比较它们的索引。如果将代码提取到方法中,我认为您会发现事情要简单得多。