Question

该项目的目的是创建两个随机数数组，并对它们进行快速排序和堆排序。跟踪比较的数量，然后比较它们。两种排序都可以，但是我的堆排序不会跟踪比较。它只是说0。我的快速排序工作并将比较放入数组中。我该如何解决？

package sorting;

import java.util.Arrays;
//import java.util.Random;
import java.util.*;


public class project2 
{ 

    static int [] heap_sort_comparison = new int[21];
    static int [] quick_sort_comparison = new int[21]; 
    static int [] array1 = new int [20];
    static int [] array2 = new int [20];
    static int compares = 0;
    static int heap_compares = 0;



    private static void quickSort(int[] array1, int l, int h) {
        if(l < h ) {
            compares++;
            int position = partition(array1, l, h);
            quickSort(array1,l, position -1);
            quickSort(array1, position +1, h);

        }
    }

    private static int partition(int[] array1, int i, int j) {
        int pivot = array1[j] -1;
        int small = i -1;

        for(int k = i; k < j; k++) {
            if(array1[k] <= pivot) {
                compares++;
                small++;
                swap(array1, k, small);
            }
        }

        swap(array1, j, small + 1);
            //System.out.println("Pivot = " + array1[small + 1]);
            print_quick_sort(array1);
            return small + 1;

    }

        public static void swap(int[] array1, int a, int b) {
            int temp;
            temp = array1[a];
            array1[a] = array1[b];
            array1[b] = temp;
        }


        public static void print_quick_sort(int[] array1) {
            for(int i = 0; i < array1.length; i++) {
              System.out.print(array1[i] + " ");
            }

            System.out.println();
          }



        //HEAP SORT
         public void build(int array2[]) {
             int length = array2.length;    

            for(int i = length/2-2; i >=0; i--) {
                bubble_down(array2, i, array2.length-1);
                heap_compares++;
            }

            for(int i = length-1; i>= 0; i--) {
                swap2(array2, 0,i);
                bubble_down(array2,i,0);
                heap_compares++;
            }
        }


         void  bubble_down(int[] array2, int parent, int size) {
            int left = parent*2+1;
            int right = 2*parent+2;
            int largest = 0;

            if(left <= size && array2[left] > array2[largest]) {
                largest = left;
                heap_compares++;
                }


            if(right <= size && array2[right] > array2[largest]) { 
                largest = right;
                heap_compares++;
            }


            if(largest != parent) {
                swap2(array2,parent, largest);
                bubble_down(array2,largest,size);
                heap_compares++;
            }
        }


         public static void swap2(int[] array2, int a, int b) {
                int temp = array2[a];
                array2[a] = array2[b];
                array2[b] = temp;
            }

         public static void print_heap_sort(int[] array2) {
                for(int i = 0; i < array2.length; i++) {
                  System.out.print(array2[i] + " ");
                }
                System.out.println();
              }





        public static void main(String[] args) {


            for(int x = 0; x < 20; x++) {

                for(int y = 0; y < 20; y++) {



            for(int i = 0; i < array1.length; i++) {
                array1[i] = array2[i]= (int)(Math.random()*20 + 0);

            }

            System.out.println("Numbers Generated in Array 1: " + Arrays.toString(array1));
            System.out.println("");
            System.out.println("Numbers Generated in Array 2: " + Arrays.toString(array2));
            System.out.println("");


            //quickSort 
            print_quick_sort(array1);
            quickSort(array1, 0, array1.length -1);
            System.out.println("The number of comparisons in quick sort: "+ compares);
            System.out.println("=============================");

                quick_sort_comparison[x] = compares;
                    compares = 0;

            System.out.println("Array of quick sort comparison's: ");
            System.out.println(Arrays.toString(quick_sort_comparison));
            System.out.println("=============================");


            //Heap Sort

            System.out.println("Before Heap Sort: ");
            System.out.println(Arrays.toString(array2));

            heap_sort_comparison[y] = heap_compares;
            heap_compares = 0;
            HeapSort ob = new HeapSort(); 
            ob.sort(array2); 
            System.out.println("Sorted array is (heap Sort): "); 
            print_heap_sort(array2);
            System.out.println("=============================");

            System.out.println("Array of heap sort comparison's: " + heap_compares);
            System.out.println(Arrays.toString(heap_sort_comparison));
            }

            }
    }



    }

Answer 1

您甚至都不会调用已构建的HeapSort方法。

在这里看...

        HeapSort ob = new HeapSort(); 
        ob.sort(array2);

我认为您正在尝试使用HeapSort类中的内置排序方法，因此您如何认为 heap_compares 计数器会增加！

我正在尝试计算堆排序和快速排序中比较的数量

1 个答案: