内部排序

直接插入排序

就看做数组只有第一个元素，将之后的元素依次插入，是从末尾往前覆盖移动并找到合适的位置插入。
- 最小时间复杂度O(n)
- 平均时间复杂度O(n^2)
- 最大时间复杂度O(n^2)
- 空间复杂度O(1)
- 稳定

package yanyingnan.baodian.sort;

import java.util.Arrays;
public class InsertSort1 {
    public static void insertSort(int[] a){
        //int tmp;
        for(int i=1; i<a.length; i++){
            int tmp = a[i];
            int j;
            if(a[i]<a[i-1]){//这个if语句不写也可以  写上更高效，因为 前面的序列已经从小到大  现在的值比最大的值还要大的话就不用下面的for循环了
                for(j=i-1; j>=0 && a[j]>tmp; j--){//这里a[j]>tmp 而不是>= 因此算法稳定
                    a[j+1] = a[j];
                }
                a[j+1] = tmp;
            }
        }
    }

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

希尔排序

是直接插入排序的改进，常用h=3*h+1（h=1开始）作为步长计算公式，并依次减少步长，扩大了移动范围，减少了移动步数，当h=1时已经相对有序了，这时就是直接插入排序了。
- 最小时间复杂度O(n)
- 平均时间复杂度O(nlogn)
- 最大时间复杂度O(n^s)1-2
- 空间复杂度O(1)
- 不稳定

package yanyingnan.baodian.sort;

import java.util.Arrays;

public class InsertSort2 {
    public static void shellSort(int[] a){
        int h = 1;
        while(h<=a.length/3)
            h = h*3+1;
        while(h>0){//while循环中与直接插入排序几乎一样
            for(int i=h; i<a.length; i++){//这里令i=h思考其原理
                int tmp = a[i];
                int j;
                if(a[i]<a[i-h]){
                    for(j=i-h; j>=0 && a[j]>tmp; j-=h){//从j-h开始以h步长往后覆盖;因为有步长的因素 所以不稳定
                        a[j+h] = a[j];
                    }
                    a[j+h] = tmp;
                }
            }
            h=(h-1)/3;
        }
    }
    public static void main(String[] args){
        int[] a = {5,4,9,8,7,6,0,1,2,3};
        shellSort(a);
        System.out.println(Arrays.toString(a));
    }
}

冒泡排序

注意flag的使用即可
- 最小时间复杂度O(n)
- 平均时间复杂度O(n^2)
- 最大时间复杂度O(n^2)
- 空间复杂度O(1)
- 稳定

package yanyingnan.baodian.sort;

import java.util.Arrays;

public class SwitchSort1 {
    public static void bubbleSort(int[] a){//大的数字沉底即可
        for(int i=0; i<a.length-1; i++){

            boolean flag = true;
            for(int j=0; j<a.length-1-i; j++){
                if(a[j]>a[j+1]){
                    int tmp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = tmp;
                    flag = false;
                }
            }
            if(flag)            //有flag提高效率   flag=true说明后面已经有序
                break;
        }
    }

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

快排

第一个元素作为基数，前后指针以基数为准分两边，递归进行下去即可
- 最小时间复杂度O(nlogn)
- 平均时间复杂度O(nlogn)
- 最大时间复杂度O(n^2)
- 空间复杂度O(logn)
- 不稳定

package yanyingnan.baodian.sort;

import java.util.Arrays;
public class SwitchSort2 {
    public static void quickSort(int[] a){
        subSort(a,0,a.length-1);
    }

    private static void subSort(int[] a, int start, int end) {//使用了递归栈空间所以空间效率稍微差一点
        if(start<end){//递归跳出条件  
            //int i = start+1, j=end;
            int i = start, j = end+1;
            while(true){//这个while循环 对应快排的一趟
//              while(i<end && a[i++]>a[start]);//问题出现在这里  应该先++ 因为后面的swap要用到i j 后++就跑偏了
//              while(j>start && a[j--]<a[start]);
                while(i<end && a[++i]<a[start]);//a[start]为基数
                while(j>start && a[--j]>a[start]);//a[start]为基数
                if(i<j) 
                    swap(a,i,j);
                else
                    break;
            }
            swap(a,start,j);
            subSort(a, start, j-1);
            subSort(a, j+1, end);
        }
    }

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

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

直接选择排序

每次选择一个最值放在前面
- 最小时间复杂度O(n^2)
- 平均时间复杂度O(n^2)
- 最大时间复杂度O(n^2)
- 空间复杂度O(1)
- 不稳定

package yanyingnan.baodian.sort;

import java.util.Arrays;

public class SelectSort1 {
    public static void selectSort(int[] a){
        int tmp,flag;
        for(int i=0; i<a.length; i++){
            flag = i;
            for(int j=i+1; j<a.length; j++){//在跳跃式移动时会导致不稳定
                if(a[flag] > a[j]){
                    flag = j;
                }
            }
            if(flag != i){
                tmp = a[i];
                a[i] = a[flag];
                a[flag] = tmp;
            }
        }
    }

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

堆排序

从小到大排序：先循环建立大顶堆，再交换头尾保证大数在末尾，树结构是存放在数组中的。
- 最小时间复杂度O(nlogn)
- 平均时间复杂度O(nlogn)
- 最大时间复杂度O(nlogn)
- 空间复杂度O(1)
- 不稳定

package yanyingnan.baodian.sort;

import java.util.Arrays;

public class SelectSort2 {
    public static void heapSort(int[] a){
        for(int i=0; i<a.length-1; i++){//循环建立大顶堆，并在每次循环后都完成交换；
            buildMaxHeap(a,a.length-1-i);
            swap(a, 0, a.length-1-i);
        }
    }

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

    private static void buildMaxHeap(int[] a, int lastIndex) {//建立大顶堆，排序后就是由小到大
        for(int i=(lastIndex-1)/2; i>=0; i--){
            int k = i;//k用来完成while循环
            while(2*k+1<=lastIndex){//如果当前节点存在子节点

                int biggerIndex = 2*k+1;//先令左子节点为较大的结点
                if(biggerIndex<lastIndex){//如果存在右子节点
                    if(a[biggerIndex] < a[biggerIndex+1])//若右子节点大,始终保存大的结点
                        biggerIndex++;
                }

                if(a[k]<a[biggerIndex]){
                    swap(a, k, biggerIndex);
                    k = biggerIndex;
                }else{
                    break;//while循环的目的是保证交换之后的子节点依然大于它的子节点 而如果没有交换就没必要执行下一次while了 因此直接break
                }
            }
        }
    }

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

归并排序

归并思想是三个while循环，排序思想是递归
- 最小时间复杂度O(nlogn)
- 平均时间复杂度O(nlogn)
- 最大时间复杂度O(nlogn)
- 空间复杂度O(n)
- 稳定

package yanyingnan.baodian.sort;

import java.util.Arrays;

public class MergeSort {
    public static void mergeSort(int[] a){
        sort(a,0,a.length-1);
    }

    private static void sort(int[] a, int left, int right) {
        if(left<right){//不写if语句的判断将一直递归下去结果是：Exception in thread "main" java.lang.StackOverflowError
            int center = (left+right)/2;
            sort(a,left,center);
            sort(a,center+1,right);
            merge(a,left,center,right);
        }
    }

    private static void merge(int[] a, int left, int center, int right) {
        int mid = center+1;
        //int index=0;//int不是默认为0吗？为什么会提示要初始化？准确地说，类字段变量是这样，而在方法中的变量需明确初始化，否则会报错。
        int index = left;//index为tmpA数组的临时下标
        int tmp = left;//用于拷贝回原数组的时候用的临时下标
        int[] tmpA = new int[a.length];
        while(left<=center && mid<=right){
            if(a[left]<a[mid])//< 不是 <= 所以稳定
                tmpA[index++] = a[left++];
            else
                tmpA[index++] = a[mid++];
        }
        while(left<=center)
            tmpA[index++] = a[left++];
        while(mid<=right)
            tmpA[index++] = a[mid++];
        while(tmp<=right)
            a[tmp] = tmpA[tmp++];
    }

    public static void main(String[] args){
        int[] a = {5,4,9,0,58,4};
        mergeSort(a);
        System.out.println(Arrays.toString(a));
    }
}