Question

我（对于家庭作业，如果影响答案的方式）应该为quicksort编写一个类，以便从用户提供的txt或dat文件中对数组进行排序。我向用户提供驱动程序类中的菜单选项以选择排序类型，然后将数组传递给quicksort类进行排序，之后将其返回给驱动程序类以写入文件。我相信返回操作正确，因为我将未排序的数组打印到文件中，但它似乎只是通过快速排序循环（仅通过“Last Loop”字符串的一次打印确定到控制台。< / p>

代码的附加位是赋值的一部分，允许用户根据用户选择，如果只有50或100个项目保留在未排序的数组中，则允许用户选择插入排序来完成排序。我试过运行这个程序来评论那两个if语句，但程序仍然没有正确排序。我确定输入正确读取，因为我有一个正确排序的附加HeapSort类，如果选择了该选项并且文件大小小于50或100整数，则插入排序正确返回。我似乎无法触发更大文件的QuickSort。

class Quicksort{
  int partition(int arr[], int lb, int ub){
     int i = lb, j = ub; 
     int temp; 
     int pivot = arr[0];
     while (i <= j) { 
        while (arr[i] < pivot){
           i++;
        }while(arr[j] > pivot){
           j--;
        }if (i <= j){
           temp = arr[i];
           arr[i] = arr[j];
           arr[j] = temp;
           i++;
           j--;
        } 
     }return i;
  } 

  int[] quicksort(int arr[], int lb, int ub, boolean insertLarge, boolean insertSmall){
     if (insertLarge && arr.length <= 100){
        System.out.println("Large");
        insertionSort(arr);
     }
     else if (insertSmall && arr.length <= 50){
        System.out.println("Small");
        insertionSort(arr);
     }
     else{
        int[] intArrCopy = new int[arr.length-1];
        for (int z = 1; z < intArrCopy.length; z++){
           intArrCopy[z-1] = arr[z];
        } 
        System.out.println("Last Loop");
        int index = partition(arr, lb, ub);
        if (lb < index-1){
           quicksort(intArrCopy, lb, index-1, insertLarge, insertSmall);
        }if (index < ub){
           quicksort(intArrCopy, index, ub, insertLarge, insertSmall);
        }
     }return arr;
  }

  public static void insertionSort(int x[]){
     int h, k, y;
     for (k=1; k < x.length; k++){
        y = x[k];
        for (h = k-1; h>=0 && y < x[h]; h--){
           x[h+1] = x[h];
        }x[h+1] = y;
     }
  }
}

如何从驱动程序类调用它：

private static void processChoice(int choice, int[] intArr){
  switch (choice){
     case 1:
        p = intArr.length;
        output = new int[p];
        startTime = System.nanoTime();
        output = quick.quicksort(intArr, intArr[0], intArr[p-1], insertLarge, insertSmall);
        endTime = System.nanoTime();
        System.out.println("Time Taken: "+(endTime-startTime)+" nanoseconds.");
        break;
   }
}

Answer 1

假设采用混合排序，请尝试以下方法：

  void quicksort(int arr[], int lb, int ub){
     if ((ub-lb) < 100){             // < 32 may be fastest
        System.out.println("Large");
        insertionSort(arr, lb, ub);
        return;
     }
     int index = partition(arr, lb, ub);
     if (lb < index-1)
        quicksort(arr, lb, index-1);
     if (index < ub)
        quicksort(arr, index, ub);
  }

  public static void insertionSort(int x[], int lb, int ub){
     int h, k, y;
     for (h = lb+1; h <= ub; h++){
        y = x[h];
        for (k = h; k > lb && x[k-1] > y; k--)
           x[k] = x[k-1];
        x[k] = y;
     }
  }

Quicksort没有开始排序过程

1 个答案: