排序算法实现原理

最新推荐文章于 2022-12-09 11:32:42 发布
最新推荐文章于 2022-12-09 11:32:42 发布
阅读量387 收藏
点赞数 2
分类专栏： 理论知识 acm指南 文章标签： 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xielinrui123/article/details/81506146
版权

说排序算法之前，先说一下交换的方法

常见的交换方法
int tmp = a ;
a = b;
b = tmp

不需要额外存储空间的交换方法

a = a + b;
b = a - b;//a+b-b=a
a = a - b;//a+b-a=b
排序方法

1、冒泡排序

for(int i=9999;i>=1;i--){
    for(int j=0;j<i;j++){
        if(a[j]>a[j+1]){
            int tmp = a[j+1];
            a[j+1] = a[j];
            a[j] = tmp; 
        }
    }
}

算法本质就是不断地对某个位置前面的每一个地方进行两两比较，确保j+1的位置比j的位置的大。从而确保i位置比他前面的都大。
可以引入一个常数级的优化，就是交换的时候做一个标记，如果一趟循环下来没有发生过标记，那么直接终止循环即可。

for(int i=9999;i>=1;i--){
    int flag=0;
    for(int j=0;j<i;j++){
        if(a[j]>a[j+1]){
            int tmp = a[j+1];
            a[j+1] = a[j];
            a[j] = tmp; 
            flag=1;
        }
    }
    if(flag==0)break;
}

处理1e4的数据耗时0.254秒
2、选择排序

for(int i=0;i<9999;i++){
    for(int j=i+1;j<9999;j++){
        if(a[i]>a[j]){
            a[i] = a[i]+a[j];
            a[j] = a[i]-a[j];
            a[i] = a[i]-a[j];
        }
    }
}

从第一个位置开始每次都找最小的那一个值放到该位置
耗时0.35秒
3、插入排序

for(int i=1;i<9999;i++){
    for(int j=i;j>0;j--){
        if(a[j]<a[j-1]){
            a[j] = a[j] + a[j-1];
            a[j-1] = a[j] - a[j-1];
            a[j] = a[j] - a[j-1];
        }
    }
}

从第二个位置开始，对它前面的值进行比较，如果前一个值比后一个值大，就交换
4、希尔排序

int increment = 10000;
while(increment>1){
    increment = increment/3 + 1;
    int d = increment;
    for(int i=d+1;i<=10000;i++){
        if(a[i]<a[i-d]){
            a[0] = a[i];
            int j = i-d;
            do{
                a[j+d] = a[j];
                j = j-d;
            }while(j>0&&a[0]<a[j]);
            a[j+d] = a[0];
        }
    }
}

耗时0.001秒，效率非常高

5、二分排序

int l,r,mid;
int tmp;
for(int i=1;i<10000;i++){
    tmp = a[i];
    l = 0;
    r = i - 1;
    while(l<=r){
        mid = (l+r)/2;
        if(a[mid]>tmp){
            r = mid - 1;
        }else{
            l = mid + 1;
        }
    }
    for(int j=i-1;j>r;j--){
            a[j+1] = a[j];
        }
    a[r+1] = tmp;
}

0.062秒

6、快速排序

void Quicksort(int l,int r){
    int i,j,x;
    if(l<r){
        i = l;
        j = r;
        x = a[i];
        while(i<j){
            while(i<j&&a[j]>x){
                j--;
            }
            if(i<j){
                a[i] = a[j];
                i++;
            }
            while(i<j&&a[i]<x){
                i++;
            }
            if(i<j){
                a[j] = a[i];
                j--;
            }
        }
        a[i] = x;
        Quicksort(l,i-1);
        Quicksort(i+1,r);
    }
}

1e4跑了0.001秒，1e5跑了0.011秒，1e6跑了0.122秒，1e7跑了1.262秒

核心思想就是找到基准点所在的位置
7、归并排序

void Mergesort(int l,int r){
    if(l<r){
        int mid = (l+r)/2;
        Mergesort(l,mid);
        Mergesort(mid+1,r);
        int i = l;
        int j = mid+1;
        int k = 0;
        int tmp[r-l+1];
        memset(tmp,0,sizeof tmp);
        while(i<=mid&&j<=r){
            if(a[i]>a[j]){
                tmp[k++] = a[j++];
            }else{
                tmp[k++] = a[i++];
            }
        }
        while(i<=mid){
            tmp[k++] = a[i++];
        }
        while(j<=r){
            tmp[k++] = a[j++];
        }
        int n = k;
        k = l;
        for(int ii=0;ii<n;ii++){
            a[k++] = tmp[ii];
        }
    }
}

1e4跑了0.001秒，1e5跑了0.017秒，1e6没结果
思想中有个核心的点就是在合并的时候，会有两个指针来指向两个数组的当前首部

8、基数排序

void radixSort(){
    int exp;
    int mx = -1;
    for(int i=0;i<100000;i++){
        mx = max(mx,a[i]);
    }
    for(exp = 1;mx/exp>0;exp*=10){
        int tmp[100000];
        int b[10] = {0};
        int n = 100000;
        for(int i=0;i<n;i++){
            b[(a[i]/exp)%10]++;
        }
        for(int i=1;i<10;i++){
            b[i] += b[i-1];
        }
        for(int i=n-1;i>=0;i--){
            tmp[ b[ ( a[i] / exp ) % 10 ] -1 ] = a[i];
            b[(a[i]/exp)%10]--;
        }
        for(int i=0;i<n;i++){
            a[i] = tmp[i];
        }
    }
}

十进制按位排序
1E5跑了0.011秒，1e6似乎跑不动

9、计数排序
累计比a[i]小的有多少，直接放在对应的位置上

int mp[1000000];
int mmx = -1;
int ans[1000000];
void Countingsort(){
    memset(mp,0,sizeof mp);
    for(int i=0;i<100000;i++){
        mp[a[i]]++;
    }
    for(int i=0;i<=mmx;i++){
        mp[i] += mp[i-1];
    }   
    for(int i=99999;i>=0;i--){
        ans[--mp[a[i]]] = a[i];
    }
}

1e5跑了0.003秒，1e6跑了0.036秒，1e7跑了0.17秒
mp用于存储当前这个数的最后一个的位置

最后再贴一份完整的所有排序的代码

#include<iostream>
#include<cstring>
#include<cstdio>
#include<string>
#include<map>
#include<stack>
#include<queue>
#include<set>
#include<sstream>
#include<ctime>
#include<algorithm>
#include<bits/stdc++.h>
#include<sstream>
#include<list>
#include<cmath>
#include<deque>
#include<cstdlib>
#include<ctime>
using namespace std;
const int maxn = 10086;
#define inf 0x3f3f3f3f
#define eps 1e-8
#define pi acos(-1.0)
typedef long long LL;
void anhangduru(){
     string line;
     while(getline(cin,line)){
        int sum=0;
        int x;
        stringstream ss(line);
        while(ss>>x){sum+=x;}//按空格读入
     }
}//按行读入
//加上符号重载
int a[100100000];
void BubbleSort(){
    clock_t start,finish;
    double totaltime;
    start=clock();

    for(int i=9999;i>=1;i--){
        int flag=0;
        for(int j=0;j<i;j++){
            if(a[j]>a[j+1]){
                int tmp = a[j+1];
                a[j+1] = a[j];
                a[j] = tmp; 
                flag=1;
            }
        }
        if(flag==0)break;
    }
    finish=clock();
    totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
    for(int i=0;i<100;i++){
        cout<<a[i]<<" ";
    }
    cout<<endl<<"程序一共运行了"<<" "<<totaltime<<" 秒"<<endl;
}
void Selectionsort(){
    clock_t start,finish;
    double totaltime;
    start=clock();

    for(int i=0;i<9999;i++){
        for(int j=i+1;j<9999;j++){
            if(a[i]>a[j]){
                a[i] = a[i]+a[j];
                a[j] = a[i]-a[j];
                a[i] = a[i]-a[j];
            }
        }
    }
    finish=clock();
    totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
    for(int i=0;i<100;i++){
        cout<<a[i]<<" ";
    }
    cout<<endl<<"程序一共运行了"<<" "<<totaltime<<" 秒"<<endl;
}
void Insertionsort(){
    clock_t start,finish;
    double totaltime;
    start=clock();
    for(int i=1;i<9999;i++){
        for(int j=i;j>0;j--){
            if(a[j]<a[j-1]){
                a[j] = a[j] + a[j-1];
                a[j-1] = a[j] - a[j-1];
                a[j] = a[j] - a[j-1];
            }
        }
    }
    finish=clock();
    totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
    for(int i=0;i<100;i++){
        cout<<a[i]<<" ";
    }
    cout<<endl<<"程序一共运行了"<<" "<<totaltime<<" 秒"<<endl;
}
void Shellsort(){
    clock_t start,finish;
    double totaltime;
    start=clock();

    int increment = 10000;
    while(increment>1){
        increment = increment/3 + 1;
        int d = increment;
        for(int i=d+1;i<=10000;i++){
            if(a[i]<a[i-d]){
                a[0] = a[i];
                int j = i-d;
                do{
                    a[j+d] = a[j];
                    j = j-d;
                }while(j>0&&a[0]<a[j]);
                a[j+d] = a[0];
            }
        }
    }
    finish=clock();
    totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
    for(int i=1;i<=10000;i++){
        cout<<a[i]<<" ";
    }
    cout<<endl<<"程序一共运行了"<<" "<<totaltime<<" 秒"<<endl;
}
void Timsort(){
    clock_t start,finish;
    double totaltime;
    start=clock();

    int l,r,mid;
    int tmp;
    for(int i=1;i<10000;i++){
        tmp = a[i];
        l = 0;
        r = i - 1;
        while(l<=r){
            mid = (l+r)/2;
            if(a[mid]>tmp){
                r = mid - 1;
            }else{
                l = mid + 1;
            }
        }
        for(int j=i-1;j>r;j--){
                a[j+1] = a[j];
            }
        a[r+1] = tmp;
    }
    finish=clock();
    totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
    for(int i=0;i<100;i++){
        cout<<a[i]<<" ";
    }
    cout<<endl<<"程序一共运行了"<<" "<<totaltime<<" 秒"<<endl;
}
void Quicksort(int l,int r){
    int i,j,x;
    if(l<r){
        i = l;
        j = r;
        x = a[i];
        while(i<j){
            while(i<j&&a[j]>x){
                j--;
            }
            if(i<j){
                a[i] = a[j];
                i++;
            }
            while(i<j&&a[i]<x){
                i++;
            }
            if(i<j){
                a[j] = a[i];
                j--;
            }
        }
        a[i] = x;
        Quicksort(l,i-1);
        Quicksort(i+1,r);
    }
}
void Mergesort(int l,int r){
    if(l<r){
        int mid = (l+r)/2;
        Mergesort(l,mid);
        Mergesort(mid+1,r);
        int i = l;
        int j = mid+1;
        int k = 0;
        int tmp[r-l+1];
        memset(tmp,0,sizeof tmp);
        while(i<=mid&&j<=r){
            if(a[i]>a[j]){
                tmp[k++] = a[j++];
            }else{
                tmp[k++] = a[i++];
            }
        }
        while(i<=mid){
            tmp[k++] = a[i++];
        }
        while(j<=r){
            tmp[k++] = a[j++];
        }
        int n = k;
        k = l;
        for(int ii=0;ii<n;ii++){
            a[k++] = tmp[ii];
        }
    }
}
void radixSort(){
    int exp;
    int mx = -1;
    for(int i=0;i<100001;i++){
        mx = max(mx,a[i]);
    }
    for(exp = 1;mx/exp>0;exp*=10){
        int tmp[100001];
        int b[20] = {0};
        int n = 100000;
        for(int i=0;i<n;i++){
            b[(a[i]/exp)%10]++;
        }
        for(int i=1;i<10;i++){
            b[i] += b[i-1];
        }
        for(int i=n-1;i>=0;i--){
            tmp[ b[ ( a[i] / exp ) % 10 ] -1 ] = a[i];
            b[(a[i]/exp)%10]--;
        }
        for(int i=0;i<n;i++){
            a[i] = tmp[i];
        }
    }
}

int mmx = -1;
int ans[10000010];
void Countingsort(){
    int mp[mmx+2];
    memset(mp,0,sizeof mp);
    for(int i=0;i<100000000;i++){
        mp[a[i]]++;
    }
    for(int i=0;i<=mmx;i++){
        mp[i] += mp[i-1];
//      cout<<i<<" "<<mp[i]<<endl;
    }   
    for(int i=99999999;i>=0;i--){
        ans[--mp[a[i]]] = a[i];
    }

}
int main()
{
//  ios::sync_with_stdio(0);//输入输出挂
    memset(a,0,sizeof a);
    srand((unsigned)time(NULL));
    for(int i=0;i<100000008;i++){
        a[i] = rand();
        mmx = max(mmx,a[i]); 
    }
    cout<<mmx<<endl;
    clock_t start,finish;
    double totaltime;
    start=clock();



    Countingsort();


    finish=clock();
    totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
    for(int i=0;i<100;i++){
        cout<<ans[i]<<" ";
    }
    cout<<ans[9999685]<<endl;
    cout<<endl<<"程序一共运行了"<<" "<<totaltime<<" 秒"<<endl;
    return 0;
}
海燕技术栈
关注
专栏目录
部分排序算法的原理和实现
Eason的博客
01-13 559
文章目录冒泡排序选择排序 本篇博客主要讲解一下，冒泡排序，插入排序，选择排序，快速排序，归并排序，桶排序，计数排序，基数排序。我会讲解一下实现原理，以及时间复杂度，空间复杂度，并贴出来我实现的核心代码。其他的排序算法，我会以后慢慢加上去。 冒泡排序 冒泡排序只会比较相邻的两个数据，每次冒泡都会对相邻的两个元素比较，看是否满足大小条件，如果不满足条件，就交换元素。一个数组长度为n，n次操作，就完成n...
排序算法原理总结
u011983560的博客
06-07 361
排序算法 排序算法是将无序的数组变为有序的数组的操作。后续都以从小到大的顺序为目的。 选择排序 选择排序是通过找到数组中无序部分中的最小那个元素，然后将它与无序部分的第一个数交换位置，交换后将无序部分第一个数归入有序部分。 插入排序 插入排序类似于我们玩扑克时摸牌的操作，第一次排序我们认为第一个数有序，然后与第二个数比较。如果第二个数小于第一个数则交换位置，否则保持不变。然后有序部分增加1，无序部分减少1.第二次排序则将第三个数（无序部分第一个数）依次从后向前与有序部分比较，将其放到合适的位置。然后有序部分
排序算法原理及实现
Swayzzu的博客
08-29 248
稳定性： 例：原序列中假设（3,1）和（3,7）的顺序是（3,1）（3,7），如果排完序，这两个顺序没变，还是（3,1）（3,7），就说明是稳定的，如果变了，就说明不稳定。 冒泡排序方法：从第一个数开始，每次只对比两个数，如果后面的比前面的小则交换位置，否则不换位置，拿较大的数继续往后比对，一直跑到最后。 两种循环实现冒泡排序： 选择排序方法：第一步从序列中选出最小的和第一个换位置；第二步从剩余的数中选出最小的和第二个换位置；依次进行。（不稳定：升序，选择最大的数的时候会不稳定。） .
插入排序、比较排序
feifei
07-15 2711
一、插入排序       插入排序就是将一个待排数据按其大小插入到一个有序表的适当位置，并插入后仍有序。分为三类：直接插入排序；折半 插入排序；希尔插入排序。    【直接插入排序】  例如，把{4,3,1,2}进行排序，算法过程见图： 通常，有序的序表是r[1]、r[2].....，而r[0]是哨兵，用于存放需要排序的数据，属于赋值空间。 所以，算法时间复杂度是：
八大排序算法的原理
adru的博客
06-24 715
简单讲述八大排序算法的原理和作用
基于flutter实现的排序算法原理演示平台设计.zip
03-10
在本项目中，我们主要探讨的是如何利用Flutter框架来设计并实现一个排序算法原理的演示平台。Flutter是由Google开发的一款开源UI工具包，用于构建高性能、高保真、跨平台的移动应用程序。在这个平台上，用户可以直观...
Python实现希尔排序算法的原理与用法实例分析
12-23
本文实例讲述了Python实现希尔排序算法的原理与用法。分享给大家供大家参考，具体如下： 希尔排序(Shell Sort)是插入排序的一种。也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。 希尔排序的基本思想...
Verilog/C++实现排序算法：Verilog/C++实现排序算法：冒泡排序、选择排序、并行全比较排序、串行全比较排序
06-27
在C++中，我们可以直接使用标准库中的`std::sort`函数，但在理解排序算法的工作原理时，手动实现它们是非常有益的。 **冒泡排序**是一种简单直观的排序方法。它的核心思想是通过重复遍历数组，比较相邻元素并交换...
计算机科学中的基数排序算法原理与实现
最新发布
09-17
本文详细介绍了基数排序这一非比较型排序方法的算法原理以及其在实际应用中如何操作。从初始化桶到最后重构阵列的每一步均进行了阐述，并提供了基于Python的实现例子。另外，对基数排序的时间和空间复杂度给出了深入...
深入解析快速排序算法的原理及其Go语言版实现
12-26
快速排序是一种基于分治技术的重要排序算法。不像归并排序是按照元素在数组中的位置对它们进行划分，快速排序按照元素的值对它们进行划分。具体来说，它对给定数组中的元素进行重新排列，以得到一个快速排序的分区。...
算法基础：基本排序算法原理、实现与总结
iOS_Manguoge的博客
02-10 933
所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
七大排序算法的基本原理及实现
m0_74199136的博客
12-09 1466
快速掌握七大排序算法的基本原理及实现
排序算法原理详解，结合python实现
weixin_39631030的博客
10-09 681
1、冒泡排序 冒泡排序算法的原理很容易理解，对n个元素来说，每次从第1个元素开始遍历直到第n-1个元素，每走一步将其与其后一个元素比较，如果大于就替换，否则保持不变（故是稳定的）；这样遍历一次之后，就将最大的元素移到末尾。第二次遍历排除上一步移到末尾的元素，即将余下的n-1个元素重复之前的操作，将最大的元素移到末尾；第三次遍历排除上一步移到末尾的元素，将余下的n-2个元素重读之前的操作；再是n-...
各种排序算法的原理、Java实现与比较分析（二）
TangowL
09-09 1087
三、交换排序3.1 冒泡排序（1）基本思想 在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。（2）特点 冒泡排序是一种稳定的排序方法 冒泡排序是最慢的排序算法。在实际运用中它是效率最低的算法 起泡排序平均时间复杂度为O(n2) （3）Java实现pa
常见的排序算法及其原理
liusiyu
06-16 1063
1.直接插入排序 1.1 原理 整个区间被分为： 有序区间和无序区间 每次选择无序区间的第一个元素，在有序区间内找个合适的位置插入 1.2 实现 依次查询 public static void insertSort(int[] array){ for (int i = 1; i < array.length; i++) { // 有序区间: [0, i) // 无序区间: [i, array.length) int v = array[i];
排序算法原理以及实现
xiyangsu2617的博客
10-02 246
1.冒泡排序算法 2.插入排序算法 /* * 1.第一个元素开始，假设第一个元素已排序 * 2.取下一个元素temp_val，在已排序的区间从后往前扫描，如果大于temp_val，则往后移 * 3.直到小于的时候，将其后一位置为temp_val即可 * 4.重复n-1次2、3步骤 */ //三个参数目的是为了，排序某个区间 void insertion_sort(vector&lt...
总结一些排序算法的原理和实现
程序人生
12-05 5214
这两天看了一下常用的排序算法，并进行了简单的实现。其原理和实现总结如下： 简介：    排序是数据处理中经常使用的一种重要运算，并且排序本身对推动算法分析的发展也起很大作用。    1、插入排序（直接插入排序、折半插入排序、希尔排序）；    2、交换排序（起泡排序、快速排序）；    3、选择排序（直接选择排序、堆排序）；    4、归并排序；    5、基数排序； 
排序算法原理汇总
qq_41558173的博客
03-28 1062
概述 排序有内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。 当n较大，则应采用时间复杂度为O(nlog2n)的排序方法：快速排序、堆排序或归并排序。 快速排序：是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短； 1、冒泡排序 最简单的一种排序算法。假设长...
C++模板实现各类排序算法
"这篇资源提供的是C++实现的各种排序算法的模板类，包括快速排序、选择排序、冒泡排序、插入排序、堆排序以及二叉排序树排序。这些算法是编程基础中的重要部分，适用于数据处理和优化。作者提供了完整的代码实现，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

海燕技术栈

你的鼓励我的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值