排序总结

冒泡排序

  比较相邻两个元素，上浮轻(小)元素或者下沉重(大)的元素
  例子：int arrayNum[] = {6, 2, 1, 3, 8, 7, 0}

  第一趟交换过程
       6 2 1 3 8 7 0
       2 6 1 3 8 7 0
       2 1 6 3 8 7 0
       2 1 3 6 8 7 0
       2 1 3 6 8 7 0
       2 1 3 6 7 8 0
       2 1 3 6 7 0 8

  第一趟排序结果-> 2 1 3 6 7 0 8

        for (int i = 0; i < arrayNum.length; i++) {
            for (int j = 0; j < arrayNum.length - 1; j++) {
                if (arrayNum[j] > arrayNum[j + 1]) {
                    int temp = arrayNum[j];
                    arrayNum[j] = arrayNum[j + 1];
                    arrayNum[j + 1] = temp;
                }
            }
        }

每一趟的排序结果
         2 1 3 6 7 0 8
         1 2 3 6 0 7 8
         1 2 3 0 6 7 8
         1 2 0 3 6 7 8
         1 0 2 3 6 7 8
         0 1 2 3 6 7 8
         0 1 2 3 6 7 8

选择排序

   寻找最大或者最小的元素置于首或尾
  例子：int arrayNum[] = {6, 2, 1, 3, 8, 7, 0}
  第一趟
     找到最小的元素 0 与 首位置元素6 交换
        0 2 1 3 8 7 6

        for(int i = 0; i < arrayNum.length; i ++){
            int min = i;
            for(int j = i + 1; j < arrayNum.length - i; j ++){
                if(arrayNum[i] > arrayNum[j]){
                    min = j;
                }
            }
            
            if(min != i){
                int temp = arrayNum[i];
                arrayNum[i] = arrayNum[min];
                arrayNum[min] = temp;
            }
        }

  每一趟的排序结果
         0 2 1 3 8 7 6
         0 1 2 3 8 7 6
         0 1 2 3 8 7 6
         0 1 2 3 8 7 6
         0 1 2 3 8 7 6
         0 1 2 3 8 7 6
         0 1 2 3 8 7 6

插入排序

   对于未排序的元素 在 已经排好序的元素里找合适的位置插入
  例子：int arrayNum[] = {6, 2, 1, 3, 8, 7, 0}
   第一趟
     假设位置0前元素已将排好序，位置1元素开始寻找合适的位置插入
         2 6 1 3 8 7 0

        for (int i = 1; i < arrayNum.length; i++) {
            // 已排序的位置
            int j = i - 1;

            // 本次插入元素
            int current = arrayNum[i];

            // 寻找插入的位置
            while (j >= 0 && arrayNum[j] > current) {
                arrayNum[j + 1] = arrayNum[j];
                j --;
            }
            // 将当前需要插入的元素放入合适的位置
            arrayNum[j + 1] = current;
        }

   每一趟排序结果
         2 6 1 3 8 7 0
         1 2 6 3 8 7 0
         1 2 3 6 8 7 0
         1 2 3 6 8 7 0
         1 2 3 6 7 8 0
         0 1 2 3 6 7 8

快速排序

   挑选基准，跟 基准 pivot比较大小分区

   例子：int arrayNum[] = {6, 2, 1, 3, 8, 7, 0}

   交换原则：右边空位，左边取值比较；左边空位，右边取值比较

   选取第一个元素为基准元素pivot

   第一趟交换过程, 6为基准，L位置为空
       空(L) 2 1 3 8 7 0( R)
       空位在左，基准跟R位置元素0相比，0 < 6，元素0填入L处空位，L+1
       0 2(L) 1 3 8 7 空( R)
       空位在右，跟L位置元素2相比，2 < 6 , L+1
       0 2 1(L) 3 8 7 空( R)
       空位在右，跟L位置元素1相比，1 < 6 , L+1
       0 2 1 3(L) 8 7 空( R)
       空位在右，跟L位置元素3相比，3 < 6 , L+1
       0 2 1 3 8(L) 7 空( R)
       空位在右， 跟L位置元素8相比，8 > 6 ，元素8填入R处空位，R-1
       0 2 1 3 空(L) 7 ( R) 8
       空位在左，基准跟R位置元素7相比，7 > 6，R-1
       0 2 1 3 空 (LR) 7 8
       L R重合，基准写入空位
       0 2 1 3 6 7 8

第一趟排序结果-> 0 2 1 3 6 7 8

    public static void quickSort(int[] arrayNum, int start, int end) {
        int i = start;
        int j = end;

        int pivot = arrayNum[start];
        while (i < j) {
            while (i < j && pivot <= arrayNum[j]){
                j--;
            }
            if (i < j) {
                swap(arrayNum, i, j);
            }

            while (i < j && arrayNum[i] <= pivot) {
                i++;
            }
            if (i < j) {
                swap(arrayNum, i, j);
            }
        }

        if (i - 1 > start) {
            quickSort(arrayNum, start, i - 1);
        }
        if (j + 1 < end) {
            quickSort(arrayNum, j + 1, end);
        }
    }

   每一趟排序结果
         0 2 1 3 6 7 8
         0 2 1 3 6 7 8
         0 1 2 3 6 7 8