八大排序算法

最新推荐文章于 2024-06-20 23:50:49 发布
最新推荐文章于 2024-06-20 23:50:49 发布
阅读量725 收藏 4
点赞数 1
分类专栏： C++面试

前言

不管是提高自身的能力，还是面试，八大排序都是很重要的一个知识点，所以理解并实践实现是很有必要的，以下给出算法思想与代码实现，并且进行运行时间测试八大排序的效率。

时间复杂度对比图

先看下对于算法时间复杂度的对比： 
这里写图片描述

冒泡排序

冒泡排序是一种简单的排序算法。主要思想是顺序的比较相邻的两个数，如果符合比较条件就替换两个数，做法可以从后往前推，也可以从前往后推，每次推出当前长度的最大值，直至最后便可以完整的排序。

时间复杂度为 : O(n*n);

#include<time.h>
#include <stdio.h>
#include <stdlib.h>
#define N 10000
#define MAX 100000000
//冒泡
void bubbleSort(int arr[],int n){
   int temp;
   for(int i=0;i < n-1;++i){

    for(int j=n-1;j>i;--j){
        if(arr[j]<arr[j-1]){
            temp = arr[j];
            arr[j] = arr[j-1];
            arr[j-1] = temp;
        }
     }
   }
}

//判断是否排序
bool isSorted(int arr[],int n){
    bool flag = true;
    for(int i=0;i<n-1;++i){
        if(arr[i+1]<arr[i]){
            flag = false;
            break;
        }
    }
    return flag;
}

int arr[N];

int main()
{
    //随机播种
    srand((unsigned)time(NULL));
    for(int i =0;i < N;++i ){
        arr[i] =  rand()% MAX;
    }


    clock_t start_time=clock();
    {
        bubbleSort(arr,N);
    }

   clock_t end_time=clock();
    printf("Running time is: %lfms\n",static_cast<double>(end_time-start_time)/CLOCKS_PER_SEC*1000);
    printf("%s",isSorted(arr,N) == true ? "true":"false");
    printf("\n");
    return 0;
}

用10000个数进行测试： 
这里写图片描述
运行时间为279ms 
不要觉得很快这才一万的数据，再加两个0，就听几首歌慢慢等吧 
冒泡有改进的方法是如果在比较相邻数的过程中都没交换过一次，说明后面的数已经排好序，可以直接跳出循环。

选择排序

思想：设当前位置为i，每次从i+1到n的数中选择最大（从大到小）或最小（从小到大）后，与位置i的值进行条件比较，符合条件则调换。

**时间复杂度为:**O（n*n）

#include<time.h>
#include <stdio.h>
#include <stdlib.h>
#define N 10000
#define MAX 100000000

//选择排序
void chioseSort(int arr[],int n){
   int temp,index;
   for(int i=0;i < n-1;++i){
        index = i;
        for(int j=i+1;j<n;++j){
           if(arr[j]<arr[index])
            index = j;
         }
         if(index!=i){
            temp = arr[i];
            arr[i] = arr[index];
            arr[index] = temp;
        }
   }
}

//判断是否排序
bool isSorted(int arr[],int n){
    bool flag = true;
    for(int i=0;i<n-1;++i){
        if(arr[i+1]<arr[i]){
            flag = false;
            break;
        }
    }
    return flag;
}

int arr[N];

int main()
{
    srand((unsigned)time(NULL));
    for(int i =0;i < N;++i ){
        arr[i] =  rand()% MAX;
    }


    clock_t start_time=clock();
    {

        chioseSort(arr,N);
    }

   clock_t end_time=clock();
    printf("Running time is: %lfms\n",static_cast<double>(end_time-start_time)/CLOCKS_PER_SEC*1000);
    printf("%s",isSorted(arr,N) == true ? "true":"false");
    printf("\n");
    return 0;
}

用10000个数进行测试： 
这里写图片描述
运行时间为141ms 
可以发现比冒泡速度更快点，主要原因是选择不需要每次都进行替换，只在最后一次再对比替换。

直接插入排序

思想：设当前位置为i,记录当前i的值为value,每次从i到0推，在推的过程中比较value的值，符合比较条件的值向后移，直至不符合条件时推结束，然后再将之前记录的value赋给不符和条件索引下标的后一个。 
动画演示： 
这里写图片描述

**时间复杂度：**O(n*n)

#include<time.h>
#include <stdio.h>
#include <stdlib.h>
#define N 10000
#define MAX 100000000
//插入排序
void insertSort(int arr[], int len)
{
    int i, j, key;
    for(i = 1; i < len; ++i){
        key = arr[i];
        for(j = i-1; j >=0; --j){
            if(arr[j] > key)
                arr[j+1] = arr[j];
            else
                break;
        }
        arr[j+1] = key;
    }
}

//判断是否排序
bool isSorted(int arr[],int n){
    bool flag = true;
    for(int i=0;i<n-1;++i){
        if(arr[i+1]<arr[i]){
            flag = false;
            break;
        }
    }
    return flag;
}

int arr[N];

int main()
{
    srand((unsigned)time(NULL));
    for(int i =0;i < N;++i ){
        arr[i] =  rand()% MAX;
    }


    clock_t start_time=clock();
    {
      //  bubbleSort(arr,N);
       // chioseSort(arr,N);
        insertSort(arr,N);
    }

   clock_t end_time=clock();
    printf("Running time is: %lfms\n",static_cast<double>(end_time-start_time)/CLOCKS_PER_SEC*1000);
    printf("%s",isSorted(arr,N) == true ? "true":"false");
    printf("\n");
    return 0;
}

用10000个数进行测试： 
这里写图片描述
用时75ms 
可以发现比以上两种都快，原因主要是插入排序没有用到交换，而是直接赋值，交换两个数要3步，直接赋值只要1步，在数据的大情况下就差了2倍。

快速排序

思想：将一个复杂的问题划分为两部分，递归。每次在当前部分的数组中任取一个值value，重排数组（从小到大来说）将比value小的放左边，比value大的放右边，递归划分后得到的就是一个排完序的。

图片演示： 
这里写图片描述

时间复杂度：O（n*logn）; 
特殊情况下(已经排好序的)：O（n*n）;

#include<time.h>
#include <stdio.h>
#include <stdlib.h>
#define N 10000
#define MAX 100000000
void swap(int *a,int *b){
    int temp = *a;
    *a = *b;
    *b = temp;
}

int partition(int arr[], int start, int end){

    swap(&arr[start],&arr[end]);
    int value = arr[end];
    int index = start;
    for(int i=start;i<end;++i){
        if(arr[i]< value){
            swap(&arr[index++],&arr[i]);
        }
    }
    swap(&arr[index],&arr[end]);
    return index;
}

void quickSort(int arr[],int start,int end){

    if(end>start){
        int index = partition(arr,start,end);
        quickSort(arr, start,index-1);
        quickSort(arr, index+1,end);
    }

}

//判断是否排序
bool isSorted(int arr[],int n){
    bool flag = true;
    for(int i=0;i<n-1;++i){
        if(arr[i+1]<arr[i]){
            flag = false;
            break;
        }
    }
    return flag;
}

int arr[N];

int main()
{
    srand((unsigned)time(NULL));
    for(int i =0;i < N;++i ){
        arr[i] =  rand()% MAX;
    }


    clock_t start_time=clock();
    {
        quickSort(arr,0,N-1);
    }

   clock_t end_time=clock();
    printf("Running time is: %lfms\n",static_cast<double>(end_time-start_time)/CLOCKS_PER_SEC*1000);
    printf("%s",isSorted(arr,N) == true ? "true":"false");
    printf("\n");
//    for(int i=0;i<N;++i){
//       printf("%d ",arr[i]);
//    }
    return 0;
}

这里写图片描述
同样10000数据 
只用了1ms 
可知与以上的方法相比快了很多很多。

堆排序

二叉堆的定义

  • 二叉堆是完全二叉树或者是近似完全二叉树。
  • 二叉堆满足二个特性： 
    1．父结点的键值总是大于或等于（小于或等于）任何一个子节点的键值。 
    2．每个结点的左子树和右子树都是一个二叉堆（都是最大堆或最小堆）。

当父结点的键值总是大于或等于任何一个子节点的键值时为最大堆。当父结点的键值总是小于或等于任何一个子节点的键值时为最小堆。下图展示一个最小堆：

这里写图片描述 
堆的存储 
一般都用数组来表示堆，i结点的父结点下标就为(i – 1) / 2。它的左右子结点下标分别为2 * i + 1和2 * i + 2。如第0个结点左右子结点下标分别为1和2。 
这里写图片描述 
堆的操作——插入删除

这里写图片描述

堆的插入 
每次插入都是将新数据放在数组最后。可以发现从这个新数据的父结点到根结点必然为一个有序的数列

//  新加入i结点  其父结点为(i - 1) / 2  
void MinHeapFixup(int a[], int i)  
{  
    int j, temp;  

    temp = a[i];  
    j = (i - 1) / 2;      //父结点  
    while (j >= 0 && i != 0)  
    {  
        if (a[j] <= temp)  
            break;  

        a[i] = a[j];     //把较大的子结点往下移动,替换它的子结点  
        i = j;  
        j = (i - 1) / 2;  
    }  
    a[i] = temp;  
}

更简短的表达为：

void MinHeapFixup(int a[], int i)  
{  
    for (int j = (i - 1) / 2; (j >= 0 && i != 0)&& a[i] > a[j]; i = j, j = (i - 1) / 2)  
        Swap(a[i], a[j]);  
}

堆的删除 
按定义，堆中每次都只能删除第0个数据。为了便于重建堆，实际的操作是将最后一个数据的值赋给根结点，然后再从根结点开始进行一次从上向下的调整。调整时先在左右儿子结点中找最小的，如果父结点比这个最小的子结点还小说明不需要调整了，反之将父结点和它交换后再考虑后面的结点。相当于从根结点将一个数据的“下沉”过程。下面给出代码：

//  从i节点开始调整,n为节点总数 从0开始计算 i节点的子节点为 2*i+1, 2*i+2  
void MinHeapFixdown(int a[], int i, int n)  
{  
    int j, temp;  

    temp = a[i];  
    j = 2 * i + 1;  
    while (j < n)  
    {  
        if (j + 1 < n && a[j + 1] < a[j]) //在左右孩子中找最小的  
            j++;  

        if (a[j] >= temp)  
            break;  

        a[i] = a[j];     //把较小的子结点往上移动,替换它的父结点  
        i = j;  
        j = 2 * i + 1;  
    }  
    a[i] = temp;  
}  
//在最小堆中删除数  
void MinHeapDeleteNumber(int a[], int n)  
{  
    Swap(a[0], a[n - 1]);  
    MinHeapFixdown(a, 0, n - 1);  
}

堆排序的两大步骤： 
1. 建立初始化堆 
2. 每次选取堆定元素进行排序 
建立初始化堆 
有了堆的插入和删除后，再考虑下如何对一个数据进行堆化操作。要一个一个的从数组中取出数据来建立堆吧，不用！先看一个数组，如下图： 
这里写图片描述

很明显，对叶子结点来说，可以认为它已经是一个合法的堆了即20，60， 65， 4， 49都分别是一个合法的堆。只要从A[4]=50开始向下调整就可以了。然后再取A[3]=30，A[2] = 17，A[1] = 12，A[0] = 9分别作一次向下调整操作就可以了。下图展示了这些步骤：

这里写图片描述

写出堆化数组的代码：

//  从i节点开始调整,n为节点总数 从0开始计算 i节点的子节点为 2*i+1, 2*i+2  
void MinHeapFixdown(int a[], int i, int n)  
{  
    int j, temp;  

    temp = a[i];  
    j = 2 * i + 1;  
    while (j < n)  
    {  
        if (j + 1 < n && a[j + 1] < a[j]) //在左右孩子中找最小的  
            j++;  

        if (a[j] >= temp)  
            break;  

        a[i] = a[j];     //把较小的子结点往上移动,替换它的父结点  
        i = j;  
        j = 2 * i + 1;  
    }  
    a[i] = temp;  
} 
//建立最小堆  
void MakeMinHeap(int a[], int n)  
{  
    for (int i = n/ 2 -1 ; i >= 0; i--)  
        MinHeapFixdown(a, i, n);  
}

每次选取堆定元素进行排序 
首先可以看到堆建好之后堆中第0个数据是堆中最小的数据。取出这个数据再执行下堆的删除操作。这样堆中第0个数据又是堆中最小的数据，重复上述步骤直至堆中只有一个数据时就直接取出这个数据。

由于堆也是用数组模拟的，故堆化数组后，第一次将A[0]与A[n - 1]交换，再对A[0…n-2]重新恢复堆。第二次将A[0]与A[n – 2]交换，再对A[0…n - 3]重新恢复堆，重复这样的操作直到A[0]与A[1]交换。由于每次都是将最小的数据并入到后面的有序区间，故操作完成后整个数组就有序了。

void MinheapsortTodescendarray(int a[], int n)  
{  
    for (int i = n - 1; i >= 1; i--)  
    {  
        Swap(a[i], a[0]);  
        MinHeapFixdown(a, 0, i);  
    }  
}

注意使用最小堆排序后是递减数组，要得到递增数组，可以使用最大堆。

时间复杂度为：O(n*logn)

#include<time.h>
#include <stdio.h>
#include <stdlib.h>
#define N 10000000
#define MAX 100000000

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


//判断是否排序
bool isSorted(int arr[],int n){
    bool flag = true;
    for(int i=0;i<n-1;++i){
        if(arr[i+1]<arr[i]){
            flag = false;
            break;
        }
    }
    return flag;
}


//----------------

//堆排序
//调整堆
void adjustHeap(int arr[],int index,int lenght){

    int l = index*2+1;
    int n = lenght;
    int temp = arr[index];
    while(l<n){

        if((l+1)<n&&arr[l+1]>arr[l])
            l++;
        if(arr[l] <= temp)
            break;
        arr[index] = arr[l];
        index = l;
        l = index*2+1;
    }

    arr[index] = temp;
}

//新建堆
void buildHeap(int arr[],int n){

    for(int i = n/2 -1;i>=0;--i){
        adjustHeap(arr,i,n);
    }
}

void heapSort(int arr[],int  n){

    buildHeap(arr,n);

    for(int i = n-1;i>0;--i){
        swap(&arr[0],&arr[i]);
        adjustHeap(arr,0,i);
    }
}


//----------------------

int arr[N];

int main()
{
    srand((unsigned)time(NULL));
    for(int i =0;i < N;++i ){
        arr[i] =  rand()% MAX;
    }


    clock_t start_time=clock();
    {
      //  bubbleSort(arr,N);
       // chioseSort(arr,N);
        //insertSort(arr,N);
       // quickSort(arr,0,N-1);
        heapSort(arr,N);
    }

   clock_t end_time=clock();
    printf("Running time is: %lfms\n",static_cast<double>(end_time-start_time)/CLOCKS_PER_SEC*1000);
    printf("%s",isSorted(arr,N) == true ? "true":"false");
    printf("\n");
//    for(int i=0;i<N;++i){
//       printf("%d ",arr[i]);
//    }
    return 0;
}

排序1000万数据： 
这里写图片描述
运行速度为4096ms

用快排排序1000万数据： 
这里写图片描述
运行速度为6381ms

可知在数据特别大的情况下堆排序的效率会比快排更好

希尔排序

略，笔者暂时没有研究希尔排序

归并排序

思想:所谓归并就是用了分治的算法思想（将一个大的问题划分为n个小问题，再用小问题得出的结果，解决大问题），主要思想就是将两个已经排好序的数组合并，最后这个数组就是有序的。 
主要有两大步骤： 
1. 先递归分解 
2. 再递归合并 
分解 
一般采取二分的方法：将一个数组分为两部分，自顶向下分解 
这里写图片描述

合并： 
当全都分解完后，开始递归合并，自底向上合并 
这里写图片描述

所以先了解下合并两数组: 
将两个已经排好序的合并成一个排序数组

//辅助数组
 int temp[N];
//-----------------------
void combineArr(int arrL[],int ln,int arrR[],int rn){

    int i = 0;
    int j = 0;
    int k=0;
    while(i<ln&&j<rn){

        if(arrL[i]<=arrR[j]){
            temp[k++] = arrL[i++];
        }else{
            temp[k++] = arrR[j++];
        }
    }
    while(i<ln){
        temp[k++] = arrL[i++];
    }

    while(j<rn){
        temp[k++] = arrR[j++];
    }

    for(int i = 0;i<k;++i){
        arrL[i] = temp[i];
    }
}

 

这里写图片描述
1000万数据，运行时速度为2642ms

时间复杂度为:O(n*logn)

可知归并排序比快排，堆排序都快，并且稳定。

基数排序（桶排序）

基数排序是一种特殊的排序，它并不是通过比较数组中的数值进行排序，而是用了很特殊的方法：通过一个二维数组，每次根据进行位数入桶，最后按顺序遍历这二维数组，便可得出一个排好序的数组。

口诉太抽象了，下面用图解释：

这里写图片描述

时间近似复杂度为：O（n）

#include<time.h>
#include <stdio.h>
#include <stdlib.h>
#define N 10000000
#define MAX 100000000


//------------基数排序
//辅助数组
int temps[10][N];
//获取最大位数的位置 如8->1 , 17->2,7832->4 
int getMexExp(int arr[],int n){

    int maxN = arr[0];
    for(int i=1;i<n;++i){
        maxN = arr[i]>maxN?arr[i]:maxN;
    }
    int exps = 1;
    maxN = maxN/10;
    while(maxN!=0){
        maxN = maxN/10;
        exps++;
    }
    return exps;
}
//基数排序
void radixSort(int arr[],int n){
    //存每个桶中数的个数
    int countIndex[10] = {0};
    int exps = getMexExp(arr,n);
    int exp = 1;
    for(int e=0;e<exps;++e){
        //入桶
        for(int i=0;i<n;++i){
            int index = (arr[i]/exp)%10;
            temps[index][countIndex[index]++] = arr[i];
        }

        //取值，改变数组
        int k=0;
        for(int i=0;i<10;++i){
            //如果桶中数的个数大于0
            if(countIndex[i]>0){
                int n  = countIndex[i];
                //将数取出，改变数组
                for(int j =0;j<n;++j){
                    arr[k++] = temps[i][j];
                }
            }

        }
        //将桶中的数的个数重置为0
        for(int i=0;i<10;++i)
            countIndex[i] = 0;
        //位数改变
        exp *=10;
    }

}



//--------------------

int arr[N];

int main()
{
    srand((unsigned)time(NULL));
    for(int i =0;i < N;++i ){
        arr[i] =  rand()% MAX;
    }


    clock_t start_time=clock();
    {
      //  bubbleSort(arr,N);
       // chioseSort(arr,N);
        //insertSort(arr,N);
     //   quickSort(arr,0,N-1);
        //heapSort(arr,N);
       // conflationSort(arr,0,N-1);
        radixSort(arr,N);
    }

   clock_t end_time=clock();
    printf("Running time is: %lfms\n",static_cast<double>(end_time-start_time)/CLOCKS_PER_SEC*1000);
    printf("%s",isSorted(arr,N) == true ? "true":"false");
    printf("\n");
//    for(int i=0;i<N;++i){
//       printf("%d ",arr[i]);
//    }
    return 0;
}

这里写图片描述
1000万数据,运行用时只用了941ms, 
基数排序会占用比较大的空间，网上还有空间压缩的方法可参照：http://www.cnblogs.com/skywang12345/p/3603669.html

可知：基数排序的效率比以上所有排序速度都快(在数特别多的情况下，如果位数k,桶数10，k*10>n（数组个数），就不用基数排序了)

总结

这里写图片描述

参考文献： http://blog.csdn.net/morewindows/article/details/6709644/

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qq_24028753/article/details/75108075

文章标签： 排序算法算法测试面试

个人分类： 算法

找个特立不独行的名
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
各种排序法
12-07
用随机数产生100000个待排序数据元素的关键字值。测试下列各排序函数的机器实际执行时间（至少测试两个）：直接插入排序、希尔排序（增量为4，2，1）、冒泡排序、快速排序、直接选择排序、二路归并排序、堆排序和基于链式队列的基数排序。
八大排序算法-及运行时间测试
热门推荐
在下李逍遥的博客
07-16 1万+
不管是提高自身的能力，还是面试，八大排序都是很重要的一个知识点，所以理解并实践实现是很有必要的，以下给出算法思想与代码实现，并且进行运行时间测试八大排序的效率。
八大经典排序算法
2302_78381559的博客
06-20 1442
深入探讨了八大排序算法——冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序、以及我们刚刚详析的计数排序之后，我们不仅掌握了一系列解决排序问题的有效策略，更深刻理解了算法设计背后的逻辑与权衡。每种算法，如同八音盒中的音符，各有其独特的旋律与应用场景，它们共同编织了计算机科学领域中关于“排序”这一基本问题的华丽乐章。数据结构-堆(带图)详解-CSDN博客。栈（Stack）是一种基本的数据结构，其特点是只允许在同一端进行插入和删除操作，这一端被称为栈顶。
统计各排序算法运行的时间
看，好自为之的博客！！！
03-08 2133
学习内容： 编写 java 程序，随机产生N个数（N>30000），分别使用插入排序、合并排序、冒泡排序对其进行排序，比较各种排序所用的时间。要求统计每个算法的运行时间，输出排序后的前20个数。 源代码： import java.util.Calendar; public class MySort_hw { static int n = 30000; public static void main(String[] args) { int[] A = new
八种排序算法的运行时间比较（附代码）
qq_36070644的博客
02-18 4886
算法的运行时间与cpu的性能相关，且存在误差，运行时长会有波动。 /* */
各种排序算法
ertcmmy的博客
11-13 169
快速排序 void quick_sort(int a[], int l, int h){ if(l >= h) return; int i = l, j = h; int tmp = a[l]; while(i < j){ while(i < j && a[j] >= tmp) // 若和以下写a[j] > tmp和a[i] ...
Python实现八大排序算法
01-20
如何用Python实现八大排序算法 1、插入排序 描述 插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为 O(n^2)。是稳定...
C语言实现八大排序算法合集
最新发布
07-20
c语言
Java实现八大排序算法
09-18
在这里，我们将深入探讨Java实现的八大排序算法，包括冒泡排序、选择排序、插入排序、希尔排序、快速排序、归并排序、堆排序以及计数排序。 1. **冒泡排序（Bubble Sort）**：冒泡排序是一种简单直观的排序算法，...
黄海安-八大排序算法总结
03-31
**八大排序算法详解** 在计算机科学中，排序算法是用于对一组数据进行排列的算法，它们在编程中扮演着至关重要的角色。以下是黄海安总结的八大经典排序算法的详细介绍： 1. **冒泡排序（Bubble Sort）** 冒泡排序...
求各种排序算法的执行时间（C++）
12-26
随机产生n个1~99的正整数序列，分别采用直接插入排序、折半插入排序、希尔排序、冒泡排序、快速排序、直接选择排序、堆排序和二路归并排序对其进行递增排序
C++常见八大排序算法
01-24
本文将详细介绍在C++中实现的八大排序算法，以及如何在Visual Studio 2017环境下进行编写。 首先，让我们来逐一了解这八大排序算法： 1. **冒泡排序**：这是一种简单的排序方法，通过重复遍历待排序的数列，一次...
python八大排序算法速度实例对比
09-21
### Python八大排序算法速度实例对比 #### 排序算法概览 本文主要通过实例的方式对Python中的八大排序算法进行了速度对比。这些算法分别是：直接插入排序、希尔排序、简单选择排序、堆排序、冒泡排序、快速排序、...
八大排序算法的Python实现
12-23
以下是八大排序算法在Python中的实现详解： 1. **插入排序**： 插入排序是一种简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。其时间...
必须知道的C语言八大排序算法(收藏)
08-29
八大排序算法 Sorting algorithms are essential in computer science and programming, and C language is no exception. In this article, we will introduce eight sorting algorithms in C language, which ...
【数据结构课程设计】数据可视化-各种排序算法绝对执行时间（代码1431行含设计文档）
qq_52878933的博客
07-05 1297
本设计涉及到对数据的随机初始化、数据的处理与可视化，文件的存取、求解11种排序方法的绝对执行时间、动态内存分配、C语言外库EasyX外库的使用。可移植性强、界面美观、初具小型系统雏形，是一份值得借鉴与学习的课程设计。欢迎感兴趣的朋友交流学习~贴一下本人的微信：UNIQKrisTien，添加请说明来意（如CSDN）。......
几种常见排序算法的实现及运行时间对比
weixin_40522938的博客
12-09 1213
// 冒泡排序 function popSort(arr) { if (arr.length < 2) return arr; let n = arr.length; while (n > 1) { let exchanged = false; for (let i = 0; i < n - 1; i++) { if (arr[i] > arr[i + 1]) { exc.
排序算法九：基数排序
爱吃芒果的薯条 的博客
04-29 146
基数排序代码main.cpp 代码 main.cpp #include <iostream> #include <list> using namespace std; void RadixSort(int data[],int n); int Maxdigit(int data[],int n); int main() { cout<<"RadixSort...
C++编程：八大排序算法详解与实现
"这篇资源主要介绍了C++编程中的八大排序算法，包括插入排序、希尔排序以及交换排序的两种方法——冒泡排序和快速排序。这些排序算法是编程基础中的重要部分，适合初学者学习和实践。资源提供了具体的代码实现，方便...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值