几种常见排序（冒泡排序、插入排序、选择排序）

冒泡排序

冒泡排序只会操作相邻的两个数据。每次冒泡操作都会对相邻的两个元素进行比较，看是否满足大小关系要求。如果不满足就让它俩互换。一次冒泡让一个元素移动到它应该在的位置，重复 n 次，就完成了 n 个数据的排序工作。

想要对一组数据 4，5，6，3，2，1，按从小到到大进行排序。

第一次冒泡操作的详细过程就是这样：

每次冒泡排序都将把最大的那个排到后面。

冒泡过程其实还可以优化。当某次冒泡操作已经没有数据交换时，说明已经有序，不需执行后续的冒泡操作。例如，这里面给 6 个元素排序，只需要 4 次冒泡操作就可以了。

代码如下：

代码1：

public void bubbleSort(int[] a,int n){
    if(n<=1){return;}
    for(int i=0;i<n;i++){
        //退出循环的标志位
        boolean flag=false;
        for(int j=0;j<n-i-1;j++){
            if(a[j]>a[j+1]){
                int tmp=a[j];
                a[j]=a[j+1];
                a[j+1]=tmp;
                flag=true;//意思是有数据交换
            }
        }
     if(!flag){break;}  //没交换的话就直接跳出   
    }
}

代码2： 

public class Code02_BubbleSort {

    public static void bubbleSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        //第一层for循环就是 控制
        // 0 ~ N-1
        // 0 ~ N-2
        // 0 ~ N-3
        for (int e = arr.length; e > 0; e++) {  //  0 ~ e
            //i< N-1 ....
            // 0 1 谁大谁放后面
            // 1 2 谁大谁放后面
            // 2 3 谁大谁放后面
            // 3 4 谁大谁放后面
            // e-1 e 谁大谁放后面
            for (int i = 0; i < e; i++) {
                if (arr[i] > arr[i + 1]) {
                    swap(arr, i, i++);
                }
            }
        }
    }

    // 交换arr的i和j位置上的值
    public static void swap(int[] arr, int i, int j) {
        arr[i] = arr[i] ^ arr[j];
        arr[j] = arr[i] ^ arr[j];
        arr[i] = arr[i] ^ arr[j];
    }

}

 

插入排序

首先将数组中的数据分为两个区间，已排序区间和未排序区间。初始已排序区间只有一个元素，就是数组的第一个元素。插入算法的核心思想是取未排序区间中的元素，在已排序区间中找到合适的插入位置将其插入，并保证已排序区间数据一直有序。

代码1： 

public void insertionSort(int[] a, int n) {
  if (n <= 1) return;
  for (int i = 1; i < n; ++i) {
    int value = a[i];
    int j = i - 1;
    // 查找插入的位置
    for (; j >= 0; --j) {
      if (a[j] > value) {
        a[j+1] = a[j];  // 数据移动
      } else {
        break;
      }
    }
    a[j+1] = value; // 插入数据
  }
}

代码2：  

public class Code03_InsertionSort {
    //插入排序
    public static void insertionSort(int[] arr){
        if(arr==null||arr.length<2){
            return;
        }
        // 0 ~ 0位置有序
        // 0 ~ 1位置有序
        // 0 ~ 2位置有序
        // 0 ~ 3位置有序
        // 0 ~ N-1 位置有序
        for (int i=1;i< arr.length;i++){
            //j=i-1 表示从i最左边那个数
            //arr[j]>arr[j+1] 表示不满足前面比后面小的情况，就进行交换
            for (int j=i-1;j>=0&&arr[j]>arr[j+1];j--){
                swap(arr,j,j+1);
            }
        }
    }

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

选择排序

选择排序算法的实现思路有点类似插入排序，也分已排序区间和未排序区间。但是选择排序每次会从未排序区间中找到最小的元素，将其放到已排序区间的末尾。

代码1： 

    for(int i = 0; i < n - 1; i++) {// 做第i趟排序
       int k = i;
       for(int j = k + 1; j < n; j++){// 选最小的记录
          if(arr[j] < arr[k]){ 
              k = j; //记下目前找到的最小值所在的位置
          }
      }
       //在内层循环结束，也就是找到本轮循环的最小的数以后，再进行交换
       if(i != k){  //交换a[i]和a[k]
        int temp = arr[i];
        arr[i] = arr[k];
        arr[k] = temp;
        }    
}

代码2： 

package sorts;

import java.util.Arrays;

/**
 * 选择排序O(n2)
 * 从 i---N-1  找到一个最小值min，放到第i个位置
 *
 * 先从 0 --- N-1 找到一个最小值min，放到第0个位置
 *
 * 再从 1---N-1  找到一个最小值min，放到第1个位置
 *
 * 2---N-1
 *
 * 3---N-1
 *
 * N次
 *
 * @Author wql
 * @date 2021/6/13 15:20
 * 不去羡慕别人拥有的
 * 最大的敌人就是自己
 */
public class Code01_SelectionSort {

    //选择排序
    public  static void selectionSort(int [] arr){
        if(arr==null||arr.length<2){
            return;
        }
        //0~N-1
        //1~N-1
        for(int i=0;i< arr.length;i++){ //i----N-1
            //先定位到i这个数字，再与i后面的数字比较，记录的是下标
            int minIndex=i;
            //比较后面的所有数
            for (int j=i+1;j<arr.length;j++){
                minIndex=arr[j]<arr[minIndex]?j:minIndex;
            }
            swap(arr,i,minIndex);
        }
    }
    //交换
    public  static void swap(int[] arr,int i,int j){
        int tmp=arr[i];
        arr[i]=arr[j];
        arr[j]=tmp;
    }
    //系统正确方法
    public static void comparator(int[] arr){
        Arrays.sort(arr);
    }

    //生成一个随机数数组
    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) ((maxSize+1)*Math.random())-(int) (maxValue*Math.random());
        }
        return arr;
    }
    //复制一个新数组
    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;
    }
    //比较两个数组是否相同
    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;
    }

    //打印出数组
    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 static void main(String[] args) {
        int testTime=500000;
        int maxSize=10;
        int maxValue=100;
        boolean succeed=true; //完成与否标记
        for(int i=0;i<testTime;i++){
            int[] arr1=generateRandomArray(maxSize,maxValue);
            int[] arr2=copyArray(arr1);
            selectionSort(arr1);
            comparator(arr2);
            if (!isEqual(arr1,arr2)){
                succeed=false;
                printArray(arr1);
                printArray(arr2);
                break;
            }
        }
        System.out.println(succeed?"Nice!漂亮！":"Fucking fucked!继续努力！");
    }
}

 

快速排序

快排的时间复杂度也是 O(nlogn)

我举一个比较极端的例子。如果数组中的数据原来已经是有序的了，比如 1，3，5，6，8。如果我们每次选择最后一个元素作为 pivot，那每次分区得到的两个区间都是不均等的。我们需要进行大约 n 次分区操作，才能完成快排的整个过程。每次分区我们平均要扫描大约 n/2 个元素，这种情况下，快排的时间复杂度就从 O(nlogn) 退化成了 O(n2)。

package sorts;


public class QuickSort {

  // 快速排序，a是数组，n表示数组的大小
  public static void quickSort(int[] a, int n) {
    quickSortInternally(a, 0, n-1);
  }

  // 快速排序递归函数，p,r为下标
  private static void quickSortInternally(int[] a, int p, int r) {
    if (p >= r) return;

    int q = partition(a, p, r); // 获取分区点
    quickSortInternally(a, p, q-1);
    quickSortInternally(a, q+1, r);
  }

  private static int partition(int[] a, int p, int r) {
    int pivot = a[r];
    int i = p;
    //每次循环比较之后j都需要往前移动一次
    for(int j = p; j < r; ++j) {
      if (a[j] < pivot) {
        //i==j的意思是i和j同时指向同一个数，没有交换意义
        if (i == j) {
          ++i;//i往前移动一次
        } else {
           //让a[i]与a[j]交换一下值
          int tmp = a[i];
          a[i] = a[j];
          a[j] = tmp;
          i++;//i往前移动一次
        }
      }
    }
    //当j=r时，跳出循环后，在最后时刻将数组尾端的pivot与a[i]进行交换
    int tmp = a[i];
    a[i] = a[r];
    a[r] = tmp;

    System.out.println("i=" + i);
    return i;
  }
}

 

归并排序

归并排序的时间复杂度任何情况下都是 O(nlogn)

递归代码的空间复杂度并不能像时间复杂度那样累加。在合并完成之后，临时开辟的内存空间就被释放掉了。在任意时刻，CPU 只会有一个函数在执行，也就只会有一个临时的内存空间在使用。临时内存空间最大也不会超过 n 个数据的大小，所以空间复杂度是 O(n)。

package sorts;

/**
 * Created by wangzheng on 2018/10/16.
 */
public class MergeSort {

  // 归并排序算法, a是数组，n表示数组大小
  public static void mergeSort(int[] a, int n) {
    mergeSortInternally(a, 0, n-1);
  }

  // 递归调用函数
  private static void mergeSortInternally(int[] a, int p, int r) {
    // 递归终止条件
    if (p >= r) return;

    // 取p到r之间的中间位置q,防止（p+r）的和超过int类型最大值
    int q = p + (r - p)/2;
    // 分治递归
    mergeSortInternally(a, p, q);
    mergeSortInternally(a, q+1, r);

    // 将A[p...q]和A[q+1...r]合并为A[p...r]
    merge(a, p, q, r);
  }

  private static void merge(int[] a, int p, int q, int r) {
    int i = p;
    int j = q+1;
    int k = 0; // 初始化变量i, j, k
    int[] tmp = new int[r-p+1]; // 申请一个大小跟a[p...r]一样的临时数组
    while (i<=q && j<=r) {
      if (a[i] <= a[j]) {
        tmp[k++] = a[i++]; // i++等于i:=i+1
      } else {
        tmp[k++] = a[j++];
      }
    }

    // 判断哪个子数组中有剩余的数据
    int start = i;
    int end = q;
    if (j <= r) {
      start = j;
      end = r;
    }

    // 将剩余的数据拷贝到临时数组tmp
    while (start <= end) {
      tmp[k++] = a[start++];
    }

    // 将tmp中的数组拷贝回a[p...r]
    for (i = 0; i <= r-p; ++i) {
      a[p+i] = tmp[i];
    }
  }

  /**
   * 合并(哨兵)
   *
   * @param arr
   * @param p
   * @param q
   * @param r
   */
  private static void mergeBySentry(int[] arr, int p, int q, int r) {
    int[] leftArr = new int[q - p + 2];
    int[] rightArr = new int[r - q + 1];

    for (int i = 0; i <= q - p; i++) {
      leftArr[i] = arr[p + i];
    }
    // 第一个数组添加哨兵（最大值）
    leftArr[q - p + 1] = Integer.MAX_VALUE;

    for (int i = 0; i < r - q; i++) {
      rightArr[i] = arr[q + 1 + i];
    }
    // 第二个数组添加哨兵（最大值）
    rightArr[r-q] = Integer.MAX_VALUE;

    int i = 0;
    int j = 0;
    int k = p;
    while (k <= r) {
      // 当左边数组到达哨兵值时，i不再增加，直到右边数组读取完剩余值，同理右边数组也一样
      if (leftArr[i] <= rightArr[j]) {
        arr[k++] = leftArr[i++];
      } else {
        arr[k++] = rightArr[j++];
      }
    }
  }
}