常见排序算法整理

最新推荐文章于 2024-02-21 15:33:51 发布
最新推荐文章于 2024-02-21 15:33:51 发布
阅读量681 收藏
点赞数 2
分类专栏： algorithm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011285477/article/details/68488109
版权

最近花了点时间把几个常用的排序算法在此做个总结，下面是代码。

1、直接插入排序

输入数组为{16,14,10,8,7,9,3,2,4,1}，按照从小到大排序。

右边的无序数不断地往左边的有序数部分进行比较然后插入

16 14 10 8 7 9 3 2 4 1

14 16 10 8 7 9 3 2 4 1

10 14 16 8 7 9 3 2 4 1

8 10 14 16 7 9 3 2 4 1

7 8 10 14 16 9 3 2 4 1

7 8 9 10 14 16 3 2 4 1

3 7 8 9 10 14 16 2 4 1

2 3 7 8 9 10 14 16 4 1

2 3 4 7 8 9 10 14 16 1

1 2 3 4 7 8 9 10 14 16


// 直接插入排序
/*
思想：每次选择一个元素K=data[i]插入到之前已排好序的部分data[0…i-1]中，插入过程中K依次
由后向前与data[0…i-1]中的元素进行比较。若发现发现data[x]>=K,则将K插入到A[x]的后面，插入前需要移动元素。
*/
void InsertSort(vector<int> & data) {
	int n = data.size();//数组长度
	int i,j;
	int temp;
	for(i=0;i<n;i++)
	{
		temp = data[i];
		j = i-1;//从右向左在有序区data[0...i-1]找data[i]的插入位置
		while(j>=0 && temp<data[j])
		{
			data[j+1] = data[j];//将值大于data[i]向右移动
			j--;
		}
		data[j+1] = temp;//在j+1处插入data[i]
	}
}

2、冒泡排序

输入数组为{16,14,10,8,7,9,3,2,4,1}，按照从小到大排序。

右边无序数中的最小数通过不断交换移到左边

1 16 14 10 8 7 9 3 2 4

1 2 16 14 10 8 7 9 3 4

1 2 3 16 14 10 8 7 9 4

1 2 3 4 16 14 10 8 7 9

1 2 3 4 7 16 14 10 8 9

1 2 3 4 7 8 16 14 10 9

1 2 3 4 7 8 9 16 14 10

1 2 3 4 7 8 9 10 16 14

1 2 3 4 7 8 9 10 14 16


//冒泡排序
//从最右侧的元素开始搜索并交换，找出最小的数移到无序的最左位置
void BubbleSort(vector<int> & data) {
	int n = data.size();//数组长度
	int i,j;
	int temp;
	for(i=0;i<n-1;i++)//n趟
	{
		for(j=n-1;j>i;j--)//找出本趟次最小的数，移到无序的最左处
		{
			if(data[j]<data[j-1])//后面的数比前面的小就交换
			{
				temp = data[j];
				data[j] = data[j-1];
				data[j-1] = temp;
			}
		}
	}

}


3、快速排序



//快速排序
//最核心的思想是将小的部分放在左边，大的部分放到右边，实现分割。
//每次都需要和中轴元素交换，因此原来的顺序就可能被打乱,所以不稳定
void QuickSort(int data[],int s,int t) {
	int i=s,j=t;
	int temp;
	if(s<t)
	{
		temp = data[s];//取data[s...t]最左侧的元素作为中轴元素
		while(i!=j){
			while(j>i && data[j]>temp) j--;//从右往左找到第一个比temp值要小的数data[j]
			if(i<j){data[i]=data[j];i++;}//data[j]移到左侧，i++

			while(i<j && data[i]<temp) i++;//从左往右找到第一个比temp值要大的数
			if(i<j){data[j]=data[i];j--;}//data[i]移到右侧,j--
		}
		data[i] = temp;
		QuickSort(data,s,i-1);//对左段继续分割
		QuickSort(data,i+1,t);//对右段继续分割
	}
}


4、直接选择排序

输入数组为{16,14,10,8,7,9,3,2,4,1}，按照从小到大排序。

右边无序数的最小数与无序数中的第一个数进行交换

1 14 10 8 7 9 3 2 4 16

1 2 10 8 7 9 3 14 4 16

1 2 3 8 7 9 10 14 4 16

1 2 3 4 7 9 10 14 8 16

1 2 3 4 7 9 10 14 8 16

1 2 3 4 7 8 10 14 9 16

1 2 3 4 7 8 9 14 10 16

1 2 3 4 7 8 9 10 14 16

1 2 3 4 7 8 9 10 14 16


// 直接选择排序
void SelectSort(vector<int> & data) {
	int n = data.size();//数组长度
	int i,j,k;
	int temp;
	for(i=0;i<n-1;i++)
	{
		k = i;
		for(j=i+1;j<n;j++)//在右边无序数中找最小数
		{
			if(data[j]<data[k])//记录最小数的位置
				k=j;
		}
		if(k!=i)//最小数data[k]跟无序数中首个数data[i]交换
		{
			temp = data[i];
			data[i] = data[k];
			data[k] = temp;
		}
	}
}


5、堆排序

输入数组为{16,14,10,8,7,9,3,2,4,1}，按照从小到大排序。

初始化为最大堆，取出堆顶最大元素跟堆的最后一个元素交换，再重新调整堆

16 14 10 8 7 9 3 2 4 1 初始化为最大堆

14 8 10 4 7 9 3 2 1 16

10 8 9 4 7 1 3 2 14 16

9 8 3 4 7 1 2 10 14 16

8 7 3 4 2 1 9 10 14 16

7 4 3 1 2 8 9 10 14 16

4 2 3 1 7 8 9 10 14 16

3 2 1 4 7 8 9 10 14 16

2 1 3 4 7 8 9 10 14 16

1 2 3 4 7 8 9 10 14 16


//调整堆，交换较大数  
void adjustHeap(int A[],int s,int e)  
{  
    int i = s,j=2*i,tmp;//数组第j个元素是第i个的左子树  
    tmp = A[i-1];  
    while(j<=e)  
    {  
        if(j<e && A[j-1]<A[j])//取左、右子树中的较大者  
            j++;  
        if(A[j-1]>tmp)  
        {  
            A[i-1]=A[j-1];//交换较大数  
            i=j;  
            j=2*i;//更新位置，进行下一轮调整  
        }  
        else  
        {  
            break;  
        }  
    }  
    A[i-1] = tmp;//最终位置  
}  
//堆排序  
void heapsort(int data[],int n)  
{  
    int i,tmp;  
    //初始化为最大堆  
    for(i=n/2;i>=1;i--)  
    {  
        adjustHeap(data,i,n);  
    }
    for(i=n;i>=2;i--)//i==1只有一个元素就不用调整了  
    {  
        tmp = data[0];//取出堆顶最大元素跟堆的最后一个元素交换  
        data[0] = data[i-1];  
        data[i-1] = tmp;  
        adjustHeap(data,1,i-1);//此时堆大小-1 
    }  
} 


6、归并排序

归并排序其实要做两件事：

（1）“分解”——将序列每次折半划分。

（2）“合并”——将划分后的序列段两两合并后排序。


//合并两个有序的
void Merge(int r[],int r1[],int s,int m,int t)
{
	int i=s;
	int j=m+1;
	int k=s;
	//有序排列到r1中
	while(i<=m && j<=t){
		if(r[i]<=r[j])
			r1[k++]=r[i++];
		else
			r1[k++]=r[j++];
	}
	if(i<=m)//[i,m]还有剩
	{
		while(i<=m)
			r1[k++]=r[i++];
	}
	else//[m+1,t]还有剩
	{
		while(j<=t)
			r1[k++]=r[j++];
	}
	//将r1赋给r
	for(int n=s;n<=t;n++)
		r[n]=r1[n];
}

//归并排序是空间换时间
void MergeSort(int r[],int r1[],int s,int t)
{
	if(s<t)
	{
		int m=(s+t)/2;//求取中间元素坐标，将数组分为两部分
		MergeSort(r,r1,s,m);//[s,m]
		MergeSort(r,r1,m+1,t);//[m+1,t]
		Merge(r,r1,s,m,t);
	}
}



完整可运行代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <vector>
#include <algorithm>
#include <math.h>

using namespace std;

// 直接插入排序
/*
思想：每次选择一个元素K=data[i]插入到之前已排好序的部分data[0…i-1]中，插入过程中K依次
由后向前与data[0…i-1]中的元素进行比较。若发现发现data[x]>=K,则将K插入到A[x]的后面，插入前需要移动元素。
*/
void InsertSort(vector<int> & data) {
	int n = data.size();//数组长度
	int i,j;
	int temp;
	for(i=0;i<n;i++)
	{
		temp = data[i];
		j = i-1;//从右向左在有序区data[0...i-1]找data[i]的插入位置
		while(j>=0 && temp<data[j])
		{
			data[j+1] = data[j];//将值大于data[i]向右移动
			j--;
		}
		data[j+1] = temp;//在j+1处插入data[i]
	}
}

//冒泡排序
//从最右侧的元素开始搜索并交换，找出最小的数移到无序的最左位置
void BubbleSort(vector<int> & data) {
	int n = data.size();//数组长度
	int i,j;
	int temp;
	for(i=0;i<n-1;i++)//n趟
	{
		for(j=n-1;j>i;j--)//找出本趟次最小的数，移到无序的最左处
		{
			if(data[j]<data[j-1])//后面的数比前面的小就交换
			{
				temp = data[j];
				data[j] = data[j-1];
				data[j-1] = temp;
			}
		}
	}
}


//快速排序
//最核心的思想是将小的部分放在左边，大的部分放到右边，实现分割。
//每次都需要和中轴元素交换，因此原来的顺序就可能被打乱,所以不稳定
void QuickSort(int data[],int s,int t) {
	int i=s,j=t;
	int temp;
	if(s<t)
	{
		temp = data[s];//取data[s...t]最左侧的元素作为中轴元素
		while(i!=j){
			while(j>i && data[j]>temp) j--;//从右往左找到第一个比temp值要小的数data[j]
			if(i<j){data[i]=data[j];i++;}//data[j]移到左侧，i++

			while(i<j && data[i]<temp) i++;//从左往右找到第一个比temp值要大的数
			if(i<j){data[j]=data[i];j--;}//data[i]移到右侧,j--
		}
		data[i] = temp;
		QuickSort(data,s,i-1);//对左段继续分割
		QuickSort(data,i+1,t);//对右段继续分割
	}
}

// 直接选择排序
void SelectSort(vector<int> & data) {
	int n = data.size();//数组长度
	int i,j,k;
	int temp;
	for(i=0;i<n-1;i++)
	{
		k = i;
		for(j=i+1;j<n;j++)//在右边无序数中找最小数
		{
			if(data[j]<data[k])//记录最小数的位置
				k=j;
		}
		if(k!=i)//最小数data[k]跟无序数中首个数data[i]交换
		{
			temp = data[i];
			data[i] = data[k];
			data[k] = temp;
		}
	}
}

//调整堆，交换较大数  
void adjustHeap(int A[],int s,int e)  
{  
    int i = s,j=2*i,tmp;//[j]是[i]的左子树  
    tmp = A[i-1];  
    while(j<=e)  
    {  
        if(j<e && A[j-1]<A[j])//取左、右子树中的较大者  
            j++;  
        if(A[j-1]>tmp)  
        {  
            A[i-1]=A[j-1];//交换较大数  
            i=j;  
            j=2*i;//更新位置，进行下一轮调整  
        }  
        else  
        {  
            break;  
        }  
    }  
    A[i-1] = tmp;//最终位置  
}  
//堆排序  
void heapsort(int data[],int n)  
{  
    int i,tmp;  
    //初始化为最大堆  
    for(i=n/2;i>=1;i--)  
    {  
        adjustHeap(data,i,n);  
    }
    for(i=n;i>=2;i--)//i==1只有一个元素就不用调整了  
    {  
        tmp = data[0];//取出堆顶最大元素跟堆的最后一个元素交换  
        data[0] = data[i-1];  
        data[i-1] = tmp;  
        adjustHeap(data,1,i-1);//此时堆大小-1 
    }  
} 

//合并两个有序的
void Merge(int r[],int r1[],int s,int m,int t)
{
	int i=s;
	int j=m+1;
	int k=s;
	//有序排列到r1中
	while(i<=m && j<=t){
		if(r[i]<=r[j])
			r1[k++]=r[i++];
		else
			r1[k++]=r[j++];
	}
	if(i<=m)//[i,m]还有剩
	{
		while(i<=m)
			r1[k++]=r[i++];
	}
	else//[m+1,t]还有剩
	{
		while(j<=t)
			r1[k++]=r[j++];
	}
	//将r1赋给r
	for(int n=s;n<=t;n++)
		r[n]=r1[n];
}


//归并排序是空间换时间
void MergeSort(int r[],int r1[],int s,int t)
{
	if(s<t)
	{
		int m=(s+t)/2;//求取中间元素坐标，将数组分为两部分
		MergeSort(r,r1,s,m);//[s,m]
		MergeSort(r,r1,m+1,t);//[m+1,t]
		Merge(r,r1,s,m,t);
	}
}
int main()
{
	//数组初始化vector
	int iarray[]={16,14,10,8,7,9,3,2,4,1};

	//count： iarray数组个数
	size_t count=sizeof(iarray)/sizeof(int);
	//int数组初始化 ivec3
	vector<int> a(iarray,iarray+count);

#if 0
	BubbleSort(a);

	for(int i=0;i<count;i++)
	{
		printf("%d\n",a[i]);
	}
#endif

#if 1
	//QuickSort(iarray,0,count-1);
	heapsort(iarray,count);

	for(int i=0;i<count;i++)
	{
		printf("%d\n",iarray[i]);
	}
#endif

	system("pause");
	return 0;
}



参考资料：

[1]【常见排序算法小结】http://blog.csdn.net/whuslei/article/details/6442755

[2]【经典排序算法】http://www.cnblogs.com/kkun/archive/2011/11/23/2260312.html

[3]【八种必须掌握的排序算法】https://zhuanlan.zhihu.com/p/26065419?utm_source=qq&utm_medium=social

通信程序猿
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
排序算法整理.zip
07-07
"排序算法整理.zip"这个压缩包文件显然包含了关于十种常见排序算法的详细资料，这些算法包括冒泡排序、选择排序、插入排序、计数排序、基数排序、堆排序、归并排序、快速排序、桶排序以及希尔排序。下面我们将逐一...
Java实现常见排序算法总结
05-02
【Java实现常见排序算法总结】 排序算法是计算机科学中至关重要的一部分，它涉及到数据处理和算法设计。本文将探讨两种常见的排序算法在Java中的实现：直接插入排序和希尔排序。 1. **直接插入排序（直接插入排序...
列排（list）排序
Samuel2983的博客
05-14 246
排序 方法一 1. 数字排序（从小到大进行排序,改变的是本身） scores = [23,43,54,67,87,100] scores.sort() print(scores) 2. 字符串排序（按首字母排序 ） **方法一 .sort()** name = ["shi","sheng","ru","yi","huang","meng"] name....
数组从小到大排序
Zj_refuseDDL的博客
09-06 2423
利用一些简单的算法进行数组的一个排序
排序算法时间复杂度函数图像
bahaidan1187的博客
08-06 897
这是使用desmos画出来的图形。主要对比xlog(x), x^2, log(x!), log(x), x的图形。 再上张大点图片 通过图形对比log(x!)低于xlog(x)高于x,但通常我们的排序算法快排和归并的最优是xlog(x)最坏是n^2, 通过二分查找改进的排序算法最坏是log(n!)，最好是n。 虽然nlog(n)和log(n!)相差不...
常用的排序算法：冒泡，简单选择，直接插入，快速排序，堆排序
dajinniu的专栏
01-15 684
冒泡排序： #include using namespace std; void bubblesort(int *data,int count) { for(int i=0;i { for(int j=0;j { if(data[j]>data[j+1]) { int temp =data[j]; data[j]=data[j+1]; data[j+1]=temp; }
最大堆、最小堆、堆排序
Che_Cars的博客
07-06 724
最（大）小堆的性质： （1）是一颗完全二叉树，遵循完全二叉树的所有性质。 （2）父节点的键值（大于）小于等于子节点的键值 （3）在堆排序中我们通常用的是最大堆，最小堆通常用在优先队列中（尚未找到恰当的例子）。 堆排序： 数组：a[10]={16,14,10,8,7,9,3,2,4,1}可以利用建堆的方式对其进行排序。因为堆是一颗完全二叉树，根据完全二叉树的性质可以得知：对数组进行建堆之后
常见排序算法整理(javascript 实现)
qq_42943914的博客
12-11 380
几种常见排序算法原理和实现，javascript实现排序算法，冒泡排序、插入排序、快速排序、归并排序、堆排序，几种算法时间复杂度、空间复杂度，算法稳定性的对比
常见的排序算法整理
最新发布
u014755700的博客
02-21 1155
1.1 冒泡排序普通版每次冒泡过程都是从数列的第一个元素开始，然后依次和剩余的元素进行比较，若小于相邻元素，则交换两者位置，同时将较大元素作为下一个比较的基准元素，继续将该元素与其相邻的元素进行比较，直到数列的最后一个元素 . 示意图如下:运行结果:排序前:[9, 2, 1, 0, 5, 3, 6, 4, 8, 7]排序后:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]1.2 冒泡排序升级版。
常见排序算法汇总
夜槿笙歌的博客
04-17 8293
整理一下之前学习的各种排序算法
PHP常见排序算法整理学习
u011415782的专栏
10-24 630
题记： 常见的排序算法有：冒泡排序法，快速排序法，选择排序法，插入排序法，此处作为自己最近面试准备进行的学习笔记，同时也希望能帮到你。 需求：将一个有多个数字的数组进行从小到大的排序.
Java实现几种常见排序算法代码
09-05
【Java实现几种常见排序算法代码】的描述中提到了排序的重要性以及分类，下面将详细讲解这些排序算法。 1. **排序算法的意义与稳定度** - 排序是计算机科学中的基本操作，它使得数据组织有序，便于查找、分析和...
常用的 JS 排序算法 整理版
12-02
它的基本思想是将待排序的元素按某个增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。希尔排序的时间复杂度在最坏的...
八大排序算法整理
10-19
自己整理的八大排序算法的实现以及其各自的特点，希望能帮助需要的人
python实现Floyd算法
图像研究猿的专栏
07-14 6273
下面是用Python实现Floyd算法的代码： # -*- coding: utf-8 -*- """ Created on Thu Jul 13 14:56:37 2017 @author: linzr """ ## 表示无穷大 INF_val = 9999 class Floyd_Path(): def __init__(self, node, node_map, path
DTW 动态时间规整
图像研究猿的专栏
11-20 2393
面临的问题 当数据在时间线上不对齐的时候，使用传统的匹配方法，是无法使用传统的全局匹配度量法的。DTW是一种衡量两个时间序列之间的相似度的方法，主要应用在语音识别领域来识别两段语音是否表示同一个单词。 DTW原理 (Dynamic Time Warping, DTW) 动态时间归整 DTW通过把时间序列进行延伸和缩短，来计算两个时间序列性之间的相似性。 如下图所示，上下两条实线代表两个...
python实现Dijkstra算法
图像研究猿的专栏
07-10 1889
下面是用python实现Dijkstra算法的代码： # -*- coding: utf-8 -*- """ Created on Fri Jul 07 11:33:19 2017 @author: linzr """ ## 表示无穷大 INF_val = 9999 class Dijkstra_Path(): def __init__(self, node_map):
常见算法模板整理汇总
ACM 模板整理是指在 ACM 竞赛中常用的算法和数据结构的总结和整理，本文档对 ACM 模板进行了分类和整理，总共分为六个部分：数学问题、字符串处理、计算几何、数论、图论和排序/查找。 **数学问题** 数学问题是 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值