排序算法

分为两种，比较类排序，非比较排序

比较类排序

通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序

冒泡排序

数组无序，将元素按照大小顺序排列

• 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
• 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
• 针对所有的元素重复以上的步骤，除了最后一个；
• 重复步骤1~3，直到排序完成。

• class solution {
      public static void main(String[] args) {
          int[] arr = {9, 8, 5, 4, 2, 0};
          bubbleSort(arr);
          System.out.println(Arrays.toString(arr));
      }
  
  
      public static void bubbleSort(int[] arr) {
  
          for (int i = 0; i < arr.length - 1; i++) {
              for (int j = 0; j < arr.length - 1 - i; i++) {
                  if (arr[j] > arr[j + 1]) {
  
                      int temp = arr[j];
                      arr[j] = arr[j + 1];
                      arr[j + 1] = temp;
                  }
  
              }
          }
      }
  }

int i = 0;  数组遍历次数是 i < arr.length

冒泡排序每次都是两个数比较，第一层比较次数是arr.length - 1

后续比较次数是 arr.length - 1 - i ,此时的i代表的是层数，例如已经排出一个最大或最小的数，数组需要遍历的元素少了一个，以此类推

快速排序

冒泡排序的优化版

定义一个基准，两次判断出i<j 后的 两次while，是为了确认这个元素的位置正确

此时第一次判断已经完成，比基准小的都在左侧，比基准大的都在右侧

在进行两次递归，用于对左侧右侧进行排序，最终得出升序数组

import java.util.Arrays;

public class Augustsixth {

    public static void quickSort(int[] arr, int low, int high) {
        if (low < high) {
            int poivt = arr[low];
            int i = low;
            int j = high;

            while (i < j) {
                while (i < j && arr[j] >= poivt) {
                    j--;
                }
                swap(arr, i, j);
                while (i < j && arr[i] <= poivt) {
                    i++;
                }
                swap(arr,i,j);
            }
            quickSort(arr,low,j-1);
            quickSort(arr,j+1,high);

        }
    }


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

    public static void main(String[] args) {
        int[] arr = {5, 3, 7, 6, 4, 1, 0, 2, 9, 10, 8};
        quickSort(arr, 0, arr.length - 1);
        System.out.println(Arrays.toString(arr));
    }
}

插入排序

将n个待排序的元素分成 1 和 n-1 ，1为有序数组，且默认已排序，重复往进填元素，填充过程中判断元素插入位置

因为默认第一个元素已经排序，且后续会判断，所以从索引为 1 开始进行遍历

第二次循环从 i 开始，因为 i 为待插入位置，插入后，不停的与左侧进行判断大小

又因为是两个数进行比较，所以 j 只需 > 0 就可以与索引0进行判断。索引0左侧没有元素，若 j = 0，左侧没有元素，会出现索引异常

public static void InsertSort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            for (int j = i; j >= 0; j--) {
                if (arr[j] < arr[j - 1]) {
                    int temp = 0;
                    temp = arr[j];
                    arr[j] = arr[j - 1];
                    arr[j - 1] = temp;
                } else {
                    break;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] arr = {7, 6, 9, 3, 1, 5, 2, 4};
        InsertSort(arr);
        System.out.println(Arrays.toString(arr));
    }

希尔排序

不稳定