本文介绍了四种经典的排序算法——冒泡排序、快速排序、归并排序和基数排序，详细阐述了它们的概念、原理及时间复杂度。每种排序算法都提供了C++实现代码，有助于读者理解和应用。
冒泡排序：
概念：
冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。
它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。
这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。
原理：
1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2.对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3.针对所有的元素重复以上的步骤，除了最后一个。
4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
时间复杂度：
最好的时候：O(n);
最坏的时候：T(n-1)+(n-1)->O(n^2)；
一般的情况：T(n-1)+(n-1)/2->O(n^2);
C++代码
#include<iostream>
using namespace std;
int main(){
int i,j,n,t,flag=0;
cout<<"please input how many number do you want to compare ";
cin>>n;
int a[n];
for(i=0;i<n;i++){
cin>>a[i];
}
for(i=0;i<n-1;i++){
flag = 0;
for(j=0;j<n-i-1;j++){
if(a[j]>a[j+1]){
t = a[j];
a[j] = a[j+1];
a[j+1] = t;
flag = 1;
}
}
if(flag==0) goto here;
}
here:
for(i=0;i<n;i++){
cout<<a[i]<<" ";
}
}
快速排序
概念：
快速排序由C. A. R. Hoare在1960年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
快速排序其实就是冒泡排序的升级版。我认为在快速排序中引用了二分思想，所以就会简化时间复杂度和空间复杂度。
原理：
(1)首先设定一个分界值，通过该分界值将数组分成左右两部分。
(2)将大于或等于分界值的数据集中到数组右边，小于分界值的数据集中到数组的左边。此时，左边部分中各元素都小于或等于分界值，而右边部分中各元素都大于或等于分界值。
(3)然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。
(4)重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左、右两个部分各数据排序完成后，整个数组的排序也就完成了。
复杂度：
时间复杂度：O(nlogn)
空间复杂度：O(n^2)
图例：
C++代码
#include<iostream>
using namespace std;
int a[20];
void quicksort(int left,int right)
{
int i,j,t,temp;
if(left>right)
return;
temp = a[left];//存储基准数
i=left;
j=right;
while(i!=j)
{
while(a[j]>=temp&&i<j)//先j--：
j--;
while(a[i]<=temp&&i<j)
i++;
if(i<j)//找的比基准数大的和小的
{
t=a[i];
a[i]=a[j];//交换位置里的元素；
a[j]=t;
}
}
a[left]=a[i];
a[i]=temp;
//递归
quicksort(left,i-1);
quicksort(i+1,right);
return;
}
int main(){
int i,j;
int n;
cin>>n;
for(i=1;i<=n;i++)
{
cin>>a[i];
}
quicksort(1,n);
for(i=1;i<=n;i++)
{
cout<<a[i];
}
}
归并排序：
概念：
归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。归并排序是一种稳定的排序方法。
也就是说归并算法就是将一个n个数的序列看成是n个有序序列，然后再看成n/2个有序序列，再看成n/4，以此类推，所以在第n次就可以排好2^n个数，所以显而易见，这个归并算法的时间复杂度为O(nlogn);
原理：
第一步：申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
第二步：设定两个指针，最初位置分别为两个已经排序序列的起始位置
第三步：比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
重复步骤3直到某一指针超出序列尾，将另一序列剩下的所有元素直接复制到合并序列尾
复杂度：
时间复杂度：O(nlogn)
空间复杂度：O(nlogn)
C++代码
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
void merge(int a[],int l,int r,int mid)
{
int aux[r-l+1],i,j,k;
for(k=l;k<=r;k++)
aux[k-l]=a[k];
i=l;
j=mid+1;
for(k=l;k<=r;k++)
{
if(i>mid)
{
a[k]=aux[j-l];
j++;
}
else if(j>r)
{
a[k]=aux[i-l];
i++;
}
else if(aux[i-l]>aux[j-l])
{
a[k]=aux[j-l];
j++;
}
else
{
a[k]=aux[i-l];
i++;
}
}
}
void merge_sort(int a[],int l,int r)
{
if(l>=r)
return ;
int mid=(l+r)/2;
merge_sort(a,l,mid);
merge_sort(a,mid+1,r);
merge(a,l,r,mid);
}
void mergesort(int a[],int l,int r)
{
merge_sort(a,l,r-1);
}
int main()
{
int a[105],n,i;
cin>>n;
for(i=0;i<n;i++)
cin>>a[i];
mergesort(a,0,n);
for(i=0;i<n;i++)
cout<<a[i];
return 0;
}
基数排序：
概念：
基数排序（radix sort）属于“分配式排序”（distribution sort），又称“桶子法”（bucket sort）或bin sort，顾名思义，它是透过键值的部份资讯，将要排序的元素分配至某些“桶”中，藉以达到排序的作用，基数排序法是属于稳定性的排序，对于n个记录，每个记录含d个关键字，每个关键字的取值范围为rd个，其时间复杂度为O (d(n+rd))，在某些时候，基数排序法的效率高于其它的稳定性排序法。
原理：
第一步
以LSD为例，假设原来有一串数值如下所示：
73, 22, 93, 43, 55, 14, 28, 65, 39, 81
首先根据个位数的数值，在走访数值时将它们分配至编号0到9的桶子中：
0
1 81
2 22
3 73 93 43
4 14
5 55 65
6
7
8 28
9 39
第二步
接下来将这些桶子中的数值重新串接起来，成为以下的数列：
81, 22, 73, 93, 43, 14, 55, 65, 28, 39
接着再进行一次分配，这次是根据十位数来分配：
0
1 14
2 22 28
3 39
4 43
5 55
6 65
7 73
8 81
9 93
第三步
接下来将这些桶子中的数值重新串接起来，成为以下的数列：
14, 22, 28, 39, 43, 55, 65, 73, 81, 93
这时候整个数列已经排序完毕；如果排序的对象有三位数以上，则持续进行以上的动作直至最高位数为止。
LSD的基数排序适用于位数小的数列，如果位数多的话，使用MSD的效率会比较好。MSD的方式与LSD相反，是由高位数为基底开始进行分配，但在分配之后并不马上合并回一个数组中，而是在每个“桶子”中建立“子桶”，将每个桶子中的数值按照下一数位的值分配到“子桶”中。在进行完最低位数的分配后再合并回单一的数组中。
复杂度：
时间复杂度：O (d(n+rd))
C++代码
#include<iostream>
#include<vector>
using namespace std;
void countSort(vector<int>& vec,int exp)
{//计数排序
vector<int> range(10,0);
int length=vec.size();
vector<int> tmpVec(length,0);
for(int i=0;i<length;++i)
{
range[(vec[i]/exp)%10]++;
}
for(int i=1;i<range.size();++i)
{
range[i]+=range[i-1];//统计本应该出现的位置
}
for(int i=length-1;i>=0;--i)
{
tmpVec[range[(vec[i]/exp)%10]-1]=vec[i];
range[(vec[i]/exp)%10]--;
}
vec=tmpVec;
}
void radixSort(vector<int>& vec)
{
int length=vec.size();
int max=-1;
for(int i=0;i<length;++i)
{//提取出最大值
if(vec[i]>max)
max=vec[i];
}
//提取每一位并进行比较，位数不足的高位补0
for(int exp=1;max/exp>0;exp*=10)
countSort(vec,exp);
}
int main()
{
int a[10]={53,3,542,748,14,214,154,63,616,589};
vector<int> vec(a,a+10);
radixSort(vec);
for(int i=0;i<vec.size();++i)
{
cout<<vec[i]<<" ";
}
cout<<endl;
return 0;
}
四者时间复杂度比较：
扫一扫
1303
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
