【algorithm】排序算法

交换排序

• |–冒泡排序
  
  • |–快速排序
• 插入排序
  
  • |–直接插入排序
  • |–希尔排序
• 选择排序
  
  • |–简单选择排序
  • |–堆排序
• 归并排序
• 基数排序

稳定排序：假设在待排序的文件中，存在了两个或两个以上的记录具有相同的关键字，在某种排序算法排序后，若这些相同关键字的元素的相对次序依然不变，则这种排序方法是稳定的。

• 稳定：冒泡、插入、归并、基数
• 不稳定：选择、快速、希尔、堆

public static void main(String[] args) {
    int[] arr = {
  3,9,7,6,8,4,5,10,2,1};
    for (int i : arr) {
        System.out.print(i+" ");
    }
    System.out.println();
    //bubbleSort(arr);
    //quickSort(arr, 0, arr.length-1);
    //insertSort(arr);
    //shellSort(arr);
    //selectSort(arr);
    heapSort(arr, arr.length);
    //int[] merge = new int[10];
    //mergeSort(arr, merge, 0, arr.length-1);
    //basketSort(arr);
    for (int i : arr) {
        System.out.print(i+" ");
    }
    System.out.println();
}

public static void swap(int[] arr,int i,int j){
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

冒泡

/*
冒泡排序
最好时间复杂度 o(n),最坏时间复杂度o(n^2),平均o(n^2),稳定
*/
public static void bubbleSort(int[] arr){
    if (arr == null || arr.length == 0) {
        return;
    }
    for (int i = 0; i < arr.length-1; i++) {
        for (int j = 0; j < arr.length-1-i; j++) {
            if (arr[j] > arr[j+1]) {
                swap(arr,j,j+1);
            }
        }
    }
}

每趟排序结果:

 start : 3 9 7 6 8 4 5 10 2 1 
process: 3 7 6 8 4 5 9 2 1 10 
process: 3 6 7 4 5 8 2 1 9 10 
process: 3 6 4 5 7 2 1 8 9 10 
process: 3 4 5 6 2 1 7 8 9 10 
process: 3 4 5 2 1 6 7 8 9 10 
process: 3 4 2 1 5 6 7 8 9 10 
process: 3 2 1 4 5 6 7 8 9 10 
process: 2 1 3 4 5 6 7 8 9 10 
process: 1 2 3 4 5 6 7 8 9 10 
  end  : 1 2 3 4 5 6 7 8 9 10 

快排

/*
 * 快速排序
 * 最好时间复杂度 o(nlog(2)n),最坏时间复杂度o(n^2),平均o(n^2)，不稳定
 */
public static void quickSort(int[] arr,int left,int right){
  //左边索引小于右边，则还未排序完成 　
  if (left < right) {
    //取中间的元素作为比较基准，小于他的往左边移，大于他的往右边移 
    int mid = arr[(left+right)/2];
    int i = left - 1;
    int j = right + 1;
    while (true) {
      //移动下标，左边的往右移动，右边的向左移动
      while(arr[++i] < mid && i < right);
      while(arr[--j] > mid && j > left);
      if (i >= j) break;
      swap(arr, i, j);
    }
    quickSort(arr, left, i-1);
    quickSort(arr, j+1, right);
  }
}

每趟排序结果:

 start : 3 9