常见排序算法

浙江大学数据结构课程

参考：https://www.icourse163.org/learn/ZJU-93001?tid=1002654021#/learn/content?type=detail&id=1003627008&cid=1004311499&replay=true

时间复杂度

1. what：评价算法好坏（读big O）
2. 计算方法是：要高阶去低阶
3. 运行时间不是指实际程序运行的时间 而是程序执行的操作数
4. 运行时间比较的角度是随着时间的增大函数曲线的变化的幅度

空间复杂度

1. what：评价算法好坏（读big O）
2. 计算方法是：要高阶去低阶
3. O（1）：自己建几个变量
4. O（n）：自己建一个数组或者该数组是目标数组的一半（忽略系数）

常见排序算法性能

算法	时间复杂度	空间复杂度	稳定性
冒泡排序	O(N^2)	O(1)	稳定
插入排序	O(N^2)	O(1)	稳定
选择排序	O(N^2)	O(1)	不稳定
归并排序	O(nlogn)	O(n)	稳定
快速排序	O(nlogn)	O(logn)	不稳定
堆排序	O(nlogn)	O(1)	不稳定

0 BaseSort

package 常见排序算法.练习;

import java.util.Arrays;

/**
 * @Description:
 * @Author: boolean
 * @Date: 2019/11/17 18:14
 */
public abstract  class BaseSort {
    // for test
    public static void comparator(int[] arr) {
        Arrays.sort(arr);
    }

    public static void swap(int[] arr, int i, int j) {
        //其实就是交换

        int tmp  = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;

    }

    // for test
    public static int[] generateRandomArray(int maxSize, int maxValue) {
        int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) ((maxValue + 1) * Math.random());
        }
        return arr;
    }

    // for test
    public static int[] copyArray(int[] arr) {
        if (arr == null) {
            return null;
        }
        int[] res = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            res[i] = arr[i];
        }
        return res;
    }

    // for test
    public static boolean isEqual(int[] arr1, int[] arr2) {
        if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
            return false;
        }
        if (arr1 == null && arr2 == null) {
            return true;
        }
        if (arr1.length != arr2.length) {
            return false;
        }
        for (int i = 0; i < arr1.length; i++) {
            if (arr1[i] != arr2[i]) {
                return false;
            }
        }
        return true;
    }

    // for test
    public static void printArray(int[] arr) {
        if (arr == null) {
            return;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

     public void testSort(BaseSort sort){
         int testTime = 500000;
        int maxSize = 100;
        int maxValue = 100;
        boolean succeed = true;
        for (int i = 0; i < testTime; i++) {
            int[] arr1 = generateRandomArray(maxSize, maxValue);
            int[] arr2 = copyArray(arr1);
            sort.sort(arr1);
            comparator(arr2);
            if (!isEqual(arr1, arr2)) {
                succeed = false;
                break;
            }
        }
        System.out.println(succeed ? "Nice!" : "Fucking fucked!");

        int[] arr = generateRandomArray(maxSize, maxValue);
        printArray(arr);
         sort.sort(arr);
        printArray(arr);

     }

    protected abstract void sort(int[] arr);


}

1.冒泡排序（BubbleSort）

思想：

https://www.cnblogs.com/kkun/archive/2011/11/23/bubble_sort.html

代码1

import java.util.Arrays;

/**
 * Created by buer on 2018/8/13.
 */
//冒泡排序
   
public class BubbleSort {
    /**
     * 进行冒泡函数
     * @param arr
     */
    public static void  bubbleSort(int[] arr){  
        if (arr == null || arr.length < 2){
            return;
        }

        for (int end = arr.length - 1; end > 0; end--){ //控制队列尾部位置，不断向前
            for (int i = 0; i < end; i ++){  //从头到尾两两比较
                if (arr[i] > arr[i + 1]){
                    swap(arr, i, i+1);
                }
            }
        }
    }

    /**
     * 交换函数
     */
    public  static void swap( int[] arr, int i, int j){
        int tmp  = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;

        //其实就是交换

        //arr[i] = arr[i] ^ arr[j];
        //arr[j] = arr[i] ^ arr[j];
        //arr[i] = arr[i] ^ arr[j];
    }

}

2.选择排序（SelectSort）

思想：

• 1 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，
• 2 然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
• 3 以此类推，直到所有元素均排序完毕。

代码1

public class SelectSort extends BaseSort {
    @Override
    protected void sort(int[] arr) {
        for (int i = 0; i < arr.length -1 ; i++) {
            int min = i;
            for (int j =  i + 1; j < arr.length; j++) {
                if (arr[min] > arr[j]){
                    min = j;
                }
            }
            swap(arr, i, min);
        }
    }

    @Test
    public void test(){
        BaseSort sort = new SelectSort();
        sort.testSort(sort);
    }
}

3.插入排序（InsertSort）

思想：

和打牌一样,后来的牌与前面相比，如果前面的牌大，就将大的牌向后移动

代码：

import java.util.Arrays;

/**
 * Created by buer on 2018/8/15.
 */
public class InsertSort extends BaseSort {
    @Override
    protected void sort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            for (int j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j --) {
                    swap(arr, j, j + 1);
            }
        }
    }
    @Test
    public void test( ){
        BaseSort sort  = new InsertSort();
        sort.testSort(sort);

    }
}

4.归并排序

思想：

https://www.cnblogs.com/chengxiao/p/6194356.html

• 1.按中间位置左右递归划分模块
• 2.申请一个辅助数组
• 2.比较两个数组元素的大小，按小到大放进辅助数组中
• 3.比较后剩余元素直接放在辅助数组后面
• 4.将辅助数组放进原来的数组

代码

import java.util.Arrays;

public class Code_05_MergeSort {

   public static void mergeSort(int[] arr) {
      if (arr == null || arr.length < 2) {
         return;
      }
      mergeSort(arr, 0, arr.length - 1);
   }

   public static void mergeSort(int[] arr, int l, int r) {
      if (l == r) {
         return;
      }
      int mid = l + ((r - l) >> 1); //l r中点  位运算
      mergeSort(arr, l, mid);   //左部分有序
      mergeSort(arr, mid + 1, r);       //有部分有序
      merge(arr, l, mid, r);
   }

   public static void merge(int[] arr, int l, int m, int r) {
      int[] help = new int[r - l + 1];
      int i = 0;
      int p1 = l;          //左部分第一个数
      int p2 = m + 1;       //有部分第一个数
      while (p1 <= m && p2 <= r) {
         help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++]; //填的数字加1之前的数
      }

      //下面两个循环只发生一个
      while (p1 <= m) {
         help[i++] = arr[p1++];
      }
      while (p2 <= r) {
         help[i++] = arr[p2++];
      }
      for (i = 0; i < help.length; i++) {
         arr[l + i] = help[i];
      }
   }

}

5 快速排序

思想

• 1 找出基准（选中间值）
• 2 移动左边数字直到数字大于基准
• 3 移动右边数字直到数字小于基准
• 4 交换左右数字(与基准值相等的数可以到任何一边)
• 5 左边递归
• 6 右边递归

public class QucikSort  {
    public static void quickSort(int[] arr, int left, int right){
        if ( left >= right||arr == null || arr.length <= 1){
            return;
        }
        int pivot = arr[left + ((right - left) >> 1)];
        int i = left;
        int j = right;
        while (i <= j  ){
            while (arr[i] < pivot){
                ++i ;
            }
            while (arr[j] > pivot){
               -- j ;
            }
            if (i < j) {
                int t = arr[i];
                arr[i] = arr[j];
                arr[j] = t;
                ++i;
                --j;
            } else if (i == j) {
                ++i;
            }
        }
        quickSort(arr, left, j);
        quickSort(arr,i, right);
    }
}

tip

快速排序适合大数据排序，小数据的话插入排序更为适合

6.堆排序

思想：

• 1.从右到左，从下到上创建大顶堆
• 2.将堆顶元素放到数组最后，调整大顶堆
  图例：

代码：

public class HeapSort extends BaseSort {
    @Override
    protected void sort(int[] arr) {
        //1.构建大顶堆
        for(int i=arr.length/2-1;i>=0;i--){
            //从第一个非叶子结点从下至上，从右至左调整结构
            adjustHeap(arr,i,arr.length);
        }
        //2.调整堆结构+交换堆顶元素与末尾元素
        for(int j=arr.length-1;j>0;j--){
            swap(arr,0,j);//将堆顶元素与末尾元素进行交换
            adjustHeap(arr,0,j);//重新对堆进行调整
        }
    }

    /**
     * 调整大顶堆（仅是调整过程，建立在大顶堆已构建的基础上）
     * @param arr
     * @param i
     * @param length
     */
    public static void adjustHeap(int []arr,int i,int length){
        int temp = arr[i];//先取出当前元素i
        for(int k=i*2+1;k<length;k=k*2+1){//从i结点的左子结点开始，也就是2i+1处开始
            if(k+1<length && arr[k]<arr[k+1]){//如果左子结点小于右子结点，k指向右子结点
                k++;
            }
            if(arr[k] >temp){//如果子节点大于父节点，将子节点值赋给父节点（不用进行交换）
                arr[i] = arr[k];
                i = k;
            }else{
                break;
            }
        }
        arr[i] = temp;//将temp值放到最终的位置
    }

    private void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

    public static void main(String[] args) {
        BaseSort sort = new HeapSort();
        sort.testSort(sort);

    }
}