1、常见的稳定的排序算法有：
（1）直接插入排序，（2）冒泡排序，（3）归并排序，（4）基数排序；
2、常见的不稳定的排序算法有：
（1）简单选择排序，（2）希尔排序，（3）快速排序，（4）堆排序。
适合运用场景：
数据量小，且基本有序：冒泡，插入，希尔，
数据量小：选择排序
数据量大，或输入成流式:堆排序
数据量大：快速排序
一，交换排序
1，冒泡排序
对于一组数，a[0],a[1],a[2]…a[n],排序后按照升序排列，首先比较a[0]与a[1]的值，如果a[0]大于a[1],则交换二者的位置，否则不变。继续比较a[1]与a[2],大于交换，否者不变，继续a[n-1]与a[n]比较，并进行交换。这样一轮下来，a[n]为前这组数中最大的。再对a[1]~a[n-1]进行这样一轮处理，处理后a[n-1]为 a[1]-a[n-1]中最大的，以此类推，共处理n-1轮后，这组序列就升序排列了。
代码实现：
#include <iostream>
using namespace std;
int main()
{
int a[10]={10,5,3,8,6,12,9,7,5,4};
//n为数组的个数
int n=10;
//外循环为总轮数 总轮数为n-1
for (int i=0;i<n-1;i++)
{
//内循环为每轮
for(int j=0;j<n-i;j++)
{
if(a[j]>a[j+1])
{
//交换
int t=a[j+1];
a[j+1]=a[j];
a[j]=t;
}
}
}
//输出结果：
for(int i=0;i<n;i++)
{
cout<<a[i]<<" ";
}
return 0;
}
优点：稳定
缺点：慢，每次只移动相邻的两个元素。
时间复杂度：理想情况下（数组本来就是有序的），此时最好的时间复杂度为o(n),最坏的时间复杂度(数据反序的)，此时的时间复杂度为o(n*n) 。冒泡排序的平均时间负责度为
2，快速排序
每轮最重要的就是找中轴（中轴左边的数比中轴小，中轴右边的数比中轴大），找到中轴后，中轴左右数据分别再进行快速排序（递归）
算法步骤：
1， 首先设定基准数据tmp为数组第一个元素，然后从数组两端扫描数据，找到tmp放的位置（左边的数都比tmp小，右边的数都比tmp大）设两个标志位：low指向起始位置，high指向结束位置
2，先从后往前，如果high值大于tmp值就high减1，直到发现high位置上的值小于tmp的值，就把high的值赋给low
此时high小于tmp，需要替换（赋值后不用担心low的值丢失，因为tmp=low），结果如下：
3，如果low值小于tmp值就low值加1，直到发现low值大于tmp值，让low值赋给high值，当前例子在low等于46时发生交换：
4，重复2，3步骤，直到low==high，将tmp的值放入此位置，此位置就是中轴位置，结束中轴的寻找
接着执行2，high–，发现high小于tmp，进行替换：
接着执行3：low++，发现直到lowhigh时未能找到low大于tmp的值的数，则**将lowhigh的位置放入tmp**并结束循环：
替换后最终寻找结果：
5，使用递归，将中轴左右数据分别在进行一轮快速排序
代码实现：
#include <iostream>
using namespace std;
//获取中轴下标的函数
int getCenter(int *a,int low,int high)
{
//先让基准数据等于第一个
int tmp=a[low];
//当low==high时结束寻找
while(low<high)
{
//先从右往左，寻找high小于tmp的值
while(low<high&&a[high]>=tmp)
{
high--;
}
//退出上一个循环，要么是high==low，要么是找到high<tmp的位置
//将high的值赋给low
a[low]=a[high];
//接着从左往右 寻找low>tmp的值
while(low<high&&a[low]<=tmp)
{
low++;
}
//退出上一个循环，要么是high==low，要么是找到low>tmp的位置
//将low的值赋给high
a[high]=a[low];
}
//跳出循环时low==high
//此位置为中轴位置，并且将tmp值赋给此位置
a[low]=tmp;
return low;
}
void QuickSort(int *a,int low,int high)
{
//判断low是否等于high 如果等于的话说明就只有一个数 就不进行这一轮快排
if(low<high)
{
//找中轴位置
int index=getCenter(a,low,high);
//进行中轴左右的一轮快排迭代
QuickSort(a,low,index-1);
QuickSort(a,index+1,high);
}
}
int main()
{
int a[10]={2,8,6,7,9,9,1,-1,5,4};
QuickSort(a,0,9);
for(int i=0;i<10;i++)
{
cout<<a[i]<<" ";
}
return 0;
}
二，插入排序
1，直接插入排序
第一趟比较前两个数，然后把这两个数按照大小排序； 第二趟把第三个数据与前两个数从前向后扫描，把第三个数按大小插入到有序表中；依次进行下去，进行了(n-1)趟扫描以后就完成了整个排序过程。
直接插入排序属于稳定的排序，最坏时间复杂性为O(n^2)，空间复杂度为O(1)。
图解：
代码：
#include <iostream>
using namespace std;
int main()
{
int a[10]={2,-5,4,9,6,5,3,7,4,8};
int n=10;
//外循环控制每一轮 i要从第二个开始
for(int i=1;i<n;i++)
{
//记下当前a[i]的值
int tmp=a[i];
//内循环进行每一轮的比较与替换
int j;
for(j=i;j>=1&&a[j-1]>tmp;j--)
{
//将当前序列比tmp大的值后移一位
a[j]=a[j-1];
}
a[j]=tmp;
}
for(int i=0;i<10;i++)
{
cout<<a[i]<<" ";
}
return 0;
}
2，希尔排序
希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。
选择增量gap=length/2，缩小增量继续以gap = gap/2的方式，这种增量选择我们可以用一个序列来表示，{n/2,(n/2)/2…1}，称为增量序列。
图例步骤：
1，原始数组：
2，确定初始增量并分组排序
gap=length/2=5，被分为五组：【8，3】，【9，5】，【1，4】，【7，6】，【2，0】
对本轮分组进行直接插入排序，可以看到3，5，6小元素跑到前面去了
3，第二次分组并排序：
本轮增量大小：
gap=gap/2=2
数组被分为两组：【3，1，0，9，7】【5，6，8，4，2】
3，继续分组排序
发现本轮分组为gap=gap/2=1
此时为整个数组：【0，2，1，4，3，5，7，6，9，8】
这时最后一轮仅需少量调整即可完成整个数组的排序：
代码：
#include <iostream>
using namespace std;
void ShellSort(int *a,int length)
{
//初始化gap
int gap=length/2;
//外循环每次对gap进行2的取整
for(int g=gap;g>0;g=g/2)
{
//通过i来依次访问各个分组的元素（将直接插入排序的1换成g即可）
for(int i=g;i<length;i++)
{
int tmp=a[i];
int j;
for(j=i;j>=g&&a[j-g]>tmp;j-=g)
{
a[j]=a[j-g];
}
a[j]=tmp;
}
}
}
int main()
{
int a[10]={2,-5,4,9,6,5,3,7,4,8};
int n=10;
ShellSort(a,n);
for(int i=0;i<10;i++)
{
cout<<a[i]<<" ";
}
return 0;
}
三，选择排序
1，简单选择排序
设所排序序列的记录个数为n。i取0,1,2,…,n-1,从所有n-i个记录（Ri,Ri+1,…,Rn-1）中找出排序码最小的记录，与第i个记录交换。执行n趟 后就完成了记录序列的排序。
代码：
#include <iostream>
using namespace std;
int main()
{
int a[9]={4,2,3,1,5,7,3,8,6};
int n=9;
for(int i=0;i<n;i++)
{
//初始化找到的位置为当前
//最小标记
int pos=i;
for(int j=i+1;j<n;j++)
{
//注意这里为a[pos]因为是找到剩下序列最小的 而不是比序列头小的
if(a[j]<a[pos])
{
pos=j;
}
}
//替换
int tmp=a[i];
a[i]=a[pos];
a[pos]=tmp;
}
for(int i=0;i<n;i++)
{
cout<<a[i]<<" ";
}
return 0;
}
2，堆排序
堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。可以利用数组的特点快速定位指定索引的元素。堆分为大根堆和小根堆，是完全二叉树。大根堆的要求是每个节点的值都不大于其父节点的值，即A[PARENT[i]] >= A[i]。在数组的非降序排序中，需要使用的就是大根堆，因为根据大根堆的要求可知，最大的值一定在堆顶。
一般使用一维数组存放堆结构
1，父节点与子节点对应关系：
2，构建大顶堆
构建时需要先从倒数第二层开始，将子父三个结点的最大值放到父节点：
（1）,先对 3 6 4结点进行heapify(将最大值放到父节点)：
（2）再对 10 8 2结点进行heapify：
（3）,再对5，6，4结点进行heapify:
注意：此时5 和6调换后，需要再对5 3 4 结点进行heapify（保证子树的大顶堆性质）
（4），再对4 6 10 结点进行heapify
10和4 交换后，要对4 结点进行heapify，保证子树的性质：
至此，大顶堆构建完成
3，有了标准大顶堆后，就可以进行排序：
（1），将根节点与最后一个结点替换，删除最后一个结点，即为值最大数：
（2），从替换后的根节点开始进行heapify：
（3），重复1 2 步骤
替换：
heapify：
（4），直至所有的元素都被删除结束：
最终结果：
4，代码
#include <iostream>
using namespace std;
//对一个结点进行大顶堆调整 n为堆的总长度 node为要进行操作的父节点下标
//进行heapify时要注意子序列必须为大顶堆
//维护大顶堆函数
void heapify(int *a,int length,int node )
{
//求左子节点下标
int left = 2*node+1;
int right = 2*node+2;
int max=node;
//得出三个元素中最大值得下标，同时为了避免越界，需保证小于n
if(left<length&&a[left]>a[max])
{
max=left;
}
if(right<length&&a[right]>a[max])
{
max=right;
}
//当根节点不是最大值时进行交换
if(max!=node)
{
swap(a[node],a[max]);
//同时保证子树也为大顶树
heapify(a,length,max);
}
}
//构建大顶堆
void buildMaxHeap(int *a,int length)
{
//从倒数第二排进行heapify
for(int i=(length-1-1)/2;i>=0;i--)
{
heapify(a,length,i);
}
}
//堆排序
int* HeapSort(int *a,int length)
{
//构建大顶堆
buildMaxHeap(a,length);
int *res=new int(length);
for(int i=length-1;i>=0;i--)
{
//存储当前最大值
res[i]=a[0];
//将根节点改为最后一个结点
a[0]=a[i];
//从根节点维护大顶堆
heapify(a,i,0);
}
return res;
}
int main()
{
int a[9]={4,5,10,3,4,8,2,6,4};
int *res=HeapSort(a,9);
//输出最终结果
for(int i=0;i<9;i++)
{
cout<<res[i]<<" ";
}
}
扫一扫
7300
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
