数据结构系列三：排序算法

1. 冒泡排序

 最基础排序，一句话总结冒泡排序，对于给定的数组，如果是升序排序，每一趟排序，都会把最大的元素放置在当前趟次的最后位置；

 冒泡排序，只会比较交换两个相邻的元素

 时间复杂度：严格O(N^2) ，和数据无关；

public static void bubbleSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        // details O(N^2) Deprecated
        // end is arr.length - 1 because exist of swap i++, prevent out of index error situation happen
        // outer foreach find one max num, and put it at end of arr array
        // inner foreach compare two nums and swap, util to the end of end border
        for (int end = arr.length - 1; end > 0; end--) {
            for (int i = 0; i < end; i++) {
                swap(arr, i, i + 1);
            }
        }
    }
private static void swap(int[] arr, int i, int j) {
    int tmp = arr[i];
    arr[i] = arr[j];
    arr[j] = tmp;
}

2. 选择排序

 最基础排序，一句话总结选择排序，对于给定的数组，如果是升序排序，每次选择最小的元素放置在当前次序的第一个位置；

  时间复杂度：严格O(N^2) ，和数据无关；

public static void selectionSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        // details O(N^2) Deprecated
        // first loop: search 0~ N-1, find min num and put it at 0 index
        // second loop: search 1~ N-1,find min num and put it at 1 index
        // until foreach all array
        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < arr.length; j++) {
                minIndex = arr[j] < arr[minIndex] ? j : minIndex;
            }
            swap(arr, i, minIndex);
        }
    }
private static void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

3. 插入排序

基础排序，类似扑克牌，整体思路如下(升序排)

 1. 从第二个元素开始遍历，即index = 1，1个元素默认有序；

 2. 对于当前元素，如果前一个元素比当前元素小，那么交换，直到前面没有元素；

 3. 每次循环保证当前位置 i 之前的素有元素都是有序的；

时间复杂度：O(N^2)

 1. 最好情况：如果原始数据是升序，那么插入排序的时间复杂度是O(N)，因为每次都不用发生交换动作；

 2. 最坏情况：如果原始数据是逆序，那么插入排序的时间复杂度是O(N^2) ，每次都要进行交换到第一个元素；

public static void insertSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        // details
        for (int i = 1; i < arr.length; i++) {
            int j = i - 1;
            while (j > 0 && arr[j] > arr[j + 1]) {
                swap(arr, j, j + 1);
                j--;
            }
        }
    }

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

4. 排序