各种排序的排序思想和实现

最新推荐文章于 2022-06-03 22:00:50 发布
最新推荐文章于 2022-06-03 22:00:50 发布
阅读量859 收藏 3
点赞数
分类专栏： C语言 linux 算法导论 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ooooo12345re/article/details/50756655
版权
C语言 同时被 3 个专栏收录
20 篇文章 1 订阅
订阅专栏
linux
12 篇文章 0 订阅
订阅专栏
数据结构
11 篇文章 0 订阅
订阅专栏

     今天主要和大家讨论八大排序算法，包括冒泡排序、插入排序、选择排序、shell排序、归并排序、快速排序、计数排序、堆排序。通过和大家的讨论，相信对大家的在今后的学习和面试肯定会有很大的帮助。下面分别来说明各种排序的排序的思想和其实现。

      （1）冒泡排序：

             排序思想：设数组a[0..n-1]，令i = 0，j从1到n - i 判断相邻的元素的大小，如果a[j - 1] > a[j]，交换a[j - 1]、a[j]，则对于一趟排序来说，就可以将数组的最大值冒泡的a[n - 1]的位置；

  下面给出冒泡排序的程序：

void bubble_sort(int *array,int length)
{
    int i = 0;
    int j = 0;
    int temp = 0;
    for(i = 0;i < length;++i){
        for(j = 1;j < length - i;++j){
            if(array[j - 1] > array[j]){
                temp = array[j - 1];
                array[j - 1] = array[j];
                array[j] = temp;
            }
        }
    }
}

在此应注意的是，i和j遍历数组的范围，因为每次冒泡都会使得最大的元素位于数组的最后，则下一次排序时，位于数组的后面的元素不用参与排序，所以j是从1到length - i。

对于冒泡排序还可以进行优化，其优化的代码如下：

void bubble_sort1(int *array,int length)
{
    Boolean flag = TRUE;
    int j = 0;
    int temp = 0;
    while(flag){
        flag = FALSE;
        for(j = 1; j < length;++j){
            if(array[j - 1] > array[j]){
                temp = array[j - 1];
                array[j - 1] = array[j];
                array[j] = temp;
                flag = TRUE;
            }
        }
        length--;
    }
}

当出现在其中一次中没有发生交换，则说明数组的元素已经升序，则排序完成。

由此可看出冒泡排序的时间复杂度为o(n^2)，并且是一种发生在相邻元素的交换，所以冒泡排序是一种稳定的排序。

    （2）插入排序：

            排序思想：设数组a[0..n-1]，

            1> 初始时，a[0]自成一个有序序列，无序区为a[1..n-1] ，令i = 1；

            2>将a[i]插入到当前有序区a[0..i - 1]形成有序区a[0..i];

           3>i++重复第二步骤，使得i == n - 1，排序结束。

下面给出插入排序的代码实现：

void insert_sort(int *array,int length)
{
    int i = 0;
    int j = 0;
    int temp = 0;
    for(i = 1;i < length;++i){
        temp = array[i];
        for(j = i - 1;j >= 0 && array[j] > temp;j--){
            array[j + 1] = array[j];
        }
        array[j + 1] = temp;
    }
}

  由此可见看出插入排序的时间复杂度为o(n^2)，插入排序并不是相邻元素交换，所以插入排序是不稳定的。

       （3）选择排序：

              排序思想：设数组a[0..n-1]；
                1> 初始时，数组全为无序区为a[0..n-1].令i = 0
                2>在无序区a[i..n-1]中选取一个最小的元素，将其与a[i]交换，交换之后a[0    ..i] ， 就形成了一个有序区。
                3> i++并重复第二步直到i==n-1,排序完成。

选择排序的代码实现：

void select_sort(int *array,int length)
{
    int i = 0;
    int j = 0;
    int min_index = -1;
    int temp = 0;
    for(i = 0;i < length;++i){
        min_index = i;
        for(j = i + 1;j < length;++j){
            if(array[j] < array[min_index]){
                min_index = j;
            }
        }
        if(min_index != i){
            temp = array[min_index];
            array[min_index] = array[i];
            array[i] = temp;
        }
    }
}
选择排序的时间复杂度仍为o(n^2),并且是一种不稳定的排序。
对于这三种排序的结果如下：

  在数据规模比较小的时候，这三种排序消耗的时间都比较短；当我们把数据规模扩大到1万的时候，其消耗的时间如下：

                    

由程序的执行效果来说，在数据规模在1万左右时，插入排序的效率是三种排序中执行效率最快的，最慢的是冒泡排序。

接下来我们讨论的排序都比上述的排序效率高，首先我们来看shell排序，

         （4）shell排序：设数组a[0 .. n-1]

                 排序思想：shell排序可以说是插入排序的升级版，其中gap称为增量，在本程序中gap是从n / 2，减到1

，每次进行插入排序，当gap 减为1时，就和上述的插入排序一样。

          shell排序的代码实现：

void shell_sort(int *array,int length)
{
    int gap = 0;
    int i = 0;
    int j = 0;
    int temp = 0;
    for(gap = length / 2;gap > 0;gap /= 2){
        for(i = gap;i < length;++i){
            temp = array[i];
            for(j = i - gap;j >= 0 && array[j] > temp;j -= gap){
                array[j + gap] = array[j];
            }
            array[j + gap] = temp;
        }
    }    
}
shell排序也被称为缩小增量排序，是不稳定的排序。

       （5）归并排序：

          排序思想：其主要用到分治的思想，假设数组为a[ 8 ] = {3,2,5,9,0,7,4,6}，归并排序首先堆数组进行拆分，直到每个元素单独看成一个数组，然后进行合并，上述数组拆分到最后为 ：

3       2         5         9           0          7        4        6；

第一次合并的结果为：2  3  5  9  0  7  4  6

第二次合并的结果为：2  3  5  9  0  4  7  6

第三次合并的结果为：0  2  3  4  5  6  7  9

其代码实现如下：

static void merge_array(int *array,int left,int mid,int right,int *temp)
{
    int i = left;
    int j = mid + 1;
    int m = mid;
    int n = right;
    int k = 0;
    while(i <= m && j<= n){
        if(array[i] <= array[j]){
            temp[k++] = array[i++];
        }else{
            temp[k++] = array[j++];
        }
    }
    while(i <= m){
        temp[k++] = array[i++];
    }
    while(j <= n){
        temp[k++] = array[j++];
    }
    memcpy(array + left, temp,sizeof(int) * k);
}
static void Merge_sort(int *array,int left,int right,int *temp)
{
    int mid = -1;
    if(left < right){
        mid = (left + right) / 2;
        //拆分
        Merge_sort(array,left,mid,temp);
        Merge_sort(array,mid + 1,right,temp);
        //合并
        merge_array(array,left,mid,right,temp);
    }
}
void merge_sort(int *array,int length)
{
    int *temp = NULL;
    
    if(array == NULL || length < 2){
        return ;
    }
    temp = (int *)Malloc(sizeof(int) * length);
    Merge_sort(array,0,length - 1,temp);
    free(temp);
}

merge_array函数为合并过程，Merge_sort函数为拆分过程。

归并排序的时间复杂度为o(n * log 2^n)，归并排序为稳定的排序。

     （6）快速排序：

           排序思想：和归并排序的思想一样，用到分治的思想，

假设数组a[10] = { 12 , 3,  45 , 65 , 18 , 5 , 2 , 11 , 4}

第一次快排的具体情况如下：

         value = 12

把比12大的放在右边，比12的放在左边

12   3    45    65    18   5    2    11    4

i                                                        j              a[ j ]  < value

4    3    45    65    18    5    2    11    4

      i                                                  j               a[i]  < value 则 i++

4    3    45    65    18    5    2    11    4

             i                                           j               a[ i ]  >value 则 a[ j ] = a[ i ]

4    3    45    65    18    5    2    11    45

             i                                    j                       a[  j ]   <value 则 a[  i ] = a[ j ]

4    3    11    65    18    5    2    11    45

                     i                            j                       a[ i ]  >value 则 a[ j ] = a[ i ]

4    3    11    65    18    5    2    65    45

                     i                     j                               a[  j ]   <value 则 a[  i ] = a[ j ]

4    3    11    2    18      5    2    65    45

                            i              j                                a[ i ]  >value 则 a[ j ] = a[ i ]

4    3     11    2    18     5    18    65    45

                             i       j                                      a[  j ]   <value 则 a[  i ] = a[ j ]

4    3    11      2    5     5     18    65    45

                                    ij                                       a[  i  ] = value

4    3    11    2      5      12    18    65    45

接下来则分别左递归，右递归。

快排的代码实现如下：

void quick_sort(int *array,int left,int right)
{
    int i = left;
    int j = right;
    int value = array[left];
    if(left < right){
        while(i < j){
            for(;j > i && array[j] > value;j--);
            if(j > i){
                array[i++] = array[j];
            }
            for(;i < j && array[i] < value;++i);
            if(i < j){
                array[j--] = array[i];
            }
        }
        array[i] = value;
        quick_sort(array,left,i - 1);
        quick_sort(array,i + 1,right);
    }
}

还有一种实现如下： 

static int partition(int *array,int left,int right)
{
    int i = left - 1;
    int j = 0;
    int value = array[right];
    int temp = 0;
    for(j = left;j <= right - 1;++j){
        if(array[j] < value){
            i = i + 1;
            temp = array[i];
            array[i] = array[j];
            array[j] = temp;
        }
    }
    temp = array[i + 1];
    array[i + 1] = array[right];
    array[right] = temp;
    return i + 1;
    
}
void quick_sort1(int *array,int left,int right)
{
    int q = 0;
    if(left < right){
        q = partition(array,left,right);
        quick_sort1(array,left,q - 1);
        quick_sort1(array,q + 1,right);
    }
}

快排是一种不稳定的排序，其时间复杂度为o(n * log 2^n)，对于有一定的顺序的序列，其快排的效率会明显下降。

接下来我们来看shell、归并和快排的执行结果：

对于1亿个数据的，以上的三种排序消耗的时间如下：

      （7）计数排序：

          排序思想：计数排序可以看成是hash的一种应用，适合数据比较集中的序列，首先统计数组中元素出现的次数，然后在将其合并。

代码的实现如下：

void count_sort(int *array,int length,int min,int max)
{
    int *count = NULL;
    int c_size = max - min + 1;
    int i = 0;
    int j = 0;
    count = (int *)Malloc(sizeof(int) * c_size);
    bzero(count,sizeof(int) * c_size);
    for(i = 0; i < length;++i){
        count[array[i] - min]++;
    }
    for(i = 0,j = 0; i < c_size;){
        if(count[i]){
            array[j++] = i + min;
            count[i]--;
        }else{
            i++;
        }
    }
    free(count);
}
时间复杂度为o(n).

     (8)堆排序：

        堆排序思想：在之前的博客中也详细介绍了堆排序，大家可以进行参考，今天则不过多说明，主要将堆排序和其他几种排序进行比较；

    代码的实现：

void heap_sort(int *array,int length)
{
    int i = 0;
    int temp = 0;
    int n = length;
    build_max_heap(array,length);
    for(i = length;i >= 1;i--){
        temp = array[0];
        array[0] = array[i -1];
        array[i - 1] = temp;
        n--;
        Max_heapify(array,1,n);
    }
}
static int Left(int i)
{
    return 2 * i;
}
static int Right(int i)
{
    return 2 * i + 1;
}
static int Parent(int i)
{
    return i / 2;
}
static void Max_heapify(int *array,int i ,int length)
{
    int left = Left(i);
    int right = Right(i);
    int largest = 0;
    int temp = 0;
    if(left <= length && array[left - 1] > array[i - 1]){
        largest = left;
    }else{
        largest = i;
    }
    if(right <= length && array[right - 1] > array[largest - 1]){
        largest = right;
    } 
    if(largest != i){
        temp = array[i - 1];
        array[i - 1] = array[largest -1];
        array[largest - 1] = temp;
        Max_heapify(array,largest,length);
    }
}
void build_max_heap(int *array,int length)
{
    int i = 0;
    for(i = length / 2;i >= 1; i--){
        Max_heapify(array,i,length);
    }

 
}

对于以上的几种排序，其执行结果如下图：

接下来再来看其对时间的消耗：

   

由此看来，对于1亿的数据进行排序，计数排序的效率更高，计数排序适用于数据比较集中的序列，其次是快排，最慢的则是堆排。

接下来我们对于10亿个数据再进行测试：

由图得出还是计数排序的效率更高一些。

下面给出主程序的代码：

int main(int argc,char** argv)
{
    clock_t start = 0;
    clock_t end = 0;
    double use_time = 0;
    int *array1 = NULL;
    int *array2 = NULL;
    int *array3 = NULL;
    int *array4 = NULL; 
    int *array5 = NULL;
    int *array6 = NULL; 
    array1 = (int *)Malloc(sizeof(int) * SIZE);
    radom_array(array1,SIZE); 
    array2 = (int *)Malloc(sizeof(int) * SIZE);
    memcpy(array2,array1,sizeof(int) *SIZE);
    array3 = (int *)Malloc(sizeof(int) * SIZE);
    memcpy(array3,array1,sizeof(int) *SIZE);
    array4 = (int *)Malloc(sizeof(int) * SIZE);
    memcpy(array4,array1,sizeof(int) *SIZE);
    array5 = (int *)Malloc(sizeof(int) * SIZE);
    memcpy(array5,array1,sizeof(int) *SIZE);
    array6 = (int *)Malloc(sizeof(int) * SIZE);
    memcpy(array6,array1,sizeof(int) *SIZE);
    //序列1：
    #ifdef PRINT
    print_array(array1,SIZE);
    start = clock();
    //bubble_sort(array1,SIZE);
    quick_sort(array1,0,SIZE - 1);
    end = clock();
    printf("quicksort:\n");
    print_array(array1,SIZE);

    use_time = (double)(end - start) / CLOCKS_PER_SEC;
    printf("quick_sort use time:%lf\n",use_time);

    #else
    start = clock();
    quick_sort(array1,0,SIZE - 1);
    end = clock();

    use_time = (double)(end - start) / CLOCKS_PER_SEC;
    printf("quick_sort use time:%lf\n",use_time);
    #endif
    //序列2：
    #ifdef PRINT
    start = clock();
    //bubble_sort1(array2,SIZE);
    //insert_sort(array2,SIZE);
    merge_sort(array2,SIZE);
    end = clock();
    printf("merge_sort:\n");
    print_array(array2,SIZE);

    use_time = (double)(end - start) / CLOCKS_PER_SEC;
    printf("merge_sort use time:%lf\n",use_time);

    #else
    start = clock();
    //bubble_sort(array2,SIZE);
    //insert_sort(array2,SIZE);
    merge_sort(array2,SIZE);
    end = clock();

    use_time = (double)(end - start) / CLOCKS_PER_SEC;
    printf("merge_sort use time:%lf\n",use_time);
    #endif
    //序列3：
    #ifdef PRINT
    start = clock();
    //quick_sort1(array3,0,SIZE - 1);
    shell_sort(array3,SIZE);
    end = clock();
    printf("shell_sort:\n");
    print_array(array3,SIZE);

    use_time = (double)(end - start) / CLOCKS_PER_SEC;
    printf("shell_sort use time:%lf\n",use_time);

    #else
    start = clock();
    //quick_sort1(array3,0,SIZE - 1);
    shell_sort(array3,SIZE);
    end = clock();

    use_time = (double)(end - start) / CLOCKS_PER_SEC;
    printf("shell_sort use time:%lf\n",use_time);
    #endif
    //序列4：
    #ifdef PRINT
    start = clock();
    count_sort(array4,SIZE,0,MODE_SIZE);
    end = clock();
    printf("count_sort:\n");
    print_array(array4,SIZE);

    use_time = (double)(end - start) / CLOCKS_PER_SEC;
    printf("count_sort use time:%lf\n",use_time);

    #else
    start = clock();
    count_sort(array4,SIZE,0,MODE_SIZE);
    end = clock();

    use_time = (double)(end - start) / CLOCKS_PER_SEC;
    printf("count_sort use time:%lf\n",use_time);
    #endif
    #if 0
    //序列5：
    #ifdef PRINT
    start = clock();
    base_sort(array5,SIZE,0,MODE_SIZE);
    end = clock();
    printf("base_sort:\n");
    print_array(array5,SIZE);

    use_time = (double)(end - start) / CLOCKS_PER_SEC;
    printf("base_sort use time:%lf\n",use_time);

    #else
    start = clock();
    base_sort(array5,SIZE,0,MODE_SIZE);
    end = clock();

    use_time = (double)(end - start) / CLOCKS_PER_SEC;
    printf("base_sort use time:%lf\n",use_time);
    #endif
    #endif
    //序列6：
    #ifdef PRINT
    start = clock();
    heap_sort(array6,SIZE);
    end = clock();
    printf("heap_sort:\n");
    print_array(array6,SIZE);

    use_time = (double)(end - start) / CLOCKS_PER_SEC;
    printf("heap_sort use time:%lf\n",use_time);

    #else
    start = clock();
    heap_sort(array6,SIZE);
    end = clock();

    use_time = (double)(end - start) / CLOCKS_PER_SEC;
    printf("heap_sort use time:%lf\n",use_time);
    #endif
    return 0;
}


    还有一个排序为基数排序，将在下次的博客中和大家分享！！！

fantasy_linux
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
常见几种排序的思想
azhe12345690的博客
03-22 719
注意：下面排序都默认从小到大 1、直接插入排序 思想：让i从第二个数字开始往后走，j是i左边的第一个数字，然后把i的数字给tmp，比较j与tmp的大小，如果j大于tmp，就把j往后挪一个位置，然后j继续往左边走，知道j小于0，证明左边已经没有数字了，然后i继续往后走，在用上面的方法进行判断。最后要将tmp的值在赋给j+1的位置。 代码： for (int i = 1; i <array.length ; i++) { int j=i-1; int tmp=array[i]; for (;j>=0
几种排序算法思想
可为测控的机器视觉专栏
01-16 294
再对a[1]~a[n-1]以相同方法处理一轮，则a[n-1]的值一定是a[1]~a[n-1]中最大的。再将a[2]与a[3]~a[n]以相同方法比较一轮，则a[2]的值一定是a[2]~a[n]中最小的。首先比较b[1]与a[1]的值，若b[1]大于a[1]，则跳过，比较b[1]与a[2]的值，若b[1]仍然大于a[2]，则继续跳过，直到b[1]小于a数组中某一数据a[x]，则将a[x]~a[n]分别向后移动一位，将b[1]插入到原来a[x]的位置这就完成了b[1]的插入。b[2]~b[m]用相同方法插入。
整理各类排序思想（更新中）
Waimo的博客
05-02 185
冒泡排序:O(n^2) 冒泡排序是对一个序列进行n-1趟操作，每一趟从第一个元素到最后一个元素进行扫描，相邻元素逆序则交换，每一趟都可以将一个未排序部分的最大元素放在未排序部分最后一位，使已排序序列长度+1。 代码： void Bubblesort(int a[],int n){ for(int i=0;i<n-1;i++) for(int j=0;j<n-2;j++) i...
各种排序的思想和代码
weixin_45177251的博客
01-02 91
插入类排序 1. 直接插入排序（稳定排序）------时间复杂度（O（n2）），空间复杂度（O（1）） 思想： 将第i个记录 插入到前面i-1个已经排好序列的记录中。直到所有的记录全部插入为止。 具体操作：将第i个记录的关键字Ki,顺次与其前面记录的关键字Ki-1,Ki-2 ....K1，进行比较。将所有关键字大于Ki的记录依次往后移动，直到遇见一个关键字小于 或等于Ki的关键字Kj,...
各种排序思想
寻寻觅觅的专栏
10-10 380
1、插入排序（对应有个希尔排序） 将一个记录插入到已排序好的有序表中，从而得到一个新，记录数增1的有序表。即：先将序列的第1个记录看成是一个有序的子序列，然后从第2个记录逐个进行插入，直至整个序列有序为止。 核心代码void InsertSort(int a[], int n) { for(int i= 1; i<n; i++){ if(a[i] < a[i
C#实现各种排序算法.zip
10-10
本资料“C#实现各种排序算法.zip”聚焦于使用C#语言实现多种常见的排序算法，这对于我们理解和优化代码性能至关重要。下面将详细介绍这些排序算法及其C#实现。 1. 冒泡排序（Bubble Sort） 冒泡排序是最基础的排序...
js的各种排序算法实现(总结)
10-21
快速排序是高效的排序算法，其核心思想是分治法。它选取一个基准元素，将数组分为两部分，一部分所有元素小于基准，另一部分所有元素大于基准，然后对这两部分再进行同样的操作，直到所有元素都在正确的位置。`...
归并排序思想实现外部排序
09-27
https://blog.csdn.net/apple_50661801/article/details/125922092 源代码
C++实现各种排序算法类汇总
09-04
C++实现各种排序算法类汇总 C++实现各种排序算法类是一种常用的算法实现方式，旨在提供多种排序算法的实现代码，以便开发者可以根据实际情况选择合适的排序算法。下面是对该实现的详细介绍： 一、直接插入排序 ...
C语言实现堆排序.zip
最新发布
01-18
在计算机科学中，排序是数据处理的一个重要环节，而堆排序是一种高效的排序算法，尤其适用于大规模数据处理。本文将深入探讨C语言如何...总的来说，掌握堆排序算法和C语言的实现，对于理解和优化算法性能具有重要意义。
各种排序算法思想
用可见的方式来记录和分享每一次收获
10-21 343
快速排序 主要思想: 主要是基于分治。(分治解读) 基本步骤: 1.确定分界点x ，常用方式q[l] q[l + r >> 1] , q[r] , 左右部分未必长度相等 2.根据分界点x调整区间，使得满足小于等于x的在左边，大于等于x的在右边 3.左右两端，递归缩小规模处理，然后进行拼接，即两个区间合并 // 快速排序算法模板 void quick_sort(int q[], int l, int r) { if (l >= r) return; .
各种排序算法思想总结
bpj27bpj的博客
12-23 244
1.选择排序   每次都找到应该在该位置的数,然后把该数移动到它应该在的位置   程序:   public static void selectedSort(int[] a){           int N=a.length;           for(int i=0;i               for(int j=i+1;j                  if(a[j]
八大排序算法实战：思想与实现
热门推荐
Rico's Blogs
05-25 1万+
所谓排序，就是根据排序码的递增或者递减顺序把数据元素依次排列起来，使一组任意排列的元素变为一组按其排序码线性有序的元素。本文将介绍八种最为经典常用的内部排序算法的基本思想与实现，包括插入排序(直接插入排序，希尔排序)、选择排序(直接选择排序，堆排序)、交换排序(冒泡排序，快速排序)、归并排序、分配排序(基数排序)，并给出各种算法的时间复杂度、空间复杂度和稳定性。
常用排序算法思想
helloworld
08-19 569
桶排序、冒泡排序、快速排序、插入排序、选择排序 的图解及代码实现
常见的几种排序算法思想与代码实现
a597637246的博客
09-28 154
插入类排序 直接插入排序 将一个无序序列从第一个开始插入到一个有序序列（或者说插入到这个无序序列的前面）。即：将a[1]位置不变，a[2]与a[1]比较，若小于a[1]，则插入到a[1]前方，a[1]往后放。再将a[3]与a[1]a[2]比较，插入到合适地方，被后面插入元素取代的元素往后移动，以此类推。 待排序记录 R1，R2，… ，Rn–1, Rn 第一步：R1 第二步：...
排序的思想总结和题解
qq_62745420的博客
06-03 161
1464. 数组中两元素的最大乘积 1636. 按照频率将数组升序排序 1287. 有序数组中出现次数超过25%的元素 436. 寻找右区间
快速排序算法思想及实现
u014507784的博客
05-05 5681
欢迎使用Markdown编辑器写博客本Markdown编辑器使用StackEdit修改而来，用它写博客，将会带来全新的体验哦： Markdown和扩展Markdown简洁的语法 代码块高亮 图片链接和图片上传 LaTex数学公式 UML序列图和流程图 离线写博客 导入导出Markdown文件 丰富的快捷键 快捷键 加粗 Ctrl + B 斜体 Ctrl + I 引用 Ctrl
几种常见的排序思想
buki26的博客
07-13 3191
本文只记录排序思想和图解，没有贴相应代码。
图解数据结构（10）——排序
weixin_34409741的博客
06-28 299
十四、排序（Sort）这可能是最有趣的一节。排序的考题，在各大公司的笔试里最喜欢出了，但我看多数考得都很简单，通常懂得冒泡排序就差不多了，确实，我在刚学数据机构时候，觉得冒泡排序真的很“精妙”，我怎么就想不出呢？呵呵，其实冒泡通常是效率最差的排序算法，差多少？请看本文，你一定不会后悔的。1、冒泡排序（Bubbler Sort）前面刚说了冒泡排序的坏话，但冒泡排序也有其优点，那就是好理解，稳定，再就...
归并排序详解：选择排序实现与比较
归并排序的主算法是一种高效的排序方法，它结合了选择排序和归并操作。选择排序（包括直接选择排序）是基础，其核心思想是每次从未...通过将选择排序的简单思想和归并操作相结合，归并排序实现了高效且稳定的排序效果。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值