排序算法

排序算法（上次更新2021.03.25）

1. 冒泡排序

• 代码实现：

private final int [] arr = new int[]{1,3,2,8,5,6,7,4};
// 冒泡排序
public void bubbleSort(){
    for(int i = 0; i < arr.length; i++){
        // 外层循环遍历次数
        for (int j = 0; j < arr.length - i - 1; j++){
            // 内层循环，升序（前一个比后一个大，则交换）
            // 内层循环一次，获取一个最大值
            if (arr[j] > arr[j+1]){
                int temp = arr[j+1];
                arr[j+1] = arr[j];
                arr[j] = temp;
            }
        }
    }
    System.out.println("冒泡排序结果如下：");
    for (int i = 0; i < arr.length; i++) {
        System.out.print(arr[i] + "");
    }
}

2. 选择排序

• 代码实现：

  private final int [] arr = new int[]{1,3,2,8,5,6,7,4};
  // 选择排序
  //说明：将i前面的数据看成一个排好的队列，i后面的看成一个无序队列。每次只需要找无需的最小值，做替换
  public void selectSort(){
      for (int i = 0; i < arr.length; i++){
          // 默认第一个是最小的。
          int min = arr[i];
          // 记录最小的下标
          int index = i;
          // 通过与后面的数据进行比较得出，最小值和下标
          for (int j = i + 1; j < arr.length; j++){
              if (arr[j] < min){
                  min = arr[j];
                  index = j;
              }
          }
          // 然后将最小值与本次循环的，开始值交换
          int temp = arr[i];
          arr[i] = min;
          arr[index] = temp;
      }
  
      System.out.println();
      System.out.println("选择排序结果如下：");
      for (int i = 0; i < arr.length; i++) {
          System.out.print(arr[i] + "");
      }
  }
  

3. 插入排序

• 代码实现：

• 位移法（优化版）

    // 插入排序（位移法）
    public void insertSort2(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            // 保存交换的值
            int insertVal = arr[i];
            int insertIndex = i - 1;
            // 如果比交换的值大，位移一位
            while (insertIndex >= 0 && arr[insertIndex] > insertVal) {
                arr[insertIndex + 1] = arr[insertIndex];
                insertIndex--;
            }
            // 循环退出，插入交换的值
            if (insertIndex + 1 != i) {
                arr[insertIndex + 1] = insertVal;
            }
        }
        System.out.println();
        System.out.println("插入排序结果如下：");
        System.out.println(Arrays.toString(arr));
    }

• 交换法

      // 插入排序
      public void insertSort(){
          for (int i = 1; i < arr.length; i++){
              //外层循环，从第二个开始比较
              for (int j = i; j > 0; j--){
                  //内存循环，与前面排好序的数据比较，如果后面的数据小于前面的则交换
                  if (arr[j] < arr[j-1]){
                      int temp = arr[j];
                      arr[j] = arr[j-1];
                      arr[j-1] = temp;
                  }else{
                      //如果不小于，说明插入完毕，退出内层循环
                      break;
                  }
              }
          }
          System.out.println();
          System.out.println("插入排序结果如下：");
          for (int i = 0; i < arr.length; i++) {
              System.out.print(arr[i] + "");
          }
      }
  

4. 希尔排序

• 代码实现

• 位移法（优化版）

  // 位移法shellSort
    public void shellSort2(int[] arr) {
        for (int gap = arr.length / 2; gap > 0; gap /= 2) {
            //从gap元素开始，逐个对其所在的组进行直接插入排序
            for (int i = gap; i < arr.length; i++) {
                int j = i;
                int temp = arr[j];
                if (arr[j] < arr[j - gap]) {
                    while (j - gap >= 0 && temp < arr[j - gap]) {
                        // 位移
                        arr[j] = arr[j - gap];
                        j -= gap;
                    }
                    // 循环退出，找到插入位置
                    arr[j] = temp;
                }
            }
        }
        System.out.println();
        System.out.println("希尔排序（位移法）结果如下：");
        System.out.println(Arrays.toString(arr));
    }
  

• 交换法（效率低）

// 希尔排序（交换法）效率低
    public void shellSort(int[] arr) {
        for (int d = arr.length / 2; d > 0; d /= 2) {
            for (int i = d; i < arr.length; i++) {
                for (int j = i - d; j >= 0; j -= d) {
                    if (arr[j] > arr[j + d]) {
                        int temp = arr[j];
                        arr[j] = arr[j + d];
                        arr[j + d] = temp;
                    }
                }
            }
        }
        System.out.println();
        System.out.println("希尔排序结果如下：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "");
        }
    }

5. 快速排序

• 代码实现：

  // 快速排序
  public void quickSort(int[] arr, int left, int right){
      int l = left;   // 左下标
      int r = right;  // 右下标
      int pivot = arr[(left + right) / 2];
      int temp = 0;
  
      while (l < r){
          while (arr[l] < pivot){
              l += 1;
          }
          while (arr[r] > pivot){
              r -= 1;
          }
  
          // 如果l>=r时，pivot左边的值都小于pivot，右边的值都大于pivot
          // 退出当前循环
          if (l >= r){
              break;
          }
  
          // 交换
          temp = arr[l];
          arr[l] = arr[r];
          arr[r] = temp;
  
          // 如果 arr[l] == pivot，没必要交换，r--
          if (arr[l] == pivot){
              r -= 1;
          }
          // 如果 arr[r] == pivot，没必要交换，l++
          if (arr[r] == pivot){
              l += 1;
          }
  
      }
      // 排序第一步完成，pivot左边的值都小于pivot，右边的值都大于pivot
  
      // 补充条件：当l == r，时 必须l++，r--,否则一直递归，栈溢出
      if (l == r){
          l += 1;
          r -= 1;
      }
  
      // 第二步：向左递归，向右递归
      if (left < r){
          quickSort(arr, left, r);
      }
      if (right > l){
          quickSort(arr, l, right);
      }
  
  }
  

6. 归并排序

7. 时间复杂度