八大排序

插入排序

时间复杂度O（n^2）
基本思路：把数组分成俩个部分，一部分是已排序数组，另一部分是未排序的数组，每次从未排序的数组中取到一个，插入到已排序数组中合适的位置。
实现：

1. 找到这个新数（下标为i）将要插入到的位置j。
2. 把下标[j,i - 1]的元素整体往后移一位。

private static int[] insertSort(int[] arr){
        for (int i = 1; i < arr.length; i++) {
            int j;
            int temp = arr[i];
            for(j = 0; j < i && arr[j] < arr[i]; j++){  //计算出要插入的位置j
            }
            for(int k = i; k > j; k--){
                arr[k] = arr[k - 1];
            }
            arr[j] = temp;
        }
        return arr;
    }

希尔排序

时间复杂度：O(n * logn)
直接插入排序的升级版本，直接
基本思路：设有一个逐渐减少的步长step，根据这个步长，把原来的数组分成几个子数组分别进行直接插入排序。

1. 步长从arr.length/2开始递减到1。对于一个步长step，切分的有step + 1个子数组。
2. 分别对这些子数组进行直接插入排序。

private static void shellSort(int[] arr){
        int step = arr.length;
        while(step > 0){
            step = step / 2;
            for(int start = 0; start < step; start++) {
                shellMethod(arr, start, step);
            }
        }
    }

    private static void shellMethod(int[] arr, int start, int step){
        for (int i = start; i < arr.length; i += step) {
            int j;
            int temp = arr[i];
            for(j = start; j < i && arr[j] < arr[i]; j += step){
            }
            for(int k = i; k > j; k -= step){
                arr[k] = arr[k - step];
            }
            arr[j] = temp;
        }
    }

选择排序

挺直观的，每次选择出一个最小的元素放在已经排好序的数组的后一个位置上。
时间复杂度O(n^2)
实现：

private static void selectSort(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            int min = i;
            for(int j = i + 1; j < arr.length; j++){
                if(arr[j] < arr[min]){
                    min = j;
                }
            }
            if(min != i){
                int temp = arr[min];
                arr[min] = arr[i];
                arr[i] = temp;
            }
        }
    }

冒泡排序

升序：比较相邻元素，把大的数放在靠后的位置，从前往后比，第一次就会把最大的数冒到数组末尾。第二次就会把第二大的数冒到末尾，以此类推。

private static void bubbleSort(int[] arr){
        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];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

堆排序

时间复杂度：o(nlogn)
自己写的时候debug了好长时间。因为每次对堆的跟结点进行调整后，还要往下进行调整，往下调整可能会触碰到已经排好序的数（交换下来的数），所以下面代码中的len，即每次要操作的数长度要格外注意！
基本思路：把原先数组先调整为一个大根堆（先创建方式有点类似于树的层次遍历，一层一层创建下去，然后从下往上进行调整）。把大根堆的跟结点和大根堆的下标最大的一个交换，意思就是把最大的给保留下来，然后从根节点开始，往下进行调整，把第二大的数调整到跟结点，再让第二大的数和数组下标的次最大值交换，以此类推。
实现：

1. 先构造一个大跟堆。
2. 交换大跟堆的根元素和arr[arr.length - index]（index表示第index次交换）。
3. 调整剩余的arr.length - index个数组成的大根堆（是从根节点开始往下调整）

private static void heapSort(int[] arr){
        int count = arr.length / 2 - 1; //下标值最大的非叶子节点
        for(int i = count; i >= 0; i--){
            adjustHeap(arr, i, arr.length);
        }
        int index = arr.length;
        while(index > 0){
            adjustHeap(arr,0, index);  //每次都是调整堆的根节点

            int temp = arr[index - 1];
            arr[index - 1] = arr[0];
            arr[0] = temp;
            index--;
        }
    }
    private static void adjustHeap(int[] arr, int root, int len){   //是一个局部调整
        while(root < len / 2){
            int maxIndex = root;
            int leftIndex = root * 2 + 1;
            int rightIndex = leftIndex + 1;
            maxIndex = arr[root] > arr[leftIndex] ? root : leftIndex;
            if(rightIndex < len){   //只存在右孩子越界
                maxIndex = arr[maxIndex] < arr[rightIndex] ? rightIndex : maxIndex;
            }
            if(maxIndex == root){   //不用调整
                return;
            }
            int temp = arr[maxIndex];
            arr[maxIndex] = arr[root];
            arr[root] = temp;

            root = maxIndex; //需要继续往下调整，把最大的数放在父结点上
        }
    }

快速排序

时间复杂度：O(n logn)
基本思路：采用分治的思想。找一个基准数（基本都是第一个数），从后往前和从前往后双向遍历，把比这个基准数大的放在基准数后面，比这个基准数小的放前面。一次做完后，这个基准数的位置是正确的，然后对俩边分别进行一样的递归操作。知道只有一个数。

1. 以head下标的数为基准数，用temp记录（此时可以认为arr[head]为空）
2. 从后往前，直到找到第一个比temp小的数，把他放在arr[head]中（此时可以认为arr[tail]为空），并且让head++
3. 从前往后，直到找到第一个比temp大的数，放在arr[tail]中，tail–;
4. 循环直到tail == head
5. 最后要注意的是要把temp，一开始保存的基准数放到arr[head]中，这样数组才是圆满的
6. 递归前半部分和后半部分

private static void quickSort(int[] arr, int startIndex, int endIndex){
        int head = startIndex;
        int tail = endIndex;
        if(head >= tail){
            return;
        }
        int temp = arr[head];   //基准数
        while(head < tail){
            while(tail > head && arr[tail] > temp){
                tail--;
            }
            if(tail > head){
                arr[head++] = arr[tail];
            }
            while(head < tail && arr[head] < temp){
                head++;
            }
            if(head < tail){
                arr[tail--] = arr[head];
            }
        }
        arr[head] = temp;
        quickSort(arr,startIndex, head - 1);
        quickSort(arr,head + 1, endIndex);
    }

完结 撒花！