Java 显示选择排序和快速排序

我想检查我的算法对于快速排序方法和选择排序方法是否正确。我相信我的快速排序正确，我的选择排序也正确，但可能需要更正。如何显示我的排序返回

选择排序

public class SelectionSort {

// complexity of O(n2)
public void selectionSort(int numbers[], int array_size) {

    int i;
    int j;
    int min;

    for (i = 0; i < array_size - 1; i++) {

        min = i;

        for (j = i + 1; j < array_size; j++) {

            if (numbers[j] < numbers[min])
                min = j;

        }

        swap(numbers[i], numbers[min]);
    }
}

public void swap(int num1, int num2) {
    int temp;
    temp = num1;
    num1 = num2;
    num2 = temp;
}

}

公共类选择排序{
//O（n2）的复杂性
public void selectionSort（整数[]，整数数组大小）{
int i；
int j；
int-min；
对于（i=0；i

快速分拣

public class QuickSort {

// complexity of O(n log n).
public void quickSort(int numbers[], int array_size) {

    quickSort(numbers, 0, array_size - 1);

}

public void quickSort(int numbers[], int left, int right) {

    int pivot;
    int leftHold;
    int rightHold;

    leftHold = left;
    rightHold = right;
    pivot = numbers[left];

    while (left < right) {

        while ((numbers[right] >= pivot) && (left < right))
            right--;

        if (left != right) {
            numbers[left] = numbers[right];
            left++;
        }

        while ((numbers[left] <= pivot) && (left < right))
            left++;

        if (left != right) {
            numbers[right] = numbers[left];
            right--;

        }
    }

    numbers[left] = pivot;
    pivot = left;
    left = leftHold;
    right = rightHold;

    if (left < pivot)

        quickSort(numbers, left, pivot - 1);

    if (right > pivot)

        quickSort(numbers, pivot + 1, right);

}
}

公共类快速排序{
//O（n logn）的复杂性。
公共无效快速排序（整数[]，整数数组大小）{
快速排序（数字，0，数组大小-1）；
}
公共无效快速排序（整数[]，整数左，整数右）{
int轴；
int leftHold；
int rightHold；
leftHold=左；
rightHold=右；
枢轴=数字[左]；
while（左<右）{
而（（数字[右]>=轴）和&（左<右））
对--；
如果（左！=右）{
数字[左]=数字[右]；
左++；
}
while（（数字[左]轴）
快速排序（数字，轴+1，右）；
}
}

主类

public class sortTesting {

public static void main(String[] args) {

    QuickSort qsort = new QuickSort();
    SelectionSort ssort = new SelectionSort();

    int i;
    int numbers[] = { 12, 9, 4, 99, 120, 1, 3, 10 };

    System.out.print("Values in the sort:\n");

    for (i = 0; i < numbers.length; i++) {
        System.out.print(numbers[i] + "  ");
        System.out.println();
    }

    qsort.quickSort(numbers, 1);
    ssort.selectionSort(numbers, 1);

    //display sort of quickSort
    //display sort of selectionSort

}

}

公共类排序{
公共静态void main（字符串[]args）{
快速排序qsort=新的快速排序（）；
SelectionSort ssort=新建SelectionSort（）；
int i；
整数[]={12,9,4,99,120,1,3,10}；
System.out.print（“排序中的值：\n”）；
对于（i=0；i

您的快速排序完全正常，但选择排序中的交换函数存在问题。问题是：

在java中，原语是通过值传递的

因此，如果将2个整数传递给swap函数，则交换将不会反映在调用函数中。可以通过传递要交换的数组和索引进行更正。因此，正确的交换函数为：

public void swap(int []numbers,int i,int min) {
    int temp;
    temp = numbers[i];
    numbers[i] = numbers[min];
    numbers[min]=temp;
}

正确的电话是：

swap(numbers,i,min);

现在谈到主函数，您有一个类型错误，您提到数组长度为1，这显然是错误的，在java中提到数组长度时，最好使用这个值

数组\u标识符。长度

另外，要向其他排序算法提供相同的未排序数组，请使用方法clone（）将未排序数组克隆到另一个数组中，然后将其发送到选择排序，因此正确的主类为：

public class sortTesting {

public static void main(String[] args) {

    QuickSort qsort = new QuickSort();
    SelectionSort ssort = new SelectionSort();

    int i;
    int numbers[] = { 12, 9, 4, 99, 120, 1, 3, 10 };

    System.out.print("Values in the sort:\n");

    for (i = 0; i < numbers.length; i++) {
        System.out.print(numbers[i] + "  ");
        System.out.println();
    }     
    int []numbers2=numbers.clone();
    qsort.quickSort(numbers, numbers.length);/*MENTION THE CORRECT ARRAY LENGTH*/        
    System.out.println("\nThe array after sorting using quick sort is");
    for(int e:numbers)
     System.out.print(e+"  ");    
    ssort.selectionSort(numbers2, numbers2.length);/*MENTION THE CORRECT ARRAY LENGTH*/    
    System.out.println("\nThe array after sorting using selection sort is");
    for(int e:numbers2)
     System.out.print(e+"  ");         
 }

}

公共类排序{
公共静态void main（字符串[]args）{
快速排序qsort=新的快速排序（）；
SelectionSort ssort=新建SelectionSort（）；
int i；
整数[]={12,9,4,99,120,1,3,10}；
System.out.print（“排序中的值：\n”）；
对于（i=0；i

您的快速排序完全正常，但选择排序中的交换函数存在问题。问题是：

在java中，原语是通过值传递的

因此，如果将2个整数传递给swap函数，则交换将不会反映在调用函数中。可以通过传递要交换的数组和索引进行更正。因此，正确的交换函数为：

public void swap(int []numbers,int i,int min) {
    int temp;
    temp = numbers[i];
    numbers[i] = numbers[min];
    numbers[min]=temp;
}

正确的电话是：

swap(numbers,i,min);

现在谈到主函数，您有一个类型错误，您提到数组长度为1，这显然是错误的，在java中提到数组长度时，最好使用这个值

数组\u标识符。长度

另外，要向其他排序算法提供相同的未排序数组，请使用方法clone（）将未排序数组克隆到另一个数组中，然后将其发送到选择排序，因此正确的主类为：

public class sortTesting {

public static void main(String[] args) {

    QuickSort qsort = new QuickSort();
    SelectionSort ssort = new SelectionSort();

    int i;
    int numbers[] = { 12, 9, 4, 99, 120, 1, 3, 10 };

    System.out.print("Values in the sort:\n");

    for (i = 0; i < numbers.length; i++) {
        System.out.print(numbers[i] + "  ");
        System.out.println();
    }     
    int []numbers2=numbers.clone();
    qsort.quickSort(numbers, numbers.length);/*MENTION THE CORRECT ARRAY LENGTH*/        
    System.out.println("\nThe array after sorting using quick sort is");
    for(int e:numbers)
     System.out.print(e+"  ");    
    ssort.selectionSort(numbers2, numbers2.length);/*MENTION THE CORRECT ARRAY LENGTH*/    
    System.out.println("\nThe array after sorting using selection sort is");
    for(int e:numbers2)
     System.out.print(e+"  ");         
 }

}

公共类排序{
公共静态void main（字符串[]args）{
快速排序qsort=新的快速排序（）；
SelectionSort ssort=新建SelectionSort（）；
int i；
整数[]={12,9,4,99,120,1,3,10}；
System.out.print（“排序中的值：\n”）；
对于（i=0；i

与其打印数组，不如编写一个函数来检查数组的数据是否正确排序

public static boolean isSorted( int[] numbers ) {
    boolean result = true;
    int previous = Integer.MIN_VALUE;
    for ( int n : numbers ) {
        result &= (n > previous );
        previous = n;
    }
    return result;
}

如果布尔值开始变大，检查布尔值比读取数组更容易

注意：您可能想