算法（java中的排序）

1，插入排序

        选择一个temp，然后与前面已经排序好的数字进行比较（默认第一个数字是排序好的），然后如果小于，就继续往前比较，直到比比较的数字大，就插入。

    public static int[] InserSort(int[] array){
        for (int i = 0; i < array.length; i++) {
            int temp=array[i];
            int k;
            for ( k = i-1; k >= 0; k--) {
                if(array[k]>temp){
                    array[k+1]=array[k];
                }else{
                    break;
                }
            }
            array[k+1]=temp;
        }
        return array;
    }

        平均时间复杂度为O(n^2)，最好的情况是O（n），最坏的情况为O(n^2)，空间复杂度为O(1)，稳定性：稳定。

2,选择排序

         选择排序就是不断找出最小值把他放前面，实现很简单。

    public static int[] SelectSort(int[] array){
        for (int i = 0; i < array.length; i++) {
            for (int j = i+1; j < array.length; j++) {
                if(array[i]>array[j]){
                    int temp=array[i];
                    array[i]=array[j];
                    array[j]=temp;
                }
            }
        }
        return array;
    }

        时间复杂度：O(n^2)，空间复杂度O(1)，但是我们可以每次查找最大值和最小值，这样就可以加快一半的时间。

3,冒泡排序

         将数字两两比较，然后将大的交换到前面，然后一遍一遍的循环，最终就可以完成排序。

    public static int[] BubbleSort(int[] array){
        for (int i = 0; i < array.length-1; i++) {
            for (int j = 0; j < array.length-1; j++) {
                if(array[j]>array[j+1]){
                    int temp=array[j+1];
                    array[j+1]=array[j];
                    array[j]=temp;
                }
            }
        }
        return array;
    }

        时间复杂度：最好情况：O(n)，最坏情况O(n^2)，空间复杂度O(1)。

4，快速排序

        对于快速排序，就是使用双指针，选择一个基准值，将每个数字与基准比较，比基准大的放在基准右边，比基准小的放在基准的左边，将数组拆分为两部分，然后不断地拆分，最终完成排序。基本思想就是分治的思想，将大问题拆分为小问题，小问题再拆分。

    public static void Quicksort(int[] array, int start, int end){
        if(start>=end){
            return;
        }
        int left = start;
        int right = end;
        int base = array[start];
        while(left != right){
            while(array[right] >= base && left<right){
                right--;
            }
            while(array[left] <= base && left<right){
                left++;
            }
            int temp=array[left];
            array[left]=array[right];
            array[right]=temp;
        }
        array[start]=array[left];
        array[left]=base;
        //左，右
        Quicksort(array,start,left-1);
        Quicksort(array,left+1,end);
    }

        时间复杂度：最好O(nlog(n))，最坏情况：O(n^2)，空间复杂度：O(nlog(n))，稳定性：不稳定。快速排序再最坏的情况下可以优化，即优化基准值，方法：三数取中法。

5，归并排序

算法（手写归并排序）_不会Java的MING的博客-CSDN博客

6，堆排序

         堆排序是利用堆这种数据结构设计的算法，堆是具有以下性质的完全二叉树：每个结点的值都大于或者等于左右孩子节点值，为大顶堆，反之是小顶堆。

        将待排序的序列构造出大顶堆，此时，这个序列的最大值就是root，然后将最大值放到末尾，此时末尾就是最大值，然后将剩余的元素重新构造为一个堆，然后反复执行，最终得到有序序列。

    //堆排序
    public static void HeapSor(int[] array){
        //首先构造大顶堆
        for (int i = array.length/2-1; i >=0 ; i--) {
            adjustHeap(array,i,array.length);
        }
        //调整堆结构
        for (int i = array.length-1; i > 0; i--) {
            swap(array,0,i);
            adjustHeap(array,0,i);
        }
    }
    //调整大顶堆
    private static void adjustHeap(int[] array, int i, int length) {
        while(2*i+1<length){
            int j=i*2+1;
            if(j+1<length && array[j]<array[j+1]){
                j++;
            }
            if(array[j]<array[i])
                break;

            swap(array,i,j);
            i=j;
        }
    }
    //交换
    private static void swap(int[] array, int a, int b) {
        int temp=array[a];
        array[a]=array[b];
        array[b]=temp;
    }

堆排序的时间复杂度为O（nlogn）空间复杂度为O（1） 稳定性：不稳定

 7，希尔排序

        该排序是为了优化插入排序，将一组数据分为n组，之后在进行组内交换。

    //希尔排序
    public static void ShellSort(int[] array){
        int gap=1;
        while(gap<array.length/3)
            gap=3*gap+1;
        while(gap>=1){
            for (int i = gap; i <array.length ; i++) {
                for (int j = i; j >= gap  && array[j]<array[j-gap];j-=gap) {
                    swap(array, j, j - gap);
                }
            }
            gap=gap/3;
        }
    }

    private static void swap(int[] array, int a, int b) {
        array[a] = array[a]+array[b];
        array[b] = array[a]-array[b];
        array[a] = array[a]-array[b];
    }

        希尔排序的平均时间复杂度为O（n^1.3~1.5），最好情况是O（n），最坏情况是O(n^2) 。空间复杂度是O（1），稳定性： 不稳定。