排序算法-冒泡、选择、插入、希尔

参考：
https://www.cnblogs.com/onepixel/p/7674659.html

---

排序算法相关描述

顾名思义，排序算法是为了给一定范围内的数字进行从小到大或者从大到小进行排序，分为比较类排序与非比较类排序。

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

相关概念

• 稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。
• 不稳定：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b 的后面。

算法相关复杂度

冒泡排序(Bubble Sort)

每次选择两个元素比较大小然后进行交换，根据需要排列元素的大小，时间复杂度最好的话是O(n)，最坏以及平均时间复杂度是O(n^2)，空间复杂度因为没有占用额外的空间，所以为O(1)。
动态展示：

java代码

	// 公共代码块
	
    static void printArr(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
         //   System.out.println();
    }


    /**
     * @Author kangyu
     * @Description 交换数值
     * @Date 11:07 2020/2/21
     * @Param [arr, i, j]
     * @return void
     **/
    static void exchange(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

	@Test
    public void bubble() {
        int[] arr = new int[]{6,1,3,2,4,5};
       for (int j = 0; j < arr.length; j++) {
           for (int i = 0; i < arr.length - j - 1; i++) {
               if (arr[i] > arr[i + 1]) {
                    exchange(arr, i, i + 1);
               }
           }
       }
       printArr(arr);
    }

选择排序(Selection Sort)

从排序序列中找到最小的值，放在序列的首位，然后从剩余的值中依次找最小的值放入已经排序的后面。
动态展示：

java代码

	static void sort(int[] arrData) {
        for (int i = 0; i < arrData.length - 1; i++) {
            int min = i;
            for (int j = i; j < arrData.length - 1; j++) {
                if (arrData[min] > arrData[j + 1]) {
                   min = j + 1;
                }
            }
            if (min != -1) {
                exchange(arrData, i, min);
            }
           // print(arrData);
        }
    }

插入排序（Insertion Sort）

分为有序和无序两部分，从第二个数进行比较，通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
动图展示：

java代码

 static void sort(int[] arrInt) {
        for (int i = 1; i < arrInt.length; i++) {
            int temp = arrInt[i];
            int z = i;
            // 如果用临时变量来存储，该如何做？
            for (int j = i; j > 0 ; j--) {
                if (temp < arrInt[j - 1]) {
                      arrInt[j] = arrInt[j - 1];
                      z--;
                } else {
                    break;
                }
            }

            if (z != i) {
                arrInt[z] = temp;
            }

            // while做法
            /*
            int z = i;
            while (z != 0) {
                if (arrInt[z] < arrInt[z - 1]) {
                    exchange(arrInt, z, z - 1);
                }
                z--;
            }*/

            // for循环做法
            /*for (int j = i; j > 0 ; j--) {
                if (arrInt[j] < arrInt[j - 1]) {
                    exchange(arrInt, j, j - 1);
                }
            }*/


        }
        printArr(arrInt);
    }

希尔排序(Shell Sort)

这个排序是插入排序的优化版本，是基于插入排序的，核心思想就是通过gap(间隔)来进行排序，比如gap为4，那么（1，5，9）（2，6，10）先排序，最终还是要通过插入排序全部排一遍。

动态展示

java代码

	static void sort2(int[] arr) {
        for (int gap = arr.length/2; gap > 0 ; gap/=2) {
            for (int i = gap; i < arr.length; i++) {
                for (int j = i; j > gap - 1; j=j-gap) {
                    if (arr[j] < arr[j - gap]) {
						exchange(arr, j, j - gap);
                    }
                }
            }
        }
       // Tools.print(arr);
    }