十大排序算法-Java版

最新推荐文章于 2024-07-16 18:11:29 发布
最新推荐文章于 2024-07-16 18:11:29 发布
阅读量75 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 排序算法 数据结构 算法 快速排序 堆排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44743245/article/details/114996506
版权

十大排序算法

image-20210318163840219

常见的递推式与复杂度

image-20210318163925259

Sort抽象类

定义排序的抽象父类，具体的排序算法延迟到sort()方法中实现

/**
 * @Description:定义排序的一些统计属性(如比较次数、交换次数、时间)
 * @author: cyb
 * @date:  2021-03-15 14:41
 * @version V1.0
 */
public abstract class Sort<T extends Comparable<T>> implements Comparable<Sort<T>> {
    protected T[] array;
    private int cmpCount;
    private int swapCount;
    private long time;
    private DecimalFormat fmt = new DecimalFormat("#.00");


    public void sort(T[] array) {
        if (array == null || array.length < 2) {
            return;
        }

        this.array = array;

        long begin = System.currentTimeMillis();
        sort();
        time = System.currentTimeMillis() - begin;
    }

    @Override
    public int compareTo(Sort<T> o) {
        int result = (int)(time - o.time);
        if (result != 0) {
            return result;
        }

        result = cmpCount - o.cmpCount;
        if (result != 0) {
            return result;
        }

        return swapCount - o.swapCount;
    }

    /**
     * 排序算法具体实现
     */
    protected abstract void sort();

    /**
     * 返回值等于0，代表 array[i1] == array[i2]
     * 返回值小于0，代表 array[i1] < array[i2]
     * 返回值大于0，代表 array[i1] > array[i2]
     */
    protected int cmp(int i1, int i2) {
        cmpCount++;
        return array[i1].compareTo(array[i2]);
    }

    protected int cmp(T v1, T v2) {
        cmpCount++;
        return v1.compareTo(v2);
    }

    protected void swap(int i1, int i2) {
        swapCount++;
        T tmp = array[i1];
        array[i1] = array[i2];
        array[i2] = tmp;
    }

    @Override
    public String toString() {
        String timeStr = "耗时：" + (time / 1000.0) + "s(" + time + "ms)";
        String compareCountStr = "比较：" + numberString(cmpCount);
        String swapCountStr = "交换：" + numberString(swapCount);
        String stableStr = "稳定性：" + isStable();
        return "【" + getClass().getSimpleName() + "】\n"
                + stableStr + " \t"
                + timeStr + " \t"
                + compareCountStr + "\t "
                + swapCountStr + "\n"
                + "------------------------------------------------------------------";

    }

    private String numberString(int number) {
        if (number < 10000) {
            return "" + number;
        }

        if (number < 100000000) {
            return fmt.format(number / 10000.0) + "万";
        }
        return fmt.format(number / 100000000.0) + "亿";
    }

    private boolean isStable() {
        if (this instanceof RadixSort) {
            return true;
        }
        if (this instanceof CountingSort) {
            return true;
        }
        if (this instanceof ShellSort) {
            return false;
        }
        if (this instanceof SelectionSort) {
            return false;
        }
        Student[] students = new Student[20];
        for (int i = 0; i < students.length; i++) {
            students[i] = new Student(i * 10, 10);
        }
        sort((T[]) students);
        for (int i = 1; i < students.length; i++) {
            int score = students[i].score;
            int prevScore = students[i - 1].score;
            if (score != prevScore + 10) {
                return false;
            }
        }
        return true;
    }
}

基于比较的排序

冒泡排序（Bubble Sort）

从头开始比较每一对相邻元素，如果第1个比第2个大，就交换它们的位置 。执行完一轮后，最末尾那个元素就是最大的元素

public class BubbleSort1 extends Sort{
    @Override
    protected void sort() {
        for (int end = array.length - 1; end > 0; end--) {
            //每一轮比较的范围是[0,end)
            for (int begin = 0; begin < end; begin++) {
                if (cmp(begin+1,begin)<0) {
                    swap(begin+1,begin);
                }
            }
        }
    }
}

优化1

如果序列已经完全有序，可以提前终止冒泡排序

public class BubbleSort2 extends Sort{
    @Override
    protected void sort() {
        for (int end = array.length - 1; end > 0; end--) {
            boolean sorted = true;
            for (int begin = 0; begin < end; begin++) {
                if (cmp(begin+1,begin)<0) {
                    swap(begin+1,begin);
                    sorted = false;
                }
            }
             //如果经过一轮排序，sort依然为true，说明没有发生一次交换，序列已经有序了
            if (sorted) {
                break;
            }
        }
    }
}

优化2

如果序列尾部已经局部有序，可以记录最后1次交换的位置，减少比较次数

public class BubbleSort3 extends Sort{
    @Override
    protected void sort() {
        for (int end = array.length - 1; end > 0; end--) {
            int sortedIndex = 0;
            for (int begin = 0; begin < end; begin++) {
                if (cmp(begin+1,begin)<0) {
                    swap(begin+1,begin);
                    sortedIndex = begin + 1;
                }
            }
            end = sortedIndex;
        }
    }
}
  • 最坏、平均时间复杂度：O(n 2 )
  • 最好时间复杂度：O(n)
  • 空间复杂度：O(1)

选择排序（Selection Sort）

从序列中找出最大的那个元素，然后与最末尾的元素交换位置 。执行完一轮后，最末尾的那个元素就是最大的元素

public class SelectionSort<T extends Comparable<T>> extends Sort<T> {
    @Override
    protected void sort() {
        for (int end = array.length - 1; end > 0; end--) {
            int maxIndex = 0;
            for (int begin = 1; begin <= end; begin++) {
                if (cmp(begin, maxIndex) > 0) {
                    maxIndex = begin;
                }
            }
            swap(maxIndex, end);
        }
    }
}

堆排序（Heap Sort）

可以认为是对选择排序的优化

执行流程

  1. 对序列进行原地建堆（heapify）–大顶堆
  2. 重复执行以下操作，直到堆的元素数量为 1
    1. 交换堆顶元素与尾元素
    2. 堆的元素数量减 1
    3. 对 0 位置进行 1 次 siftDown() ,即下滤操作
public class HeapSort<E extends Comparable<E>> extends Sort<E>{
    private int heapSize;
    @Override
    protected void sort() {
        //原地建堆，有两种形式，自上而下的上滤,或者自下而上的下滤
        //这里是自下而上的下滤
        heapSize=array.length;
        //(heapSize >> 1) - 1只有非叶子节点
        for (int i = (heapSize >> 1) - 1; i >= 0; i--) {
            siftDown(i);
        }
        while (heapSize>1){
            //交换堆顶元素和尾部
            swap(0,--heapSize);
            //对0位置下滤
            siftDown(0);
        }
    }
    /**
     * 下滤
     * @param index
     */
    private void siftDown(int index) {
        E element = array[index];
        //第一个叶子节点的索引=非叶子节点的数量
        int half = heapSize >> 1;
        while (index < half) { //必须保证index非叶子节点
            //index的子节点有两种情况
            //1、只有左节点
            //2、同时有左右节点
            //默认为左节点
            //找出左右节点中大的那个
            int childIndex = (index << 1) + 1;
            E child = array[childIndex];
            //右子节点
            int rightIndex = childIndex + 1;
            if (rightIndex < heapSize && cmp(array[rightIndex], child) > 0) {
                childIndex = rightIndex;
                child = array[rightIndex];
            }
            if (cmp(element, child) >= 0) {
                break;
            }
            //将子节点存放到index
            array[index] = child;
            index = childIndex;
        }
        array[index] = element;
    }
}

插入排序（Insertion Sort）

在执行过程中，插入排序会将序列分为2部分，头部是已经排好序的，尾部是待排序的 。从头开始扫描每一个元素 ，每当扫描到一个元素，就将它插入到头部合适的位置，使得头部数据依然保持有序

public class InsertionSort1<T extends Comparable<T>> extends Sort<T> {

    /**
     * 逆序对越多，时间复杂度越高
     */
    @Override
    protected void sort() {
        for (int begin = 1; begin < array.length; begin++) {
            int cur = begin;
            while (cur > 0 && cmp(cur, cur - 1) < 0) {
                swap(cur, cur - 1);
                cur--;
            }
        }
    }
}

优化

思路是将【交换】转为【挪动】

public class InsertionSort2<T extends Comparable<T>> extends Sort<T> {
    @Override
    protected void sort() {
        for (int begin = 1; begin < array.length; begin++) {
            int cur = begin;
            T v=array[cur];
            while (cur > 0 && cmp(v, array[cur - 1]) < 0) {
//                swap(cur, cur - 1);
                array[cur]=array[cur-1];
                cur--;
            }
            array[cur]=v;
        }
    }
}

二分搜索优化

在元素 v 的插入过程中，可以先二分搜索出合适的插入位置，然后再将元素 v 插入

public class InsertionSort3<T extends Comparable<T>> extends Sort<T> {
    @Override
    protected void sort() {
        for (int begin = 1; begin < array.length; begin++) {
            insert(begin,search(begin));
        }
    }

    /**
     * 将source位置的元素插入到dest位置
     * @param source
     * @param dest
     */
    private void insert(int source, int dest) {
        T v=array[source];
        for (int i = source; i >dest ; i--) {
            array[i]=array[i-1];
        }
        array[dest]=v;
    }

    /**
     * @param index
     * @Description: 利用二分搜索找到index位置元素的待插入位置
     * @Return int
     * @Exception 
     * @author: cyb
     * @date:  2021-03-17 14:24
     */
    private int search(int index){
        T v = array[index];
        int begin=0;
        int end=index;
        while (begin<end){
            int mid=(begin+end)>>1;
            if (cmp(v,array[mid])<0){
                end=mid;
            }else {
                begin=mid+1;
            }
        }
        return begin;
    }
}

归并排序（Merge Sort）

  1. 不断地将当前序列平均分割成2个子序列 , 直到不能再分割（序列中只剩1个元素）
  2. 不断地将2个子序列合并成一个有序序列 ,直到最终只剩下1个有序序列
public class MergeSort<T extends Comparable<T>> extends Sort<T> {
    private T[] leftArray;

    // T(n) = T(n/2) + T(n/2) + O(n)
    
    @Override
    protected void sort() {
        leftArray = (T[]) new Comparable[array.length >> 1];
        sort(0, array.length);
    }

    /**
     * @param begin
     * @param end
     * @Description: 对[begin, end)范围内的数据归并排序
     */
    private void sort(int begin, int end) {
        if (end - begin < 2) {
            return;
        }
        int mid = (begin + end) >> 1;
        sort(begin, mid);
        sort(mid, end);
        merge(begin, mid, end);
    }

    /**
     * @param begin
     * @param mid
     * @param end
     * @Description: 将[begin, mid),[mid,end)合并
     */
    private void merge(int begin, int mid, int end) {
        //左边数组的起始
        int li = 0;
        int le = mid - begin;
        //右边数组的起始
        int ri = mid;
        int re = end;
        //备份的左边数组的index
        int ai = begin;
        //备份左边数组
        for (int i = li; i < le; i++) {
            leftArray[i] = array[begin + i];
        }
        //如果左边还没结束
        while (li < le) {
            if (ri < re && cmp(array[ri], leftArray[li]) < 0) {
                array[ai++] = array[ri++];
            } else {
                array[ai++] = leftArray[li++];
            }
        }
    }
}

快速排序（Quick Sort）

  • 从序列中选择一个轴点元素（pivot）
    • 假设每次选择 0 位置的元素为轴点元素
  • 利用 pivot 将序列分割成 2 个子序列
    • 将小于 pivot 的元素放在pivot前面（左侧）
    • 将大于 pivot 的元素放在pivot后面（右侧）
    • 等于pivot的元素放哪边都可以
  • ③ 对子序列进行 ① ② 操作
    • 直到不能再分割（子序列中只剩下1个元素）
public class QuickSort<T extends Comparable<T>> extends Sort<T> {

    @Override
    protected void sort() {
        sort(0, array.length);
    }

    /**
     * @param begin
     * @param end
     * @Description: 对[begin, end)范围内的元素快速排序
     */
    private void sort(int begin, int end) {
        if (end - begin < 2) {
            return;
        }
        //确定轴点位置
        int mid = pivotIndex(begin, end);
        //对子序列快速排序
        sort(begin, mid);
        sort(mid + 1, end);
    }

    /**
     * 构造轴点,以第一个元素作为轴点
     * @param begin
     * @param end
     * @return
     */
    private int pivotIndex(int begin, int end) {
        //随机选择一个元素跟begin交换
        swap(begin, begin+(int) (Math.random()*(end-begin)));

        //备份begin位置的元素
        T pivot = array[begin];
        end--;
//        boolean turn=true;
        //类似左右切换的可以用三个while循环加break解决
        while (begin < end) {
            while (begin < end) {
                if (cmp(pivot, array[end]) < 0) { // 右边元素 > 轴点元素
                    end--;
                } else { // 右边元素 <= 轴点元素
                    array[begin++] = array[end];
                    break;
                }
            }
            while (begin < end) {
                if (cmp(pivot, array[begin]) > 0) { // 左边元素 < 轴点元素
                    begin++;
                } else { // 左边元素 >= 轴点元素
                    array[end--] = array[begin];
                    break;
                }
            }
        }
        //将轴点元素放到最终的位置
        array[begin] = pivot;
        return begin;
    }
}

希尔排序（Shell Sort）

希尔排序把序列看作是一个矩阵，分成 𝑚 列，逐列进行排序 ,m从某个整数逐渐减为1,当 𝑚 为1时，整个序列将完全有序

因此，希尔排序也被称为递减增量排序（Diminishing Increment Sort）

矩阵的列数取决于步长序列（step sequence），比如，如果步长序列为{1,5,19,41,109,…}，就代表依次分成109列、41列、19列、5列、1列进行排序。不同的步长序列，执行效率也不同

希尔本人给出的步长序列是 𝑛/2 𝑘，比如 𝑛 为16时，步长序列是{1, 2, 4, 8}

目前已知的最好的步长序列，最坏情况时间复杂度是 O(n 4/3 ) ，1986年由Robert Sedgewick提出

image-20210318163536160

public class ShellSort<T extends Comparable<T>> extends Sort<T> {

    @Override
    protected void sort() {
        //步长序列
        List<Integer> stepSequence = sedgewickStepSequence();
        for (Integer step : stepSequence) {
            sort(step);
        }
    }

    /**
     * 分成step列进行排序
     *
     * @param step
     */
    private void sort(int step) {
        for (int col = 0; col < step; col++) {
            //第col列排序
            //需要排序的元素 col、col+step、col+2step
            for (int begin = col + step; begin < array.length; begin += step) {
                int cur = begin;
                while (cur > col && cmp(cur, cur - step) < 0) {
                    swap(cur, cur - step);
                    cur -= step;
                }
            }
        }
    }

    private List<Integer> shellStepSequence() {
        ArrayList<Integer> stepSequence = new ArrayList<>();
        int step = array.length;
        while ((step >>= 1) > 0) {
            stepSequence.add(step);
        }
        return stepSequence;
    }

    /**
     * 目前已知的最好的步长序列，最坏情况时间复杂度是 O(n的4/3次方),1986年由Robert Sedgewick提出
     * @return
     */
    private List<Integer> sedgewickStepSequence() {
        List<Integer> stepSequence = new LinkedList<>();
        int k = 0, step = 0;
        while (true) {
            if (k % 2 == 0) {
                int pow = (int) Math.pow(2, k >> 1);
                step = 1 + 9 * (pow * pow - pow);
            } else {
                int pow1 = (int) Math.pow(2, (k - 1) >> 1);
                int pow2 = (int) Math.pow(2, (k + 1) >> 1);
                step = 1 + 8 * pow1 * pow2 - 6 * pow2;
            }
            if (step >= array.length) break;
            stepSequence.add(0, step);
            k++;
        }
        return stepSequence;
    }
}

计数排序（Counting Sort）

统计每个整数在序列中出现的次数，进而推导出每个整数在有序序列中的索引

public class CountingSort extends Sort<Integer> {
    /**
     * 改进最简单的实现
     */
    @Override
    protected void sort() {
        int max = array[0];
        int min = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i] > max) {
                max = array[i];
            }
            if (array[i] < min) {
                min = array[i];
            }
        }
        //开辟内存空间，存储每个整数出现的次数
        int[] counts = new int[max - min + 1];
        for (int i = 0; i < array.length; i++) {
            counts[array[i] - min]++;
        }
        //累加次数
        for (int i = 1; i < counts.length; i++) {
            counts[i] += counts[i - 1];
        }
        //从后往前（保证稳定性）遍历元素，将它放到有序数组的合适位置
        int[] newArray = new int[array.length];
        for (int i = array.length - 1; i >= 0; i--) {
            newArray[--counts[array[i] - min]] = array[i];
        }
        for (int i = 0; i < newArray.length; i++) {
            array[i] = newArray[i];
        }
    }

    /**
     * 最简单的实现
     * 存在以下问题:
     * 1、无法对负整数进行排序
     * 2、极其浪费内存空间
     * 3、是个不稳定的排序
     */
    protected void sort0() {
        //找出最大值
        int max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i] > max) {
                max = array[i];
            }
        }
        //开辟内存空间，存储每个整数出现的次数
        int[] counts = new int[1 + max];
        for (int i = 0; i < array.length; i++) {
            counts[array[i]]++;
        }
        //根据整数出现次数进行排序
        int arrayIndex = 0;
        for (int i = 0; i < counts.length; i++) {
            while (counts[i] > 0) {
                array[arrayIndex++] = i;
                counts[i]--;
            }
        }
    }
}

基数排序（Radix Sort）

依次对个位数、十位数、百位数、千位数、万位数…进行排序（从低位到高位）

个位数、十位数、百位数的取值范围都是固定的0~9，可以使用计数排序对它们进行排序||或者用二维数组实现

public class RadixSort extends Sort<Integer>{
    @Override
    protected void sort() {
        int max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i] > max) {
                max = array[i];
            }
        }
        // 个位数: array[i] / 1 % 10 = 3
        // 十位数：array[i] / 10 % 10 = 9
        // 百位数：array[i] / 100 % 10 = 5
        // 千位数：array[i] / 1000 % 10 = ...
        for (int divider = 1; divider <= max; divider *= 10) {
            countingSort(divider);
        }
    }

    protected void countingSort(int divider) {
        //开辟内存空间，存储每个整数的基数出现的次数
        int[] counts = new int[10];
        for (int i = 0; i < array.length; i++) {
            counts[array[i]/divider%10]++;
        }
        //累加次数
        for (int i = 1; i < counts.length; i++) {
            counts[i] += counts[i - 1];
        }
        //从后往前（保证稳定性）遍历元素，将它放到有序数组的合适位置
        int[] newArray = new int[array.length];
        for (int i = array.length - 1; i >= 0; i--) {
            newArray[--counts[array[i]/divider%10]] = array[i];
        }
        for (int i = 0; i < newArray.length; i++) {
            array[i] = newArray[i];
        }
    }
}
cyb-xh
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
10亿条long型数据外部排序的文件分割实践及优化过程（JAVA）
小P的博客
10-11 963
 一、题目         生成10亿个long随机数正整数，把它写入一个文件里。然后实现一个函数 fetch(int k,int n)。（fetch函数的输出结果是这10亿个正整数中从小到大中第k个开始（不包含第k个）往后取n个数。）         给定内存为1G（可为2G）。 二、题目分析     （1）首先生成10亿个long随机正整数，可考虑使用ThreadLocalRando...
JAVA快速排序——亿级体量数据
TianciZhu的博客
08-26 3388
算法真的是太强大了，今天测试了给一亿个随机数据进行排序，花了67秒不到！不多说，直接见代码：   import java.util.Random; public class sort {         public static void main(String[] args) {                          int[] dat
C++实现十大排序算法
liuzuoping的博客
12-03 9824
今天我们来用C++实现一下经典的十大排序算法 具体代码与文件可访问我的GitHub地址获取 https://github.com/liuzuoping/Algorithms PS：欢迎star 1 冒泡排序 冒泡排序无疑是最为出名的排序算法之一，从序列的一端开始往另一端冒泡（你可以从左往右冒泡，也可以从右往左冒泡，看心情），依次比较相邻的两个数的大小（到底是比大还是比小也看你心情）。 （无序区...
十大排序算法Java实现
被风吹跑的发际线
12-19 187
之前写了JavaScript实现的排序算法，因为社会的压迫233333，Java可能也得写写，所以就将这个放在这里来了，算法介绍看之前JavaScript那一篇播客吧，这里就只有代码。 我知道，给类起中文名是一个很不好的习惯，但我现在只是为了让自己找的时候比较方便。 我没写完，还有基数排序，但是我饿了，，，，干饭人！！！要干饭了！ 一、冒泡排序（Bubble Sort） public class 冒泡排序 { public static void main(String[] args.
Java实现十大排序算法
木梓沐丶
11-26 1465
十大排序算法 十大排序算法分别为：冒泡排序、快速排序、插入排序、希尔排序、选择排序、堆排序、归并排序、桶排序、计数排序、基数排序 他们的时间复杂度分别为： 关于时间复杂度 平方阶 (O(n2)) 排序 各类简单排序：直接插入、直接选择和冒泡排序。 线性对数阶 (O(nlog2n)) 排序 快速排序、堆排序和归并排序； O(n1+§)) 排序，§ 是介于 0 和 1 之间的常数。 希尔排序 线性阶 (O(n)) 排序 基数排序，此外还有桶、箱排序。 关于稳定性 稳定的排序算法：冒泡排序、插入排序、归并排序
java十大排序算法实现
11-20
java十大排序算法实现 1. 冒泡排序（Bubble Sort） 2. 选择排序（Selection Sort） 3. 插入排序（Insertion Sort） 4. 快速排序（Quick Sort） 5. 归并排序（Merge Sort） 6. 堆排序（Heap Sort） 7. 计数排序...
十大经典排序算法.pdf
12-08
十大经典排序算法是数据结构与算法领域中的基础，它们包括冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序、计数排序、桶排序和基数排序。这些算法分别适用于不同的场景，具有各自的时间复杂度...
十大排序算法代码（Java）
10-08
十大排序算法十大排序算法源码，自己整理的，可以直接运行，Java版本
十大常用排序算法（java实现）
11-01
十大常用排序算法（java实现）,冒泡排序，简单选择排序等
十大经典排序算法(java源码)
04-19
"十大经典排序算法"通常包括以下内容：冒泡排序、选择排序、插入排序、希尔排序、快速排序、归并排序、堆排序、计数排序、桶排序和基数排序。这些算法各有特点，适用于不同的数据结构和场景。 1. 冒泡排序（Bubble ...
Java常用排序算法
weixin_43732943的博客
07-13 159
排序算法
Java-排序~查找算法
lizhiwei21的博客
07-16 89
冒泡排序 : 将一组数据按照从小到大的顺序进行排序冒泡排序原理 : 相邻元素两两作比较 , 大的元素往后放。
【排序算法】1.冒泡排序-C语言实现
m0_75090944的博客
07-15 812
【排序算法】1.冒泡排序-C语言实现
排序-java（详解）
2302_81705247的博客
07-13 934
直接插入排序，希尔排序，选择排序，堆排序，冒泡排序，快速排序及其优化，归并排序，基数排序，计数排序
十分钟“手撕”七大排序
2301_80958683的博客
07-16 480
可以通过目录来找你需要的排序的源代码。先是解释底层原理，后附带代码。
常见的排序算法，复杂度
最新发布
m0_61544805的博客
07-16 338
稳定 / 非稳定排序：两个相等的数 排序前后 相对位置不变。 插入排序（希尔排序）： 每一趟将一个待排序记录，按其关键字的大小插入到已排好序的一组记录的适当位置上，直到所有待排序记录全部插入为止。稳定，O(n)，O(1)。 把记录按下标增量（模）分组，对每组进行直接插入排序，每次排序后减小增量，当增量减至 1 时排序完毕。不稳定，不知道（有个实验结论），O(1)。 冒泡排序： 比较相邻的元素，如果第一个比第二个大就进行交换，对每一对相邻元素做同样的工作。稳定，O(n)，O(1)。 选择
常见排序算法总结
mydaily_的博客
07-16 519
大概是因为插入排序没预处理，极端情况可能让一个很小很右的数一直比比比比比，比到最开头，浪费比较次数。某种情况比计数排序好，因为数字，如果按照普通十进制理解，则只需准备10个不同数字的桶就好了！整体的quickSort函数swap后，再进行partition，划分三部分后，所以这种不基于比较的算法应用范围很局限，大部分情况下，不如之前的所有比较算法！前提得知道空间范围，比如人的年龄，正数[0-200]，否则内存爆炸！间隔分组，且分组间隔依次减半，每次分组后，每个组内排序都是插入排序。
【排序 】
2301_81510374的博客
07-14 859
1. 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序2. 时间复杂度：O(N*logN)
排序算法
南城以北的博客
07-16 570
内部排序：指将需要处理的所有数据都加载到内部存储器中进行排序外部排序：数据量过大，无法全部加载到内存中，需要借助外部存储进行排序一个算法花费的时间与算法中语句的执行次数成正比，对算法的时间频度Tn就得到了算法的时间复杂度Ofn))，比如Tn3n27n6=>On2O1Olog2​nOnOnlog2​nOn2On3OnkO2n一个小技巧是记住下面的典型代码结构，就可以快速判断一段代码的时间复杂度。1.常数阶O。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值