继续刷刷--《十大经典排序算法》

原创 已于 2022-10-24 11:14:24 修改 · 452 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#排序算法 #算法

于 2022-09-01 23:45:03 首次发布

前言

如前所述，下面接着刷刷排序算法，自然就得看看目前经典的十大排序算法。打算都过一遍，理解一下思路，再用代码实现一下，加深印象，仅作为自己的学习积累，写在这里也做自己备份，偶尔也可以上来看看~~

网上关于这十大经典排序算法的资料、说明很多，我就不重复说明了，这里仅放一些自己的理解。有些资料也来源网络，毕竟没必要重复造轮子，如有侵权，请告知我删除~

十大经典排序算法说明

所谓排序，就是将一组序列，按照数的大小，递增地或递减地排列起来的操作。距今为止，出现了10种经典的排序算法，也就是接下来要逐一介绍的。如下图（图片来源网络）：
（图片来源网络）
名词解释：

  • 时间复杂度：定性描述一个算法执行所耗费的时间；（重要性>空间复杂度，优先考虑）
  • 空间复杂度：定性描述一个算法执行所需内存的大小；
  • n：数据规模/个数；
  • k：“桶”的个数；
  • In-place：占用常数内存，不占用额外内存；
  • Out-place：占用额外内存
  • 稳定：排序后，不改变相同元素的先后位置；
  • 不稳定：排序后，会改变相同元素的先后位置。

十大经典排序算法分类

目前看到的分类，主要有三种分类：

  • 一是按是否占用额外内存分类，分为内部排序和外部排序；
  • 二是按是否稳定分类，分为稳定排序和非稳定排序；
  • 最后一种就是按是否进行数与数之间的比较分类，分为比较类排序和非比较类排序。

个人觉得最后一种是比较正确的分类方式，方便理解和记忆。

前两种分类，在上图已有介绍。下面放上最后一种分类方式（图片来源网络）：
请添加图片描述

下面开始逐一过一下各个排序算法，学习一下前人的思想有多伟大，一个排序都能想到这么多种方法、思路。

说明：以下排序算法均以升序进行介绍。

——————————分割线：2022，0901——————————————————————

1. 冒泡排序

1.1 算法介绍

经典排序算法，循环比较两个数大小，如果前者大于后者，则进行交换，否则不变（升序）。算法名字的由来也是因为越小的元素会经由交换逐渐“冒泡”到序列前面。

冒泡排序还有一种优化算法，就是定一个flag记录在一次遍历比较中，是否发生元素交换，若未发生交换，则说明该序列已经有序，可提前终止遍历，提升性能。

个人最常用的一种排序，实现简单，很好记忆，几行代码就能搞定。

记忆的话，就记住核心是不停交换就行了，不停冒泡，交换次数：(leng - 1)^2。为什么是减一，因为比如2个数，只用交换1次就排序好了，这样来理解；为什么是平方，因为长序列，不可能通过一次遍历交换就可以排序好，所以是平方。

1.2 算法步骤

  1. 比较相邻两个元素，如果前者大于后者，则进行交换；
  2. 重复步骤1，至多n^2次，则可完全排序完。

1.3 算法性能指标

平均复杂度：O(n^2)
空间复杂度：O(1)
稳定性：稳定

1.4 代码实现

main.cpp

#include <iostream>

#include "../include/bubble_sort.h"

using namespace std;

/*
    function description:
        printf a array before or after sort
    parameter:
        @is_before_sort : array type,  true for array before sort, false for array after sort
        @array          : data after bubble sort
        @size           : size of data_before_sort
    return Value:
        void
*/
void printf_sort_array(bool is_array_before_sort, const int* array, ssize_t size)
{
    if(NULL == array || size <= 0)
        return;
    
    if(true == is_array_before_sort)
        cout << "array_before_sort: "<< endl;
    else
        cout << "array_after_sort: "<< endl;

    ssize_t i;
    for( i = 0; i < size; i++ )
    {
        cout << " " << array[i];
        if(i == size - 1)
            cout << endl << endl;
    }
}

int main(void) 
{
    /* 排序前的序列 */
    int array[] = {
        3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48
    };
    
    ssize_t len_of_array = sizeof(array) / sizeof(int);
    
    /* printf array before sort */
    printf_sort_array(true, array, len_of_array);

    /* sorting */
    bubble_sort(array, len_of_array);

    /* printf array after sort */
    printf_sort_array(false, array, len_of_array);
    return 0;
}

bubble_sort.cpp

#include "../include/bubble_sort.h"

using namespace std;

/*
    function description:
        bubble sort
    parameter:
        @array : data need to be sorted
        @size  : size of data_before_sort
    return Value:
        void
*/
void bubble_sort(int* array, ssize_t size)
{
    if(NULL == array || size <= 0)
         return;
    
    ssize_t i,j;
    ssize_t cycle_num = 0;

    int temp;
    bool flag_to_terminate = true; //flag to optimize bubble sort

    cout<< "Bubble sorting(optimized)..." << endl << endl;

    //冒泡算法核心：逐个交换
    for(i = 0; i < size - 1; i++)
    {
        flag_to_terminate = true;
        for(j = 0; j < size - 1; j++)
        {
            if(array[j] > array[j + 1])   
            {
                temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
                flag_to_terminate = false;
            }
            cycle_num++;
        }
        if(flag_to_terminate)
            break;
    }

    cout << "cycle_num: " << cycle_num << endl;
}

bubble_sort.h

#ifndef __BUBBLE_SORT_H
#define __BUBBLE_SORT_H

#include <iostream>
void bubble_sort(int* array, ssize_t size);

#endif // __BUBBLE_SORT_H

1.5 代码运行结果：

请添加图片描述

——————————分割线：2022，0904——————————————————————

2. 选择排序

2.1 算法介绍

经典排序算法，在未排序序列中找到最小数，放在序列的起始位置（升序），然后再从剩余未排序序列中继续找最小数放在已排序序列的下一位置，重复当前步骤，直至所有序列已排序完毕。

核心是每次在未排序序列中找到最小数，然后放到已排序序列，然后再从剩余未排序序列中找到最小数，注意是剩余的序列，不然会遍历重复元素，徒增算法消耗。

记忆的话，算法核心就是不停在未排序序列中选择一个最小数放在已排序序列中，组成已排序序列，所以叫做选择排序。

2.2 算法步骤

  1. 在未排序序列找到最小数，放在已排序序列起始位置；
  2. 在剩余未排序序列找到最小数，放在已排序序列的下一位置；
  3. 重复步骤2，直至元素排序完。

2.3 算法性能指标

平均复杂度：O(n^2)
空间复杂度：O(1)
稳定性：不稳定

不稳定体现在取未排序序列的最小数时，并不知道哪个与其相等，所以有可能会改变相同元素的位置。

2.4 代码实现

select_sort.cpp

#include "../include/bubble_sort.h"

using namespace std;

/*
    function description:
        select sort
    parameter:
        @array : data need to be sorted
        @size  : size of data_before_sort
    return Value:
        void
*/
void select_sort(int* array, ssize_t size)
{
    if(NULL == array || size <= 0)
        return;

    int temp, min_index;
    ssize_t i,j;

    cout<< "Select sorting..." << endl << endl;
 
    for(i = 0; i < size - 1; i++)
    {
        min_index = i;
        //find min in the unsorted array
        for(j = i + 1; j < size;j++){
            if(array[j] < array[min_index])
                min_index = j;
        }

        //exchange the min in the unsorted array to the sorted array
        if(min_index > i)
        {
            temp = array[i];
            array[i] = array[min_index];
            array[min_index] = temp;
        }
    }
}

main.cpp同前，只是换了调用的函数，改为select_sort(array, len_of_array)即可，此处不重复添加代码。

2.5 代码运行结果：

请添加图片描述

——————————分割线：2022，0906——————————————————————

3. 插入排序

3.1 算法介绍

经典排序算法，代码实现没有冒泡排序和选择排序那样简单粗暴，但原理是最好理解的。打过扑克牌的，都能理解，在整理牌的时候，会把牌按从小到大整理，再来下一张牌的时候，就插入在已整理的牌中。

把待排序序列的第一个元素看做一个有序序列，把第二个到最后一个元素作为一个未排序序列，从头到尾依次扫描未排序序列，把扫描到的每个元素插入到有序序列的适当位置。

记忆的话，算法核心就是不停在未排序序列中取出一个数插入到已排序序列中，组成已排序序列，所以叫做插入排序。

3.2 算法步骤

  1. 把待排序序列的第一个元素看做一个有序序列，把第二个到最后一个元素作为一个未排序序列；；
  2. 依次遍历未排序序列的每个元素，逐一插入到有序序列中；
  3. 重复步骤2，直至元素排序完。

3.3 算法性能指标

平均复杂度：O(n^2)
空间复杂度：O(1)
稳定性：稳定

稳定性体现在在插入的时候，可以选择在遇到相同元素的时候，可以不动其位置，直接放在元素后面就可以了。

3.4 代码实现

insert_sort.cpp

#include "../include/insert_sort.h"
using namespace std;

/*
    function description:
        bubble sort
    parameter:
        @array : data need to be sorted
        @size  : size of data_before_sort
    return Value:
        void
*/
void insert_sort(int* array, ssize_t size)
{
    if(NULL == array || size <= 0)
        return;

    int temp;
    ssize_t i, j, k;
    ssize_t cycle_num = 0;

    cout<< "Insert sorting..." << endl << endl;

    //unsorted array
    for(j = 1; j < size; j++)
    {
        // sorted array 
        for(i = 0; i < j; i++)
        {
            cycle_num++;
            // 1,5,7,8, ←3
            //插入排序为 1,3,5,7,8 说明 5,7,8需要分别向右移一个位置
            //然后再放入3在5前面
            if(array[j] < array[i])
            {
                temp = array[j]; //保存3的值
                //右移i到j之间数字到下一个位置(包含i，不含j)
                for(k = j - 1; k >= i; k--) {
                    array[k + 1] = array[k];
                }
                array[i] = temp; //3的插入
                break;//插入完成后，则停止继续查找插入位置
            }

            //遍历到最后一个，说明是最大的，直接添加到序列最后的位置
            //1,5,7,8, ←9
            //1,5,7,8,9
            if(i == j - 1){
                array[i + 1] = array[j];
            }
        }
    }
    
    cout << "cycle_num: " << cycle_num << endl;
}

3.5 代码运行结果：

请添加图片描述
——————————分割线：2022，0910——————————————————————
今天中秋，节日快乐！一个人在外面，也没啥过节氛围，只有刷刷题啦=。=

4. 希尔排序

4.1 算法介绍

1959年由shell发明，就是下图中这个哥们，有点帅啊，第一个复杂度突破O（n^2）的排序算法，NB！也是插入排序的改进版，改进之处在于它可以优先比较距离较远的元素。

首先通过一个初始增量（我理解为间距），将数组分为多组，然后分别对每个组进行插入排序，然后不断缩小增量、排序，重复这个过程，最后当增量为1，再进行一次普通的插入排序，排序完成了。所以也称为缩小增量排序。

请添加图片描述
它比插入排序更高效，主要基于上图中的两点：

  1. 插入排序对已经排序好的数据操作效率高，可以达到线性排序的效率；（所以先使用增量对每组进行排序）
  2. 插入排序低效在于每次只能对一个数据进行排序。（所以使用增量，对每组进行排序）

增量的取值，上图也有说明，一般可取值为待排序数的个数的一半，然后逐次减半，直至为1。

算法如下图（图片来源网络），就比较直观了：
请添加图片描述

记忆的话，算法核心就是缩小增量排序/改进版的插入排序，希尔发明，所以叫希尔排序。

4.2 算法步骤

  1. 选择一个增量序列，gap1,gap2,gap3,…，1。增量序列为降序，即gap1 > gap2等；
  2. 对每个gap下的序列，进行gap次插入排序（因为分为了gap个数组）；
  3. 重复步骤2，即可排序完成。

4.3 算法性能指标

平均复杂度：O(nlogn)
空间复杂度：O(1)
稳定性：不稳定

不稳定体现在多个增量排序下，不能保证相同元素的位置保持不变。

4.4 代码实现

shell_sort.cpp

/*
    function description:
        shell sort
    parameter:
        @array : data need to be sorted
        @size  : size of data_before_sort
    return Value:
        void
*/
void shell_sort(int* array, ssize_t size) 
{
    if(NULL == array || size <= 0)
        return;

    int temp;
    ssize_t i, j, k, m, n;
    short gap;
    ssize_t cycle_num = 0;

    cout<< "Shell sorting..." << endl << endl;

    //gap值取的规则为size的一半向下取整
    for(gap = size >> 1; gap > 0; gap >>= 1)
    {
        //每个gap下，每个array的排序
        for(m = 0; m < gap; m++)
        {
            //插入排序，i为未排序序列,j为已排序序列
            for(i = m + gap; i < size; i += gap)
            {
                for(j = m; j < i; j += gap)
                {
                    if(array[i] < array[j])
                    {
                        temp = array[i];
                        for(k = i - gap; k >= j; k -= gap) {
                            array[k + gap] = array[k];
                        }
                        array[j] = temp;
                        break;//插入完成后，则停止继续查找插入位置
                    }
                    cycle_num++;
                }
            }
        }

    }

    cout << "cycle_num: " << cycle_num << endl;
}

4.5 代码运行结果：

请添加图片描述
——————————分割线：2022，0913——————————————————————

5. 归并排序

5.1 算法介绍

从算法名字就可以看出，该排序算法的核心在于归并。

既然要归并的话，则开始肯定是需要先分离的，怎么分离呢，就是很直接地不停二二分组，不停分成两组，直到最后两组各只有一个元素，然后比较两组的元素大小，再将该两组归并到一组，再逐一不停归并，一直归并到一个组，此时就完成了归并排序。

两个数组的归并的详细过程是这样的，申请一块内存，内存大小为待归并的两个已排序的数组，两个指针分别指向两个已排序的数组的起始位置，先比较大小，小的放进那块内存，并把指向小的指针移向下一个位置，再进行比较，重复前面的过程，直至两个指针的其中一个已经移到了数组末尾，此时再把那个未到达数组末尾的指针所在的数组剩余的数拷贝至内存末尾。

这样就完成了两个有序数组的归并，注意前提是两个数组必须有序。因为从前面“最后的拷贝至末尾”的操作可以看出，如果不是有序，则会出问题。

5.2 算法步骤

  1. 数组的不停二二拆分；
  2. 拆至分别只剩1个元素后，然后比较大小，再进行2个数组归并；
  3. 重复步骤2，即可排序完成。

5.3 算法性能指标

平均复杂度：O(nlogn)
空间复杂度：O(n)
稳定性：稳定

从算法可以看出，归并排序需要先申请一块内存，所以空间复杂度为O(n)。

5.4 代码实现

merge_sort.cpp

#include "../include/merge_sort.h"

using namespace std;

/*
    function description:
        sorted merge two sorted arrays
    parameter:
        @array1 : sorted array1 need to be merge
        @size1  : size1 of array1
        @array2 : sorted array2 need to be merge
        @size2  : size of array2
    return Value:
        @int*   : sorted merge array, size = size1 + size2
*/
int* merge_two_arrays(int* array1, ssize_t size1, int* array2, ssize_t size2)
{
    /* parameters check */
    if(NULL == array1 && NULL != array2)
        return array2;
    
    if(NULL == array2 && NULL != array1)
        return array1;

    if(NULL == array1 && NULL == array2)
        return NULL;

    // index_1 → array1,index_2 → array2,
    ssize_t index_1 = 0, index_2 = 0, index_t = 0;

    int* temp_array = (int *)malloc((size1 + size2)*sizeof(int));

    //归并两个已排序序列
    while(index_1 < size1 && index_2 < size2){
        temp_array[index_t++] = array1[index_1] < array2[index_2] ? array1[index_1++] : array2[index_2++];
    }

    //复制剩余元素至已排序序列
    while (index_1 < size1){
        temp_array[index_t++] = array1[index_1++];
    }
    
    while (index_2 < size2){
        temp_array[index_t++] = array2[index_2++];
    }

    return temp_array;
}

/*
    function description:
        merge sort
    parameter:
        @array : data need to be sorted
        @size  : size of data_before_sort
    return Value:
        @int*  : sorted merge array, size = input array size
*/
int* merge_sort(int* array, ssize_t size)
{
    if(NULL == array || size <= 1)
        return array;

    ssize_t middle_index = size >> 1;
    ssize_t f = 0 , l = 0, temp = 0;

    int temp_first[middle_index];
    int temp_last[size - middle_index];

    while (f < middle_index){
        temp_first[f++] = array[temp++];
    }
    
    while (l < size - middle_index){
        temp_last[l++] = array[temp++];
    }

    // First, merge sort the first half and the last half.
    // Then, merge the two halves.
    return merge_two_arrays(merge_sort(temp_first, middle_index), middle_index, 
                            merge_sort(temp_last, size - middle_index), size - middle_index);
}

代码使用的是递归方式进行实现，部分代码参考【https://www.cnblogs.com/guyouyin123/p/14622770.html】，只有TA的代码逻辑我看得很清晰。

5.5 代码运行结果：

在这里插入图片描述

6. 快速排序

6.1 算法介绍

快速排序突出一个“快”，“沉也沉的快嘛”，= =。

快速排序是由东尼·霍尔所提出的一种排序算法，名字很直接，排序就是快，而且效率高！据说它是处理大数据最快的排序算法之一了，虽然最坏情况的时间复杂度为O（n^2），平均时间复杂度为O（nlogn），但在大多数情况下，都比平均时间复杂度的排序算法表现要好。

快速排序通过多次比较和交换来完成排序，和冒泡很像，所以经常会拿过来一起比较，但快速排序多了一个和基准值的比较，然后再“分而治之”，比基准值小的放前面，比基准值大的放后面，然后再迭代比较两个区间，最后，就排序好了。

6.2 算法步骤

  1. 从数列中挑出一个基准数据（一般是第一个元素）；
  2. 排序数列，挑出比基准数小的放基准前面，比基准数大的放后面；
  3. 递归地对基准前的数据和基准后的数据进行重复步骤2，即可排序完成。

6.3 算法性能指标

平均复杂度：O(nlogn)
空间复杂度：O(logn)
稳定性：不稳定

6.4 代码实现

//快速排序
//递归地调用单趟排序
void quick_sort(int* a, int left, int right)
{
    //如果区间只剩一个数或没有数，就不进行操作
    if(NULL == a || left >= right)
        return;

    int key = single_sort(a, left, right);
    quick_sort(a, left, key-1);
    quick_sort(a, key+1, right);
}

//单趟排序，hoare方法
//1.任意取左边第一个数作为基准数，然后分别从最左边向右边遍历和从最右边向左边遍历（注意需要先要最右边向左边遍历）
//2.最右边向左边遍历寻找比基准数小的数，最左边向右边遍历寻找比基准数大的数
//3.各找到一个后，交换，继续遍历，直至两个位置重合
//4.最后，交换重合位置的数和基准数
static int single_sort(int* a, int left, int right)
{
    int key = left;

    while (left < right)
    {
        while(right > left && a[right] >= a[key])
            right--;
        while(left < right && a[left] <= a[key])
            left++;
        //交换基准数两边的数
        swap(&a[left], &a[right]);
    }
	//交换基准数，使其前面为小于它的数，后面为大于它的数
    swap(&a[key], &a[left]);
    key = left;

    return key;
}

static void swap(int* a, int* b)
{
    int temp;

    temp = *a;
    *a = *b;
    *b = temp;
}

参考：
https://blog.youkuaiyun.com/LiangXiay/article/details/121421920（代码实现）
https://blog.youkuaiyun.com/weixin_43586713/article/details/119820797（快速排序的排序过程理解）

6.5 代码运行结果：

请添加图片描述

夜深人静写算法（十七）- 分组背包
英雄哪里出来
01-21 4万+
互相冲突的背包——分组背包
算法刷刷刷（一、递归)
weixin_45743162的博客
02-14 1153
去tm的封面
贪心算法--Leetcode刷刷刷
如果可以一直带着少年时的酷
12-04 1017
贪心总结.png。
回溯算法--Leetcode刷刷刷
如果可以一直带着少年时的酷
12-04 247
每层都是从0开始搜索而不是startIndex需要used数组记录path里都放了哪些元素了47. 全排列 II只需要在46题的基础上加上树层去重即可。怎么进行树层去重呢？历时21天，14道经典题目分析，20张树形图，21篇回溯法精讲文章，从组合到切割，从子集到排列，从棋盘问题到最后的复杂度分析，至此收尾了。这里的每一种问题，讲解的时候我都会和其他问题作对比，做分析，确保每一个问题都讲的通透。可以说方方面面都详细介绍到了。如何理解回溯法的搜索过程？
算法系列之经典排序算法
Web分享
05-05 332
说到算法，入门级的算是排序算法了。还记得读大学时，学的第一个是冒泡排序。初次接触算法，觉得很神秘，一个冒泡竟然搞了很久。 这边文章主要介绍一些经典的排序算法，由于博主现在做 web 前端方面的工作，所以编程语言就使用 JavaScript 了。不过，如果是学其他语言的人，读懂大致的思路是没问题的，完全可以仿照文章中 JavaScript 版的代码进行重写。 概述 排序算法是非常基础的算法之一，在...
排序算法系列：归并排序算法
大鱼
05-27 2万+
上一篇我们说了一个非常简单的排序算法——选择排序。其复杂程序完全是冒泡级的，甚至比冒泡还要简单。今天要说的是一个相对比较复杂的排序算法——归并排序。复杂的原因不仅在于归并排序分成了两个部分进行解决问题，而是在于，你需要一些算法的思想支撑。
华为OD-----字符串筛选排序
TTz012的博客
07-13 268
k如果大于字符串长度则输出最大ASCII码值的字母所在字符串的位置索引。k如果大于字符串长度则输出最大ASCII码值的字母所在字符串的位置索引。如果第k个最小ASCII码值的字母存在重复 则输出该字母的最小位置索引。输出该字母所在字符串中的位置索引(字符串的第一个位置索引为0)输出字符串中第k个最小ASCII码值的字母所在字符串的位置索引。F在字符串中位置索引为5(0为字符串的第一个字母位置索引)查找字符串中第K个最小ASCII码值的字母(k>=1)如果有重复字母则输出字母的最小位置索引。
算法刷刷刷--01选择排序、冒泡排序、插入排序
xcvbxv01的博客
04-16 193
【代码】算法刷刷刷--01选择排序、冒泡排序、插入排序。
python算法题排序_python-数据结构与算法- 面试常考排序算法题-快排-冒泡-堆排-二分-选择等...
weixin_39611413的博客
12-05 164
算法可视化网站推荐---->visualgo0.面试题中的排序算法一些排序算法可能在工作中用的会比较少，但是面试却是不得不面对的问题。算法有助于提高我们对数据结构的理解以及提高自己的逻辑能力，没事刷刷真的不错。1.快排面试最推荐而且也是写的最多的快排的思路是分而治之，相当于我每次去将一个数归为，直到所有的数都归为了，那么这个排序也就成功了。快排第一种思路：(这个思路参考下，不要写)平均时间复...
开始刷题--《C语言经典100题》
热门推荐
To_be_a_fisher的博客
10-06 3万+
前言 国庆哪儿也没去，打算趁着这段时间好好理理、总结自己刚工作以来的问题。 工作有点恼火，没有得心应手的感觉，除了换了工作方向不适应外，就感觉自己基础不够好，刚工作，就在公司犯了一些C语言方面的错误，也被leader说了，就打算来刷刷C语言的题了，加强下自己的基础，加油！ 每天至少两道题，立贴为证~~ 编程环境 IDE： Visual C++ 6.0 操作系统： win10-64位 所编程序均已验证，能实现功能，但是否最优，尚待确认，仅作为自己的练习积累。 如有不妥，敬请指教啦~ 正文 【程序1】 题目：有
刷刷笔试题--贪心算法
nanaMasuda的博客
09-09 4659
1.[编程题]最大差值 有一个长为n的数组A，求满足0≤a≤b 给定数组A及它的大小n，请返回最大差值。 测试样例： [10,5],2 返回：0 解析： 要求按顺序从左到右扫，很多题都适用这种方法 import java.util.*; public class LongestDistance { public int getDis(int[]
日拱一卒：Android，java_基础，leetcode算法刷刷刷，数组、链表、二叉树、排序
09-26
在这个压缩包文件中，我们发现了一系列关于Android开发、Java基础知识、LeetCode算法练习以及数据结构与算法的核心概念，如数组、链表、二叉树和排序算法的学习资料和练习代码。这些内容构成了一个全面的基础学习...
Leetcode前k个出现次数最多的单词--对python3排序函数的思考
liguangbenren的博客
11-24 1756
目录   0. 磨叽一下 1. leetcode题目--返回前k 个出现次数最多的单词 2. 未领会题目精神的错误解答 3. python多条件排序    0. 磨叽一下 刷leetcode有一阵子了，出于效率考虑，还只是把重点放在简单类型的题目，这个难度的题目花费时间不会太长，基本上利用每天到公司上班前的一小段时间可以完成一道。 但是总是停留着自己的舒适区是不会有太大的进步，于...
Leetcode JAVA刷刷站（33）搜索旋转排序数组
m0_73399576的博客
08-15 388
Leetcode JAVA刷刷站——搜索旋转排序数组篇
数据结构初阶（17）排序算法——非比较排序（计数排序·动图演示）、排序算法总结
2301_79907403的博客
08-16 669
排序算法——非比较排序、排序算法总结
数据结构初阶（16）排序算法——归并排序
2301_79907403的博客
08-16 904
排序算法——归并排序
Java算法之排序
最新发布
Y409001的博客
08-19 490
本文系统介绍了七大基于比较的排序算法，包括插入排序（直接插入和希尔排序）、选择排序（直接选择和堆排序）、交换排序（冒泡和快速排序）以及归并排序。重点分析了快速排序和堆排序的实现原理，详细讲解了快速排序的三种分割方法（Hoare法、挖坑法和前后指针法）及其优化策略（三数取中法和减少递归深度）。文章还探讨了归并排序的递归和非递归实现，并对各种算法从稳定性、时间复杂度和空间复杂度三个维度进行了性能比较。最后简要介绍了非基于比较的计数排序及其适用场景。排序算法的选择需根据具体数据特征和应用场景。
数据结构初阶（15）排序算法—交换排序（快速排序）（动图演示）
2301_79907403的博客
08-15 1469
排序算法—交换排序（快速排序）（动图演示）
LCR 076. 数组中的第 K 个最大元素
执子手 吹散苍茫茫烟波
08-15 374
在此过程中，i走过的区域都是大于等于待排元素的，j走过的区域都是小于待排元素的，最后i和j相遇且指向的都是废弃元素。从i位置往后遍历，找到小于待排元素，把该元素换到右指针指向位置（上轮的废弃位置；从j位置往前遍历，找到大于待排元素，把该元素换到左指针指向位置（此时右指针位置废弃）；请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。输入：nums = [3,2,3,1,2,4,5,5,6], k = 4。输入：nums = [3,2,1,5,6,4], k = 2。
如何刷刷算法题
04-01
### 如何有效刷算法题并提升技巧 为了有效地提高算法能力，可以通过以下几个方面进行实践： #### 1. 制定学习计划 制定清晰的学习目标和计划有助于系统化地掌握数据结构与算法的知识。可以从基础的数据结构入手，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值