算法排序算法

Posted 2022-12-09 danfengw

https://github.com/francistao/LearningNotes/blob/master/Part3/Algorithm/Sort/面试中的 10 大排序算法总结.md

排序算法	平均时间复杂度	最坏时间复杂度	空间复杂度	是否稳定
冒泡排序	O（n2）	O（n2）	O（1）	是
选择排序	O（n2）	O（n2）	O（1）	不是
直接插入排序	O（n2）	O（n2）	O（1）	是
归并排序	O(nlogn)	O(nlogn)	O（n）	是
快速排序	O(nlogn)	O（n2）	O（logn）	不是
堆排序	O(nlogn)	O(nlogn)	O（1）	不是
希尔排序	O(nlogn)	O（ns）	O（1）	不是
计数排序	O(n+k)	O(n+k)	O(n+k)	是
基数排序	O(N∗M)	O(N∗M)	O(M)

记录一下 时间最快 与 空间复杂度小的算法

快排

从平均时间来看，快速排序是效率最高的，但快速排序在最坏情况下的时间性能不如堆排序和归并排序。

每次找个基数，然后对比基数，l 和 h 指针， 从两头开始找比自己小向右移，比自己大的向左移。

  public static int[] quickSort(int[] data) 
        return quickSort(data, 0, data.length - 1);
    

    public static int[] quickSort(int[] data, int low, int height) 
        int l = low;
        int h = height;
        int povit = data[l];
        while (l < h) 
            while (l < h && data[h] >= povit) h--;

            if (l < h) 
                data[l] = data[h];
                l++;
            


            while (l < h && data[l] <= povit) l++;

            if (l < h) 
                data[h] = data[l];
                h--;
            

            data[l] = povit;
        
        if (l - 1 > low) quickSort(data, low, l - 1);
        if (h + 1 < height) quickSort(data, h + 1, height);
        return data;
    

冒泡排序

内存优先

  public static int[] bubbleSort(int[] array) 
        if (array == null || array.length <= 1) return array;
        for (int i = 0; i < array.length; i++) 
            for (int j = i + 1; j < array.length; j++) 
                if (array[j] <= array[i]) 
                    int temp = array[i];
                    array[i] = array[j];
                    array[j] = temp;
                
            
        
        return array;
    

插入排序

内存优先

首先位置1上的数和位置0上的数进行比较，如果位置1上的数大于位置0上的数，将位置0上的数向后移一位，将1插入到0位置，否则不处理。位置k上的数和之前的数依次进行比较，如果位置K上的数更大，将之前的数向后移位，最后将位置k上的数插入不满足条件点，反之不处理。

    public static int[] insertSort(int[] array) 
        if (array == null || array.length <= 1)
            return array;
        int j;
        for (int i = 1; i < array.length; i++) 
            // 如果 后一个 小于 前一个，就向前继续查找
            if (array[i] < array[i - 1]) 
                int temp = array[i];
                // 如果 当前大于temp 就向后移动一位
                for (j = i; (j > 0) && (array[j-1] > temp); j--) 
                    array[j] = array[j - 1];
                
                array[j] = temp;
            

        
        return array;