（8）七种排序算法的对比

下面我们写一个程序来比较选择排序、插入排序、冒泡排序、合并排序、快速排序、堆排序、基数排序这七种排序算法对同样的整型数组的排序所用的时间。

public class AllSort {  public static void main(String[] args) {    System.out.println("Array Size\tSelection Sort\tInsertion Sort"            + "\tBubble Sort\tMerge Sort\tQuick Sort\tHeap Sort\tRadix Sort");    int[] list;    Integer[] list1;       Integer[] list2;    Integer[] list3;    Integer[] list4;    Integer[] list5;    Integer[] list6;    long startTime;    long endTime;    long[][] executionTime = new long[6][7];    final int BASE = 1000;    for (int k = 0; k < 6; k++) {      list=new int[k * BASE + BASE];       for (int i = 0; i < list.length; i++) {        list[i] = (int)(Math.random() * 100000);      }      list1=initList(list);        list2=initList(list);        list3=initList(list);        list4=initList(list);        list5=initList(list);        list6=initList(list);              startTime = System.currentTimeMillis();      selectionSort(list1);      endTime = System.currentTimeMillis();      executionTime[k][0] = endTime - startTime;      startTime = System.currentTimeMillis();      insertionSort(list2);      endTime = System.currentTimeMillis();      executionTime[k][1] = endTime - startTime;      startTime = System.currentTimeMillis();      bubbleSort(list3);      endTime = System.currentTimeMillis();      executionTime[k][2] = endTime - startTime;      //print(list4);      startTime = System.currentTimeMillis();      mergeSort(list4);      endTime = System.currentTimeMillis();      executionTime[k][3] = endTime - startTime;      //print(list4);      startTime = System.currentTimeMillis();      quickSort(list5);      endTime = System.currentTimeMillis();      executionTime[k][4] = endTime - startTime;           startTime = System.currentTimeMillis();      heapSort(list6);      endTime = System.currentTimeMillis();      executionTime[k][5] = endTime - startTime;      startTime = System.currentTimeMillis();      radixSort(list, 5);      endTime = System.currentTimeMillis();      executionTime[k][6] = endTime - startTime;    }    for (int i = 0; i < 6; i++) {        System.out.print(BASE + i * BASE + " ");        for (int j = 0; j < 7; j++)            System.out.print("\t\t" + executionTime[i][j]);        System.out.println();    }  }  public static void print(Integer[] list){      int len=list.length;      for(int i=0;i<len;i++)          System.out.print(list[i]+" ");      System.out.println();              }  public static Integer[] initList(int[] array){      int len=array.length;      Integer[] list=new Integer[len];      for(int i=0;i<len;i++)          list[i]=array[i];      return list;  }    /** The method for sorting the numbers */    public static <E extends Comparable<E>> void selectionSort(E[] list) {        for (int i = list.length - 1; i >= 1; i--) {          // Find the maximum in the list[0..i]          E currentMax = list[0];          int currentMaxIndex = 0;          for (int j = 1; j <= i; j++) {            if (currentMax.compareTo(list[j]) < 0) {              currentMax = list[j];              currentMaxIndex = j;            }          }          // Swap list[i] with list[currentMaxIndex] if necessary;          if (currentMaxIndex != i) {            list[currentMaxIndex] = list[i];            list[i] = currentMax;          }        }    }  /** The method for sorting the numbers */  public static <E extends Comparable<E>> void insertionSort(E[] list) {    for (int i = 1; i < list.length; i++) {        /** insert list[i] into a sorted sublist list[0..i-1] so that             list[0..i] is sorted. */        E currentElement = list[i];        int k;        for (k = i - 1; k >= 0 && list[k].compareTo(currentElement) > 0; k--) {          list[k + 1] = list[k];        }        // Insert the current element into list[k+1]        list[k + 1] = currentElement;      }    }  /** The method for sorting the numbers */  public static <E extends Comparable<E>> void bubbleSort(E[] list) {        boolean needNextPass = true;        for (int k = 1; k < list.length && needNextPass; k++) {            // Array may be sorted and next pass not needed            needNextPass = false;            for (int i = 0; i < list.length - k; i++) {                if (list[i].compareTo(list[i + 1]) > 0) {                    // Swap list[i] with list[i + 1]                    E temp = list[i];                    list[i] = list[i + 1];                    list[i + 1] = temp;                    needNextPass = true; // Next pass still needed                }            }        }    }    /** The method for sorting the numbers */    public static <E extends Comparable<E>> void mergeSort(E[] list) {        if (list.length > 1) {          // Merge sort the first half          E[] firstHalf = (E[])new Comparable[list.length / 2];          System.arraycopy(list, 0, firstHalf, 0, list.length / 2);          mergeSort(firstHalf);          // Merge sort the second half          int secondHalfLength = list.length - list.length / 2;          E[] secondHalf = (E[])new Comparable[secondHalfLength];          System.arraycopy(list, list.length / 2,                           secondHalf, 0, secondHalfLength);          mergeSort(secondHalf);          // Merge firstHalf with secondHalf          E[] temp = merge(firstHalf, secondHalf);          System.arraycopy(temp, 0, list, 0, temp.length);        }    }    private static<E extends Comparable<E>> E[] merge(E[] list1, E[] list2) {        E[] temp = (E[])new Comparable[list1.length + list2.length];        int current1 = 0; // Index in list1        int current2 = 0; // Index in list2        int current3 = 0; // Index in temp        while (current1 < list1.length && current2 < list2.length) {          if (list1[current1].compareTo(list2[current2]) < 0) {            temp[current3++] = list1[current1++];          }          else {            temp[current3++] = list2[current2++];          }        }        while (current1 < list1.length) {          temp[current3++] = list1[current1++];        }        while (current2 < list2.length) {          temp[current3++] = list2[current2++];        }        return temp;    }  public static<E extends Comparable<E>>void quickSort(E[] list) {    quickSort(list, 0, list.length - 1);  }  private static<E extends Comparable<E>>void quickSort(E[] list, int first, int last) {    if (last > first) {      int pivotIndex = partition(list, first, last);      quickSort(list, first, pivotIndex - 1);      quickSort(list, pivotIndex + 1, last);    }  }  /** Partition the array list[first..last] */  private static<E extends Comparable<E>>int partition(E[] list, int first, int last) {    E pivot = list[first]; // Choose the first element as the pivot    int low = first + 1; // Index for forward search    int high = last; // Index for backward search    while (high > low) {      // Search forward from left      while (low <= high && list[low].compareTo(pivot) <= 0) {        low++;      }      // Search backward from right      while (low <= high && list[high].compareTo(pivot) > 0) {        high--;      }      // Swap two elements in the list      if (high > low) {        E temp = list[high];        list[high] = list[low];        list[low] = temp;      }    }    while (high > first && list[high].compareTo(pivot) >= 0) {      high--;    }    // Swap pivot with list[high]    if (pivot.compareTo(list[high]) > 0) {      list[first] = list[high];      list[high] = pivot;      return high;    }    else {      return first;    }  }  public static<E extends Comparable<E>>void heapSort(E[] list) {    Heap<E> heap = new Heap<E>(); // Create a Heap    // Add elements to the heap    for (int i = 0; i < list.length; i++) {      heap.add(list[i]);    }    // Remove elements from the heap    for (int i = list.length - 1; i >= 0; i--) {      list[i] = heap.remove();    }  }  /** Sort the int array list. numberOfDigits is the number of digits   * in the largest number in the array */  public static void radixSort(int[] list, int numberOfDigits) {    java.util.ArrayList<Integer>[] buckets = new java.util.ArrayList[10];    for (int i = 0; i < buckets.length; i++) {      buckets[i] = new java.util.ArrayList<Integer>();    }    for (int position = 0; position <= numberOfDigits; position++) {      // Clear buckets      for (int i = 0; i < buckets.length; i++) {        buckets[i].clear();      }            // Distribute the elements from list to buckets      for (int i = 0; i < list.length; i++) {        int key = getKey(list[i], position);        buckets[key].add(list[i]);      }      // Now move the elements from the buckets back to list      int k = 0; // k is an index for list      for (int i = 0; i < buckets.length; i++) {        if (buckets[i] != null) {          for (int j = 0; j < buckets[i].size(); j++)            list[k++] = buckets[i].get(j);        }      }    }  }  /** Return the digit at the specified position.    * The last digit's position is 0. */  public static int getKey(int number, int position) {    int result = 1;    for (int i = 0; i < position; i++)      result *= 10;    return (number / result) % 10;  }  static class Heap <E extends Comparable<E>> {    java.util.ArrayList<E> list = new java.util.ArrayList<E>();    /** Create a default heap */    public Heap() {    }    /** Create a heap from an array of objects */    public Heap(E[] objects) {      for (int i = 0; i < objects.length; i++) {        add(objects[i]);      }    }    /** Add a new object into the heap */    public void add(E newObject) {      list.add(newObject); // Append to the heap      int currentIndex = list.size() - 1; // The index of the last node      while (currentIndex > 0) {        int parentIndex = (currentIndex - 1) / 2;        // Swap if the current object is greater than its parent        if (list.get(currentIndex).compareTo(list.get(parentIndex)) > 0) {        //最小堆        //if (list.get(currentIndex).compareTo(list.get(parentIndex)) < 0) {              E temp = list.get(currentIndex);          list.set(currentIndex, list.get(parentIndex));          list.set(parentIndex, temp);        }        else {          break; // the tree is a heap now        }        currentIndex = parentIndex;      }    }    /** Remove the root from the heap */    public E remove() {      if (list.size() == 0) {        return null;      }      E removedObject = list.get(0);      list.set(0, list.get(list.size() - 1));      list.remove(list.size() - 1);      int currentIndex = 0;      while (currentIndex < list.size()) {        int leftChildIndex = 2 * currentIndex + 1;        int rightChildIndex = 2 * currentIndex + 2;        // Find the maximum between two children        if (leftChildIndex >= list.size()) {          break; // The tree is a heap        }        int maxIndex = leftChildIndex;        if (rightChildIndex < list.size()) {          if (((Comparable)(list.get(maxIndex))).compareTo(            list.get(rightChildIndex)) < 0) {//>0            maxIndex = rightChildIndex;          }        }        // Swap if the current node is less than the maximum        if (((Comparable)(list.get(currentIndex))).compareTo(          list.get(maxIndex)) < 0) {//>0          E temp = list.get(maxIndex);          list.set(maxIndex, list.get(currentIndex));          list.set(currentIndex, temp);          currentIndex = maxIndex;        }        else {          break; // The tree is a heap        }      }      return removedObject;    }    /** Get the number of nodes in the tree */    public int getSize() {      return list.size();    }  }}

结果如下：