C++ 排序算法

最新推荐文章于 2024-07-11 17:17:41 发布
最新推荐文章于 2024-07-11 17:17:41 发布
阅读量254 收藏
点赞数
分类专栏： 思路（以后python内容放在这） 文章标签： 后端 排序算法 c++ 算法
原文链接：https://www.wqyunpan.com/resourceDetail.html?id=67021&openId=oUgl9wXomRGJoAQSOyJSOnGGotII&qrcodeId=59414&sign=ZTVkOGM1MGRhZDJjLTE2MzgwMDE4MTk3OTI=
版权

专题三 排序


这些排序算法的定义等等自己去百度百科，这里只有代码

排序类的定义

/************************
排序类Sort的类定义
*************************/
class Sort
{
public:
	Sort(int r[ ], int n); //构造函数，生成待排序序列
	~Sort( ); //析构函数
	
	void InsertSort( ); //直接插入排序
	void ShellSort( ); //希尔排序
	void BubbleSort( ); //起泡排序
	void QuickSort(int first, int last); //快速排序
	void SelectSort( ); //简单选择排序
	void HeapSort( ); //堆排序
	void MergeSort1(int first, int last); //二路归并递归排序
	void MergeSort2( ); //二路归并非递归排序
	void Print( ); //输出序列
private:
	int Partition(int first, int last); //快速排序，一次划分
	void Sift(int k, int last); //堆排序，堆调整
	void Merge(int first1, int last1, int last2); //归并排序，合并相邻有序序列
	void MergePass(int h); //归并排序，一趟归并
	
	int *data; //待排序序列，可以是数组
	int length;
};

Sort :: Sort(int r[ ], int n)
{
	data = new int[n];
	for (int i = 0; i < n; i++)
	data[i] = r[i];
	length = n;
}

Sort :: ~Sort( )
{
	delete[ ] data;
}

void Sort :: Print( )
{
	for (int i = 0; i < length; i++)
	cout << data[i] << " ";
}

直接插入排序 Straight Insertion Sort （稳定）

/***********************
直接插入排序算法
************************/
void Sort::InsertSort( )
{
	int i, j, temp;  //temp是一个值
	for (i = 1; i < length; i++) //排序进行length-1趟
	{
		temp = data[i]; //暂存待插记录
		for (j = i - 1; j >= 0 && temp < data[j]; j--) //寻找插入位置
			data[j + 1] = data[j];
		
		data[j + 1] = temp;
	}
}

希尔排序 Shell Sort （不稳定）

/******************
希尔排序算法
*******************/
void Sort::ShellSort( )
{
	int temp, d, i, j;
	for (d = length/2; d >= 1; d = d/2) //增量为d进行直接插入排序
	{
		for (i = d; i < length; i++) //进行一趟希尔排序
		{
			temp = data[i]; //暂存待插入记录
			for (j = i - d; j >= 0 && temp < data[j]; j = j - d)
				data[j + d] = data[j]; //记录后移d个位置
				
			data[j + d] = temp;
		}
	}
}

起泡排序 Bubble Sort（和冒泡不一样）（稳定）

/*******************
起泡排序算法
********************/
void Sort::BubbleSort( )
{
	int j, exchange, bound, temp;
	exchange = length - 1; //第一趟起泡排序的区间是[0~length-1]
	
	while (exchange != 0)
	{
		bound = exchange;
		exchange = 0;
		for (j = 0; j < bound; j++) //一趟起泡排序的区间是[0~bound]
			if (data[j] > data[j+1]) 
			{
				temp = data[j];
				data[j] = data[j+1];
				data[j+1] = temp;
				exchange = j; //记载每一次记录交换的位置
			}
	}
}

快速排序 Quick sort （不稳定）

一次划分算法

/*****************************
快速排序的一次划分算法
******************************/
int Sort::Partition(int first, int last)
{
	int i = first, j = last, temp; //初始化一次划分的区间
	while (i < j)
	{
		while (i < j && data[i] <= data[j]) 
			j--; //右侧扫描
		if (i < j) 
		{
			temp = data[i];
			data[i] = data[j]; 
			data[j] = temp;
			i++;
		}
		
		while (i < j && data[i] <= data[j])
			i++; //左侧扫描
			
		if (i < j) 
		{
			temp = data[i]; 
			data[i] = data[j]; 
			data[j] = temp;
			j--;
		}
	}
	return i; // i为轴值记录的最终位置
}

整个过程

/*******************
快速排序算法
********************/
void Sort::QuickSort(int first, int last)
{
	if (first >= last)
		return; //区间长度为1，递归结束
	else
	{
		int pivot = Partition(first, last); //一次划分
		QuickSort(first, pivot-1); //对左侧子序列进行快速排序
		QuickSort(pivot+1, last); //对右侧子序列进行快速排序
	}
}

简单选择排序 Simple Select Sort (不稳定)

/**********************
简单选择排序算法
***********************/
void Sort::SelectSort( )
{
	int i, j, index, temp;
	for (i = 0; i < length - 1; i++) //进行length-1趟简单选择排序
	{
		index = i;
		for (j = i + 1; j < length; j++) //在无序区中选取最小记录
			if (data[j] < data[index]) 
				index = j;
				
		if (index != i)
		{
		temp = data[i]; 
		data[i] = data[index]; 
		data[index] = temp;
		}
	}
}

堆排序 Heap Sort （不稳定）

图解排序算法(三)之堆排序

堆调整算法

将完全二叉树存储到 data[0] ~ data[length-1] 中（顺序存储，层序遍历的那种），则结点 data[i] 的左孩子是 data[2*i+2] ,堆调整算法的成员函数定义如下：

/*****************
堆调整算法
******************/
void Sort::Sift(int k, int last)
{
	int i, j, temp;
	i = k; j =2 * i + 1; // i是被筛选结点，j是i的左孩子
	
	while (j <= last) //筛选还没有进行到叶子
	{
		if (j < last && data[j] < data[j+1]) 
			j++; // j指向左右孩子的较大者
		if (data[i] > data[j])
			break; //已经是堆
		else
		{
			temp = data[i]; data[i] = data[j]; data[j] = temp;
			i = j; j = 2 * i + 1; //被筛结点位于原来结点j的位置
		}
	}
}

堆排序

最后结果是升序序列

/*****************
堆排序算法
******************/
void Sort::HeapSort( )
{
	int i, temp;
	for (i = ceil(length/2) - 1; i >= 0; i--) //从最后一个分支结点至根结点
		Sift(i, length-1) ;
	
	for (i = 1; i < length; i++)
	{
		temp = data[0]; data[0] = data[length-i]; data[length-i] = temp;
		Sift(0, length-i-1); //重建堆
	}
}

归并排序 Merge Sort

二路归并排序的递归算法（稳定）

/***********************
归并排序的递归算法
************************/
void Sort::MergeSort1(int first, int last)
{
	if (first == last)
		return; //待排序序列只有1个记录，递归结束
	else {
		int mid = (first + last)/2;
		
		MergeSort1(first, mid); //归并排序前半个子序列
		
		MergeSort1(mid+1, last); //归并排序后半个子序列
		
		Merge(first, mid, last); //将两个已排序的子序列合并
	}
}

将两个已排序的子序列合并

/*************************
合并相邻子序列算法
**************************/
void Sort::Merge(int first1, int last1, int last2)
{
	int *temp = new int[length]; //数组temp作为合并的辅助空间
	int i = first1, j = last1 + 1, k = first1;
	
	while (i <= last1 && j <= last2)
	{
		if (data[i] <= data[j])
		temp[k++] = data[i++]; //取较小者放入temp[k]
		else
		temp[k++] = data[j++];
	}
	
	while (i <= last1) //对第一个子序列进行收尾处理
		temp[k++] = data[i++];
	
	while (j <= last2) //对第二个子序列进行收尾处理
		temp[k++] = data[j++];
		
	for (i = first1; i <= last2; i++) //将合并结果传回数组r
		data[i] = temp[i];
		
	delete[ ] temp;
}

二路归并排序非递归算法

/**************************
归并排序的非递归算法
***************************/
void Sort::MergeSort2( )
{
	int h = 1; //初始时子序列长度为1
	while (h < length)
	{
		MergePass(h); //一趟归并排序
		h = 2 * h;
	}
}

/*******************！！！！！！！！！！！！！！！！！！
一趟归并算法
********************/
void Sort::MergePass(int h)
{
int i = 0;
while (i + 2 * h <= length) //待归并记录有两个长度为h的子序列
{
Merge(i, i+h-1, i+2*h-1);
i = i + 2 * h;
}
if (i + h < length)
Merge(i, i+h-1, length-1); //两个子序列一个长度小于h
}

各种排序技术的使用范例/总代码

（每次只能运行一次）

/************************************************
    排序类Sort的类定义、各种排序算法及使用范例 
*************************************************/
#include <iostream> 
#include <cmath>
using namespace std; 

class Sort
{
public:
    Sort(int r[ ], int n);                           //构造函数，生成待排序序列
    ~Sort( );                                   //析构函数
	void InsertSort( );                            //直接插入排序
	void ShellSort( );                            //希尔排序
	void BubbleSort( );                           //起泡排序
	void QuickSort(int first, int last);                //快速排序
	void SelectSort( );                            //简单选择排序
	void HeapSort( );                             //堆排序
	void MergeSort1(int first, int last);               //二路归并递归排序
	void MergeSort2( );                           //二路归并非递归排序
	void Print( );                                //输出序列 
private:
	int Partition(int first, int last);                   //快速排序，一次划分
	void Sift(int k, int last);                        //堆排序，堆调整
	void Merge(int first1, int last1, int last2);          //归并排序，合并相邻有序序列
	void MergePass(int h);                        //归并排序，一趟归并

    int *data;                                  //待排序序列
    int length;
};

void Sort::InsertSort( )          
{	
  	int i, j, temp;
  	for (i = 1; i < length; i++)                      //排序进行length-1趟
  	{ 
		temp = data[i];                                //暂存待插记录
		for (j = i - 1; j >= 0 && temp < data[j]; j--)     //寻找插入位置
			data[j + 1] = data[j];                
		data[j + 1] = temp;	
  	}
}

void Sort::BubbleSort( )      
{	
	int j, exchange, bound, temp;
	exchange = length - 1;           //第一趟起泡排序的区间是[0~length-1]
	while (exchange != 0)            
	{
		bound = exchange; exchange = 0;  
		for (j = 0; j < bound; j++)       //一趟起泡排序的区间是[0~bound]
			if (data[j] > data[j+1]) {
				temp = data[j]; data[j] = data[j+1]; data[j+1] = temp;
				exchange = j;           //记载每一次记录交换的位置
			}
	}
}

void Sort::MergePass(int h) 
{
	int i = 0;
	while (i + 2 * h <= length)           //待归并记录有两个长度为h的子序列
	{
		Merge(i, i+h-1, i+2*h-1);
		i = i + 2 * h;
	}
	if (i + h < length) 
		Merge(i, i+h-1, length-1);    //两个子序列一个长度小于h
}

void Sort::MergeSort2( )      
{
	int h = 1;                            //初始时子序列长度为1
	while (h < length)
	{
		MergePass(h);                     //一趟归并排序
		h = 2 * h;
	}
}

void Sort::SelectSort( )       
{   
	int i, j, index, temp;
	for (i = 0; i < length - 1; i++)  	        //进行length-1趟简单选择排序
	{  
		index = i; 		
		for (j = i + 1; j < length; j++)         //在无序区中选取最小记录
			if (data[j] < data[index]) index = j;
		if (index != i) {
			temp = data[i]; data[i] = data[index]; data[index] = temp;
		}
	}
}

void Sort::Sift(int k, int last)        
{
  	int i, j, temp;
  	i = k; j =2 * i + 1;                // i是被筛选结点，j是i的左孩子
  	while (j <= last)                  //筛选还没有进行到叶子
  	{
    	if (j < last && data[j] < data[j+1]) j++;     // j指向左右孩子的较大者
		if (data[i] > data[j]) 
			break;               //已经是堆
		else 
		{
  			temp = data[i]; data[i] = data[j]; data[j] = temp;   
  			i = j; j = 2 * i + 1;                //被筛结点位于原来结点j的位置
		}
  	}
}

void Sort::HeapSort( )     
{
  	int i, temp;
  	for (i = ceil(length/2) - 1; i >= 0; i--)       //从最后一个分支结点至根结点
		Sift(i, length-1) ;     
  	for (i = 1; i < length; i++)         
  	{
    	temp = data[0]; data[0] = data[length-i]; data[length-i] = temp; 
		Sift(0, length-i-1);                          //重建堆
  	}
}

void Sort::Merge(int first1, int last1, int last2) 
{
	int *temp = new int[length];           //数组temp作为合并的辅助空间
	int i = first1, j = last1 + 1, k = first1;
	while (i <= last1 && j <= last2)
	{   
		if (data[i] <= data[j]) 
			temp[k++] = data[i++];    //取较小者放入temp[k]
		else 
			temp[k++] = data[j++]; 
	}
	while (i <= last1)                  //对第一个子序列进行收尾处理
		temp[k++] = data[i++]; 
	while (j <= last2)                  //对第二个子序列进行收尾处理
		temp[k++] = data[j++];  
	for (i = first1; i <= last2; i++)         //将合并结果传回数组r
	    data[i] = temp[i];
	delete[ ] temp;
}

void Sort::MergeSort1(int first, int last)
{ 
	if (first == last) 
  		return;        //待排序序列只有1个记录，递归结束
  	else {
		int mid = (first + last)/2;
		MergeSort1(first, mid);          //归并排序前半个子序列
		MergeSort1(mid+1, last);        //归并排序后半个子序列
		Merge(first, mid, last);            //将两个已排序的子序列合并
	}
}

void Sort::ShellSort( )        
{	
	int temp, d, i, j;
	for (d = length/2; d >= 1; d = d/2)         //增量为d进行直接插入排序
	{
		for (i = d; i < length; i++)               //进行一趟希尔排序
		{
			temp = data[i];                    //暂存待插入记录
			for (j = i - d; j >= 0 && temp < data[j]; j = j - d)
				data[j + d] = data[j];                //记录后移d个位置
			data[j + d] = temp;
		}
	}
}

Sort :: Sort(int r[ ], int n)
{
  	data = new int[n];
  	for (int i = 0; i < n; i++)
    	data[i] = r[i];
  	length = n;
}

Sort :: ~Sort( )
{
  	delete[ ] data;
}

void Sort :: Print( )
{
  	for (int i = 0; i < length; i++)
    	cout << data[i] << "\t";
}

int Sort::Partition(int first, int last)
{	
	int i = first, j = last, temp;              //初始化一次划分的区间
	while (i < j)	
	{
		while (i < j && data[i] <= data[j]) j--;      //右侧扫描
		if (i < j) { 
			temp = data[i];	data[i] = data[j]; data[j] = temp; 
			i++; 
		}
		while (i < j && data[i] <= data[j]) 
			i++;     //左侧扫描
		if (i < j) {
			temp = data[i]; data[i] = data[j]; data[j] = temp;  
			j--; 
		}
	}
	return i;                           // i为轴值记录的最终位置
}

void Sort::QuickSort(int first, int last)
{	
  	if (first >= last) 
  		return;                            //区间长度为1，递归结束
  	else 
  	{
		int pivot = Partition(first, last);     //一次划分
		QuickSort(first, pivot-1);         //对左侧子序列进行快速排序
		QuickSort(pivot+1, last);         //对右侧子序列进行快速排序
	}
}

int main( )
{
	int select, r[10] = {2, 5, 7, 1, 9, 4, 3, 6, 5, 8};
  	cout << "原数据是：";
  	for(int i = 0; i < 10; i ++ )
  		cout << r[i] << " ";
  	cout << endl;
  	Sort L(r, 10);
  	cout << "1. 直接插入排序      2. 希尔排序" << endl;
  	cout << "3. 起泡排序          4. 快速排序" << endl;
  	cout << "5. 简单选择排序      6. 堆排序" << endl;
  	cout << "7. 二路归并递归排序  8. 二路归并非递归排序" << endl;
  	cout << "请输入使用的排序技术编号：" ;
  	cin >> select;
  	switch (select)
  	{
    	case 1: L.InsertSort( ); break;     
		case 2: L.ShellSort( ); break;
		case 3: L.BubbleSort( ); break;      
		case 4: L.QuickSort(0, 9); break;
		case 5: L.SelectSort( ); break;       
		case 6: L.HeapSort( ); break;
		case 7: L.MergeSort1(0, 9); break;  
		case 8: L.MergeSort2( ); break;
		default : cout << "输入排序编号错误" << endl; break;
  	}
	L.Print( );
	return 0;
}
懒回顾，半缘君
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++排序算法：归并排序详解
小天狼星_布莱克 的博客
07-17 3万+
C++排序算法：归并排序详解
c++排序算法
11-24
此排序算法为本人平常学习练习所写，在学习的过程中也是非常希望和大家分享交流
第一次练习笔记（排序算法）
weixin_53946236的博客
03-20 638
冒泡排序 冒泡排序（Bubble sort）,是一种简单的排序算法。 它重复地循环要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。 算法步骤 比较相邻的元素。如果第一个比第二个大，就交换他们两个。 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。 针对所有的元素重复以上的步骤，除了最后一个。 持续每次对越来越少的元素重..
排序算法之简单排序
小浦原的技术专栏
02-26 781
//冒泡排序算法void BubbleSort(int *Data,int n) { int i,j,temp; bool exchange; for(i=n-1,exchange=true;i>0 && exchange;i-- ) { for(j=0,exchange=false;j<i;j++) { if(Data[j+1]<Data[j
常见排序算法之快速排序原理及递归非递归版本代码
JM-Nie的博客
10-19 466
目录快速排序原理复杂度分析选择排序代码1.递归版本2.非递归版本测试及结果测试结果 快速排序原理 之前介绍过三种基础的排序算法以及它们之间的比较：冒泡排序，选择排序和直接插入排序，我们知道它们的时间复杂度都是O(n2)，那是不是所有的算法的时间复杂度都是O(n2)呢？当然不是！下面我们介绍的快速排序之所以叫快速排序就是因为目前已有的排序算法中，快速排序的时间复杂度是最小的。 快速排序的基本思想：通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分小，则可以分别对这两部分记录继续进行排
C++-排序算法详解
一然明月(嵌入式)的博客
06-06 1254
排序算法是一种将一组数据按照特定顺序（如升序或降序）进行排列的算法。其主要目的是对一组无序的数据进行整理，使得它们呈现出一定的有序性。主要排序算法有:冒泡排序.插入排序,快速排序.选择排序,归并排序,堆排序.
C++ sort()排序详解
热门推荐
晴空๓
05-05 39万+
本文对C++中的sort()做了一个比较详细的说明，包括为什么选择使用sort()、sort()函数的实现原理、sort()的使用方法等等。
c++十大经典排序算法
客舟中
12-28 6076
代码 1 冒泡排序 冒泡排序是一种简单直观的入门排序算法。它的原理就是从第一个元素开始，与后面的元素逐个比较，如果顺序不对就交换，直到没有可比较的元素为止。 1 // 冒泡排序 2 void BublingSort(int *arr, int len) 3 { 4 if(len == 0) 5 { 6 return; 7 } 8 std::cout<<"冒泡排序"<<std::endl; 9 for(i
C++八种排序算法万字详解
我的博客
06-04 7481
哈喽，今天我来总结一下C++中的8中排序方法，这些排序在实际开发中能起到一些作用，也可以锻炼你的算法头脑。我也好长时间没上热榜了，这次准备做一个非常详细🔎的总结，看看能不能上热榜。既然叫排序算法，肯定要排序。我们要实现的效果是输入几个数，输出升序（或降序）排序后的结果，并找到时间复杂度最低的算法，应用到实际开发中。冒泡排序主要思路就是遍历数组，比较两个相邻的元素，也就是 arr[j] 和 arr[j+1] ，如果顺序错误就用 swap 函数或空杯交换，交换这两个元素。举个例子，数组是 a[5]={2,1,.
C++实现排序算法
ymhdt的博客
04-12 1万+
一、冒泡排序 上浮法 ：从数组末尾开始，连续比较相邻两个元素，使其符合排序。比较一个循环后，处于数组前排的元素最先符合（最大 or 最小），不再参与下一个循环的比较。 下沉法：从数组开头开始，连续比较相邻两个元素，使其符合排序。比较一个循环后，处于数组后排的元素最先符合（最大 or 最小），不再参与下一个循环的比较。 冒泡法最优时间复杂度可以达到O(n)，最差可以达到O（n^2） 【注】如果上一次循环已经符合排序，即没有交换过一次，则已经排序完成，得到结果，不需要再进行下一次循环 参考代码 C+.
c++排序算法-冒泡排序
11-08
冒泡排序是一种基础且经典的计算机科学排序算法，尤其在C++编程中常见。它通过不断地比较相邻元素并根据需要进行交换，逐步将较大的元素“冒泡”到序列的末尾，从而实现升序排列。这一过程可以理解为一个逐层推进的...
简单的C++排序算法
11-21
一看就懂，一学就会的C++排序算法。学习数组使用，用数组下标进行选择排序，用双循环实现选择排序。 选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小...
C++排序算法之插入排序
08-25
C++排序算法之插入排序 本文主要介绍了C++排序算法之插入排序的基本思想、算法实现和时间复杂度分析。插入排序是一种简单的排序算法，通过将未排序的数据元素按大小顺序插入到已排好序数据序列中实现排序。 基本...
C++ 排序算法之冒泡排序
07-25
C++ 排序算法之冒泡排序
如何搭建互联网医院系统源码？医疗陪诊APP开发实战详解
最新发布
meihusdk的博客
07-11 89
希望本文能够为正在或即将从事相关开发的技术人员提供一些参考和帮助。通过不断的努力和创新，我们可以为患者提供更优质的医疗服务，推动医疗行业的数字化转型。
WVP后端项目文件结构
招风的黑耳CSDN
07-08 299
WVP（Web Video Platform）是一个基于GB28181-2016标准实现的网络视频平台，负责实现核心信令与设备管理后台部分，支持NAT穿透，支持海康、大华、宇视等品牌的IPC、NVR、DVR接入。支持国标级联，支持rtsp/rtmp等视频流转发到国标平台，支持rtsp/rtmp等推流转发到国标平台。支持浏览器无插件播放摄像头视频。支持国标设备(摄像机、平台、NVR等)设备接入 支持非国标(onvif, rtsp, rtmp，直播设备等等)设备接入，充分利旧。支持跨网网闸平台互联。
基于若依的文件上传、下载
谁说自己不可以
07-06 1087
基于若依的文件上传、下载、详细步骤。
uniapp实现table排序
qq_39772439的博客
07-11 69
uniapp实现table排序
c++排序算法及其实现
05-19
C++中有许多不同的排序算法，包括冒泡排序、选择排序、插入排序、快速排序、希尔排序、归并排序等等。以下是其中一些算法的实现示例： 1. 冒泡排序 ``` void bubbleSort(int arr[], int n) { int i, j; for (i =...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值