七大排序 | 快排详解 | 比较型排序总结

已于 2023-02-28 19:05:34 修改
阅读量214 收藏
点赞数 1
文章标签： java Powered by 金山文档
于 2023-02-28 18:43:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59565952/article/details/129267361
版权

比较型排序

1.直接插入排序

当插入第i(i>=1)个元素时，前面的array[0],array[1],…,array[i-1]已经排好序，此时用array[i]的排序码与array[i-1],array[i-2],…的排序码顺序进行比较，找到插入位置即将array[i]插入，原来位置上的元素顺序后移

/**
 *时间复杂度最差情况O(N^2)
 *           最好情况O(N)
 *               当数据趋于有序的时候，排序速度会非常快
 *                   一般场景就是数据基本有序，建议直接使用直接插入排序
 * 空间复杂度：O(1)
 * 稳定性:稳定
 * 如果一个排序是稳定的 那么就可以实现为不稳定 这里直接 array[j] >= tmp 就会变得不稳定
 * @param array
 */
public static void insertSort(int[] array) {
    for (int i = 1; i < array.length; i++) {
        //从后往前排
        int tmp = array[i];
        int j = i - 1;
        for (; j >= 0; j--) {
            if (array[j] > tmp) {
                array[j + 1] = array[j];
            } else {
                //这时候就说明前面的数都会比tmp小(前面已经有序)
                //节省时间效率
                break;
            }
        }
        //break跳到的语句或者当前最小的数(全部排序了一遍)
        array[j + 1] = tmp;
    }
}

直接插入排序特性总结:

  1. 元素集合越接近有序，直接插入排序算法的时间效率越高

  1. 时间复杂度：O(N^2) ,最好情况 O(N)

  1. 空间复杂度：O(1)，它是一种稳定的排序算法

  1. 稳定性：稳定

2.希尔排序(缩小增量排序)

希尔排序法又称缩小增量法。希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分成多个组， 所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。

其实就是直接插入排序的一种优化,每一次都是进行了快排,只是增量为gap

//待排序数组越有序 插入排序越快
/**
 * 时间复杂度O(N^1.3) ~ O(N^1.5)
 * 空间复杂度O(1)
 * 稳定性: 不稳定
 * 相当于对直接插入排序进行优化
 * @param array
 */
public static void shellSort(int[] array) {
    int gap = array.length;
    //当gap > 1的时候不断进行分组排序
    //分组逐渐变少
    while (gap > 1) {
        gap /= 2;
        //gap组数据 每组数据n/gap
        //gap为其他组的时候是预排序
        //只有当gap == 1 的时候 才是直接排序
        shell(array, gap);
    }
    //整体进行插入排序
}
private static void shell(int[] array, int gap) {
    //这里是i ++ 因为是间隔性的插入排序 (第一组没排序完排第二组)...
    for (int i = gap; i < array.length; i++) {
        //从后往前排
        int tmp = array[i];
        int j = i - gap;
        for (; j >= 0; j -= gap) {
            if (array[j] > tmp) {
                //往后挪
                array[j + gap] = array[j];
            } else {
                break;
            }
        }
        array[j + gap] = tmp;
    }
}

希尔排序的特性总结：

  1. 希尔排序是对直接插入排序的优化。

  1. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。

  1. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些树中给出的希尔排 序的时间复杂度都不固定：

3.选择排序

在元素集合array[i]--array[n-1]中选择关键码最大(小)的数据元素

若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中的最后一个（第一个）元素交换

在剩余的array[i]--array[n-2]（array[i+1]--array[n-1]）集合中，重复上述步骤，直到集合剩余1个元素

/**
 * 时间复杂度O(N^2)
 * 空间复杂度O(1)
 * 稳定性:不稳定
 * @param array
 */
public static void selectSort(int[] array) {
    for (int i = 0; i < array.length; i++) {
        //定义最小下标是i i后面都是待排序数组
        int minIndex = i;
        for (int j = i + 1; j < array.length; j++) {
            if (array[minIndex] > array[j]) {
                minIndex = j;
            }
        }
        swap(array, minIndex, i);
    }
}
private static void swap(int[] array, int i, int j) {
    int tmp = array[i];
    array[i] = array[j];
    array[j] = tmp;
}

直接选择排序的特性总结:

  1. 直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用

  1. 时间复杂度：O(N^2)

  1. 空间复杂度：O(1)

  1. 稳定性：不稳定

4.堆排序

堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是通过堆 来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆

//建堆
public static void createHeap(int [] array){
    for (int parent  = (array.length -1-1) / 2 ; parent  >= 0 ; parent --) {
        shiftDown(array,parent,array.length);
    }
}
/**
 * 堆排序
 * 时间复杂度O(n * log N) | 空间复杂度 O(1)
 * 稳定度:稳定
 * @param array
 */
public static void heapSort(int [] array){
    //1.先要获得一个大根堆 每次根节点跟最后一个互换
    createHeap(array);
    int end = array.length -1;
    while (end > 0) {
        swap(array,0,end);
        shiftDown(array,0,end);
        end --;
    }
}
private static void shiftDown(int [] array, int parent, int len){
    int child = parent * 2 + 1;
    while (child < len){
        //这里确保存在右孩子 才可以进行比较
        if(child + 1 < len && 
                array[child] < array[child + 1] ){
            //右孩子大一些
            child ++;
        }
        if(array[child] > array[parent]){
            swap(array, child, parent);
            parent = child;
            child = parent * 2 + 1;
        }else {
            break;
        }
    }
}
private static void swap(int[] array, int i, int j) {
    int tmp = array[i];
    array[i] = array[j];
    array[j] = tmp;
}

堆排序的特性总结:

  1. 堆排序使用堆来选数，效率就高了很多。

  1. 时间复杂度：O(N*logN)

  1. 空间复杂度：O(1)

  1. 稳定性：不稳定

5.冒泡排序

基本思想：所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排序的特 点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。

/*
 * 冒泡排序
 * 时间复杂度O(n^2)
 * 空间复杂度O(1)
 * */
public static void bubbleSort(int[] array) {
    for (int i = 0; i < array.length; i++) {
        boolean flg = false;
        for (int j = 0; j < array.length - 1 - i; j++) {
            if (array[j] > array[j + 1]) {
                swap(array, j, j + 1);
                flg = true;
            }
        }
        //说明这趟循环没有改变 就说明已经有序
        if (flg == false) {
            return;
        }
    }
}
private static void swap(int[] array, int i, int j) {
    int tmp = array[i];
    array[i] = array[j];
    array[j] = tmp;
}

冒泡排序的特性总结:

  1. 冒泡排序是一种非常容易理解的排序

  1. 时间复杂度：O(N^2)

  1. 空间复杂度：O(1)

  1. 稳定性：稳定

6.快速排序

快速排序的基本思想为：任取待排序元素序列中的某元 素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有 元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

(1)挖坑法

每次找到一个基准 再从基准划分两边区域然后继续进行寻找基准

1) 将最左/右值记录下来用tmp表示,定义两边的指针left,right

2) left寻找比tmp大的值,right寻找比tmp小的值 当right找到就覆盖left下标的值,left同理

3)找到left = right的基准就返回下标值 由此分割成两个数组继续进行找基准

public static void quickSort(int[] array) {
    quick(array, 0, array.length - 1);
}
private static void quick(int[] array, int start, int end) {
    //终止递归条件
    //大于说明连左边或者右边都没有数据 end 在最左边 或者start 在最右边的情况
    if (start >= end) {
        return;
    }
    /*
    * 优化:
    * 当数据比较少的时候可以使用直接插入排序
    * 主要减少了递归的次数
    * */
    if(end - start + 1 <= 14){
        insertSort2(array,start,end);
        return;
    }
    //优化:三数取中法
    int index = midThree(array,start,end);
    //交换
    swap(array,index,start);
    //划分
    int pivot = partition(array, start, end);
    //左边
    quick(array, start, pivot - 1);
    //右边
    quick(array, pivot + 1, end);
}
private static int partition(int[] array, int left, int right) {
    int tmp = array[left];
    while (left < right) {
        /*
         * 这里相当于left找一次 right 找一次 不断地找*/
        //这里面找tmp右边的值 也就是比tmp大的值
        //这里如果不取等号就会无限循环下去
        while (left < right && array[right] >= tmp) {
            right--;
        }
        /*
         * 出该while循环它有两种可能
         * 1.是 left < right 说明全部排序完成
         * 内层的这个条件是控制寻找范围 外层是终止循环条件
         * 2.是 array[right] >= tmp 那么就说明找到了比tmp大的数字进行互换
         * 但是这只是换了一个值 还需要继续往左边找直到left < right 不成立(外层的while循环)
         * */
        array[left] = array[right];
        while (left < right && array[left] <= tmp) {
            left++;
        }
        array[right] = array[left];

    }
    //left 与 right 相遇  就开始left的值存在现在相遇的位置
    array[left] = tmp;
    return left;
}

我们会发现 如果第一次找的基准太大或者太小,数组分开就会不均匀,从而影响排序效率 ,因此引出三数取中法找到中间的值做tmp

优化:

[1]三数取中

//找到中间下标
private static int midThree(int[] array,int left,int right){
    int mid = (left + right) /2;
    if(array[left] < array[right]){
        if(array[mid] < array[left]){
            //mid < left < right
            return left;
        }else if(array[mid] > array[right]){
            //left < right < mid
            return right;
        }else {
            return mid;
        }
        //left > right
    }else {
        //left > right > mid
        if(array[mid] < array[right]){
            return right;
        }
        //mid > left > right
        else if(array[mid] > array[left]){
            return left;
        }else  {
            return mid;
        }
    }
}

[2]小数据优化

递归到小的子区间时，可以考虑使用插入排序 因为在排接近有序,或者小数组序列的时候 直接直接插入排序效率会比快排高

//辅助快排的直接插入排序
private static void insertSort2(int[] array,int left,int right) {
    for (int i = left + 1; i < right + 1; i++) {
        //从后往前排
        int tmp = array[i];
        int j = i - 1;
        for (; j >= left; j--) {
            if (array[j] > tmp) {
                //往后挪
                array[j + 1] = array[j];
            } else {
                //array[j+1] = tmp;
                //这时候就说明前面的数都会比tmp小 因为是排序好的
                //节省时间效率
                break;
            }
        }
        //break跳到的语句 或者当前最小的数(全部排序了一遍)
        array[j + 1] = tmp;
    }
}
(2)Hare法

与挖洞法不同的是将right值找到之后不进行覆盖而是找left值两个下标都找到之后再进交换

并且需要先找right的下标 然后再找left的下标

此时两种可能

1.left遇见right 说明right已经找到比tmp小的值

2.right遇见left 此时left所指位置一定是一个比tmp小的值(上一次交换的结果)

因此交换的结果一定是比tmp小的值去了最左边

public static void quickSort(int[] array) {
    quick(array, 0, array.length - 1);
}
private static void quick(int[] array, int start, int end) {
    //终止递归条件
    //大于说明连左边或者右边都没有数据 end 在最左边 或者start 在最右边的情况
    if (start >= end) {
        return;
    }
    /*
    * 当数据比较少的时候可以使用直接插入排序
    * 主要减少了递归的次数
    * */
    if(end - start + 1 <= 14){
        insertSort2(array,start,end);
        return;
    }
    三数取中法
    int index = midThree(array,start,end);
    //交换
    swap(array,index,start);
    //划分
    int pivot = partition(array, start, end);
    //左边
    quick(array, start, pivot - 1);
    //右边
    quick(array, pivot + 1, end);
}
//--------------------------------------区别------------------------------------------
public static int partition(int[] array, int left, int right) {
    int tmp = array[left];
    int i = left;
    while (left < right) {
        //需要先走右边再走左边 不然基准大的会换到前面
        while (left < right && array[right] >= tmp) {
            right--;
        }
        while (left < right && array[left] <= tmp) {
            left++;
        }
        //left找到比tmp小的right找到比tmp大的进行交换
        swap(array, left, right);
    }
    //相遇 此时两种可能1.left遇见right 说明right已经找到比tmp小的值 2.right遇见left 此时left所指位置一定是一个比tmp小的值(上一次交换的结果)
    swap(array, left, i);
    return left;
}
(3)快慢指针法

(1)定义一个前驱指针prev和当前所指元素指针Cur

遍历数组,条件[1] 当cur指向的元素小于left所指元素

条件[2] 判断prev是否为cur的前驱,如果是就不交换

(2)此时满足两个条件 prev和cur内的元素进行交换

(3)走完数组 将left的值和prev值进行交换,prev所在下标就是找到的基准位置.

public static void quickSort(int[] array) {
    quick(array, 0, array.length - 1);
}
private static void quick(int[] array, int start, int end) {
    //终止递归条件
    //大于说明连左边或者右边都没有数据 end 在最左边 或者start 在最右边的情况
    if (start >= end) {
        return;
    }
    /*
    * 当数据比较少的时候可以使用直接插入排序
    * 主要减少了递归的次数
    * */
    if(end - start + 1 <= 14){
        insertSort2(array,start,end);
        return;
    }
    三数取中法
    int index = midThree(array,start,end);
    //交换
    swap(array,index,start);
    //划分
    int pivot = partition(array, start, end);
    //左边
    quick(array, start, pivot - 1);
    //右边
    quick(array, pivot + 1, end);
}
//--------------------------------------区别------------------------------------------
public static int partition(int[]array,int left,int right){
    int prev = left;
    int cur = left + 1;
    //走到尾
    while (cur <= right) {
        //刚开始++prev的位置 == cur 因此不会交换
        //只有当中间出现array[cur] > array[left] 的时候 后面的条件才会成立 可交换
        if(array[cur] < array[left] && array[++prev] != array[cur]){
            swap(array,cur,prev);
        }
        cur ++;
    }

    swap(array,prev,left);
    return prev;
}

拓展:

非递归快速排序

public static void quickSort(int[] array) {
    Deque<Integer> stack = new LinkedList<>();
    int left = 0;
    int right = array.length -1;
    //找一次基准
    int pivoit = partition(array,left,right);
    //左边
    /*left + 1 和 right-1 保证两边存在数据*/
    if(pivoit > left + 1){
        //将left 和 pivot -1 放进去
        stack.push(left);
        stack.push(pivoit -1 );
    }
    //右边
    if(pivoit < right - 1){
        //将 right和 pivot  + 1 放进去
        //顺序不能换 不然后续的代码也需要换
        stack.push(pivoit + 1);
        stack.push(right);
    }
    while (!stack.isEmpty()){
        //弹出两个之后找基准
        //只要栈不为空 说明 左右两边都有元素 那么就可以不断的压栈入栈
        //直到pivot两边如果一边只存在一个元素那么就说明 排序完成
        right = stack.pop();
        left = stack.pop();
        pivoit = partition(array,left,right);
        if (pivoit > left + 1) {
            stack.push(left);
            stack.push(pivoit -1);
        }
        if (pivoit < right - 1) {
            stack.push(pivoit + 1);
            stack.push(right);
        }
    }
}

快速排序总结

  1. 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序

  1. 时间复杂度：O(N*logN)

  1. 空间复杂度：O(logN)

  1. 稳定性：不稳定

7.归并排序

基本思想

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使 子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。 归并排序核心步骤:

/**
 * 归并排序
 * 时间复杂度N*logN
 * 空间复杂度O(n)
 * 稳定性：稳定
 * @param array
 */
public static void mergeSort(int [] array){
    mergeSortFunc(array,0,array.length-1);
}
private static void mergeSortFunc(int []array,int left,int right ){
    if (left >= right) {
        return;
    }
    int mid = (left + right) / 2;
    //分解左边
    mergeSortFunc(array,left,mid );
    //分解右边
    mergeSortFunc(array,mid + 1,right );
    //合并数组
    merge(array,left,right,mid);
}
//合并
private static void merge(int[]array,int start,int end,int mid){
    int s1 = start;
    //int e1 = mid;
    int s2 = mid + 1;
    //int e2 = end;
    //申请一个合并数组
    int [] tmp = new int[end - start + 1];
    int k = 0;// tmp 数组下标
    //说明两个数组都有数据
    //这里有点像合并链表
    while (s1 <= mid && s2 <= end){
         if(array[s1] <= array[s2]){
             //小的放进tmp里面
             tmp[k++] = array[s1++];
         }else {
             tmp[k++] = array[s2++];
         }
    }
    //说明第一个数组存在数据
    while (s1 <= mid) {
        tmp[k++] = array[s1++];
    }
    //第二个存在数据
    while (s2 <= end) {
        tmp[k++] = array[s2++];
    }
    //需要加strat 因为不是所有array都是从0开始
    for (int i = 0; i < tmp.length; i++) {
        array[i + start] = tmp[i];
    }
}

拓展:

非递归实现归并排序

public static void mergeSort(int [] array){
    int gap = 1;
    while (gap < array.length){
        //从gap == 1 开始合并 每一次 gap * 2
        for (int i = 0; i < array.length; i+= gap*2) {
            int left = i;
            int mid = left + gap -1;//有可能会越界
            if (mid >= array.length) {
                mid = array.length - 1;
            }
            int right = mid + gap;
            if (right >= array.length) {
                right = array.length - 1;
            }
            merge(array,left,right,mid);
        }
        //当前为两组有序 下次变成四组有序 ...

        gap *=2;
    }
}

归并排序总结

  1. 归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。

  1. 时间复杂度：O(N*logN)

  1. 空间复杂度：O(N)

  1. 稳定性：稳定

排序类算法总结

NjmaoCompute
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
七大经典排序算法总结详解
12-29
七大经典排序算法总结【详解】
常见排序算法详解：插入，冒泡，希尔，选择，快速排序，归并，计数排序，堆排序（已完结）
zhang_si_hang的博客
04-17 3561
一.插入排序 void PrintArray(int* a, int n) { for (int i = 0; i < n; ++i) { printf("%d ", a[i]); } printf("\n"); } void Swap(int* pa, int* pb) { int tmp = *pa; *pa = *pb; *pb = tmp; } void InsertSort(int* a, int n) { for (int i = 0; ...
最快的排序算法是什么
温故而知新
09-26 1万+
最快的排序算法是什么，很多人的第一反应是快排，感觉QuickSort 当然应该最快了，其实并非如此，快排是不稳定的，最坏情况下，快排序并不是最优，Java7 中引入的 TimSort 就是一个结合了插入排序和归并排序的高效算法. Timsort最早是 Tim Peters 于2001年为 Python 写的排序算法。自从发明该算法以来，它已被用作Python，Java，Android平台和GNU ...
经典排序算法总结(快速排序、冒泡排序、二叉树排序...)
u011707861的博客
04-08 1011
排序(Sorting) 是计算机程序设计中的一种重要操作，它的功能是将一个数据元素(或记录)的任意序列，重新排列成一个关键字有序的序列。 我整理了以前自己所写的一些排序算法结合网上的一些资料，共介绍8种常用的排序算法，希望对大家能有所帮助。 八种排序算法分别是： 1.冒泡排序； 2.选择排序； 3.插入排序； 4.快速排序； 5.归并排序； 6.希尔排序； 7.二叉排序； ...
十大排序算法及其优化
qq_53077771的博客
07-05 642
通过重新排列表中的元素，使表中的元素满足按关键字有序的过程。为了查找方便,通常希望计算机中的表是按关键字有序的。
各种排序不同数据情况下性能比较（冒泡、插入、选择、希尔、归并、堆排、快排、基数排序）
m0_63494135的博客
06-20 2734
各种排序随打
【数据结构和算法】九大排序算法（插入排序，希尔排序，选择排序，堆排序，冒泡排序，快速排序，归并排序，计数排序，基数排序）
芥末虾的博客
03-07 6365
【数据结构和算法】九大排序算法（插入排序，希尔排序，选择排序，堆排序，冒泡排序，快速排序，归并排序，计数排序，基数排序）
八大排序算法
柒七的博客
02-04 1249
八大排序算法1.冒泡排序 冒泡排序是一种交换排序, 就是两两比较待排序的元素, 若次序不满足要求则交换, 知道整个数组有序 基本思想 : 每次找到最大或最小值, 然后放到首位或最后一位 对于长度为n 的数组, 因为只需要找到n-1个数的位置, 最后一个就已经确定了. 所以我们外部循环需要从0 ~ n-2. 内部循环从 n-1到 i+1, 内部循环每次将最大值或最小值推到i的位置(即选出第i小或第i大的数). 往复n-1次, 就完成了排序 public void bubbleSort(int[...
最快的排序方法-----快速排序
热门推荐
wfc1998的博客
10-03 2万+
一，快速排序的思想 1，在一个无序的数组里随机找一个作为基准值。 2，然后让数组里的每一个数字和基准值比较，比基准值大的放在基准值右边，比基准值小的，放在基准值左边。 3，递归调用这个函数，使得整个数组有序。 二，快速排序的实现方法 方法一：交换法 取最后一个数据为基准值，begin标记数组第一个数据，end标记数组最后一个数据 begin++向后走，找到比基准值大的数停下来，end–向前走，找...
快速排序小结
北漂的IT小白菜
07-23 520
定义：快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要Ο(nlogn)次比较。事实上，快速排序通常明显比其他Ο(nlogn) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来，并且在大部分真实世界的数据，可以决定设计的选择，减少所需时间的二次方项之可能性。快速排序，通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字
python快排算法详解
12-31
2、快排是一种解决排序问题的运算方法。 3、快排的原理：在数组中任意选择一个数字作为基准，用数组的数据和基准数据进行比较，比基准数字打的数字的基准数字的右边，比基准数字小的数字在基准数字的左边， 第一次...
python 排序算法总结及实例详解
09-21
主要介绍了python 排序算法总结及实例详解的相关资料,需要的朋友可以参考下
Java中自然排序和比较器排序详解
09-01
给大家介绍Java中的排序并不是指插入排序、希尔排序、归并排序等具体的排序算法。而是自然排序和比较器排序，文中通过实例代码介绍的很详细，有需要的朋友们可以参考借鉴。
Java 7大常见排序方法实例详解
08-30
主要通过实例介绍了Java中常用的7种排序方法，需要的朋友可以参考下
各个排序算法的时间复杂度、稳定性、快排的原理以及图解
05-30 1万+
一、整体介绍 常见的数据结构算法如下图所示： 常见数据结构算法的时间复杂度、空间复杂度、稳定性介绍如下图所示： 二、分部介绍： （1）直接插入排序： 从第一个元素开始，该元素可以认为已经被排序 取出下一个元素，在已经排序的元素序列中从后向前扫描 如果新元素小于已排序元素tmp<array[ j ]，将该元素移到下一位置array[ j+1]=array[ j ] 重复步骤3 j - -，直到找到已排序的元素小于或者等于新元素的位置 array[ j ]<=tmp.
七大排序算法（插排，希尔，选择排序，堆排，冒泡，快排，归并）--图文详解
qq_52592775的博客
09-04 8148
万字长文加N多图片喂你七大排序的知识点, 让你用脚都能写出排序算法
八大排序详解
！
04-23 739
实用的排序算法，考研找工作必备！
面试：聊一聊 Java 数组默认的排序算法，我懵了
wadfdhsajd的博客
07-05 823
之前一直没关注过Java底层排序的算法，才仔细看了下Timsort。Timsort 是一个混合、稳定的排序算法，简单来说就是归并排序和二分插入排序算法的混合体，号称世界上最好的排序算法。它由 Tim Peters 在 2002 年提出并实现，一直是 Python 的标准排序算法。Java 在 1.7 后增加了 Timsort API ，从Java中的 可以看出它是默认的排序算法，主要用于非原始类型数组排序。所以不管是进阶编程还是面试，理解 Timsort 都是比较重要。 前置知识 理解 Timsort
排序算法——快速排序及Python实现
黄大堂
05-08 379
快速排序 快速排序（英语：Quicksort），又称划分交换排序（partition-exchange sort），通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归（函数内部再调用函数自身）进行，以此达到整个数据变成有序序列。 步骤为： 从数列中挑出一个元素，称为"基准"（pivo...
ps -aux |grep命令详解
最新发布
07-28
问题:ps -aux |grep命令详解 回答:ps -aux | grep命令是一种常用的进程查看和筛选命令。ps -aux命令用于查看当前系统中所有进程的详细信息，包括进程的用户、进程ID、CPU占用率等。而grep命令则用于在ps命令的输出...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值