基本排序算法实现汇总

最新推荐文章于 2020-07-13 17:58:08 发布
最新推荐文章于 2020-07-13 17:58:08 发布
阅读量139 收藏
点赞数
分类专栏： 数据结构 C/C++ 算法 文章标签： 排序算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wcl0617/article/details/107177174
版权
C/C++ 同时被 3 个专栏收录
47 篇文章 1 订阅
订阅专栏
算法
18 篇文章 0 订阅
订阅专栏
数据结构
7 篇文章 0 订阅
订阅专栏

最近有空复习了一下排序算，这里将各种基本排序算法实现总结了一遍，并整理到了一个类中，方便以后查询。
头文件

#ifndef _SORT_UTILS_H_
#define _SORT_UTILS_H_
#include <vector>
using namespace std;

template<class T>
class CSortUtils
{
public:
	CSortUtils();
	virtual ~CSortUtils();
	typedef struct node{
		T key;
		struct node *lChild, *rChild;
		node(T value) :key(value),lChild(NULL), rChild(NULL){}
	}Node,*BST;
public:
	void SelectSort(T *arrays, int size);
	void BubbleSort(T *arrays,int size);
	void InsertSort(T *arrays, int size);
	void ShellSort(T *arrays, int size);
	void QuickSort(T *arrays,int left,int right);
	void MergeSort(T *arrays, int left, int right);	
	void HeapSort(T *arrays, int size);
	void BSTreeSort(T *arrays, int size);
    void CountSort(int *arrays, size_t size);//计数排序，适用于无符号整型
private:
	void Swap(T &a,T &b);
	void Merge(T *arrays, int left, int right);
	void HeapAdjust(T *arrays,int pAdjust, int size);
	void CreateBST(BST &N, T *arrays, int size);
	void BSTInsert(BST &N,T value);
	void InOrderTraverse(BST N, vector<T>& temp);
	void ReleaseTreeNode(BST N);
};

实现文件

template<class T>
CSortUtils<T>::CSortUtils()
{
}

template<class T>
CSortUtils<T>::~CSortUtils()
{
}

template<class T>
void CSortUtils<T>::Swap(T& a, T& b)
{
	T temp = a;
	a = b;
	b = temp;
}

/*
排序过程：给定一个数值集合，循环遍历集合，
每次遍历从集合中选择出最小或最大的放入集
合的开头或结尾的位置，下次循环从剩余的元
素集合中遍历找出最小的并如上操作，最后直
至所有原集合元素都遍历完毕，排序结束。
分析总结：选择排序时间复杂度比较高，达到了O（n^2），
每次选择都要遍历一遍无序区间。选择排序对一类重要的
元素序列具有较好的效率，就是元素规模很大，而排序码
却比较小的序列。另外要说明的是选择排序是一种不稳定
的排序方法。
*/
template<class T>
void CSortUtils<T>::SelectSort(T *arrays, int size)
{
	int nIndex;//记录最值索引
	for (int i = 0; i < size;++i)
	{
		nIndex = i;
		for (int j = i + 1; j < size;++j)
		{
			if (arrays[nIndex] > arrays[j])
			{
				nIndex = j;
			}
		}

		if (nIndex != i)
		{
			Swap(arrays[nIndex],arrays[i]);
		}
	}
}

/*
排序过程：冒泡排序的过程形如其名，就是依次比较相邻
两个元素，优先级高（或大或小）的元素向后移动，直至
到达序列末尾，无序区间就会相应地缩小。下一次再从无
序区间进行冒泡操作，依此循环直至无序区间为1，排序结束。

分析总结：冒泡排序的时间复杂度也比较高，达到O（n^2），
每次遍历无序区间都将优先级高的元素移动到无序区间的末
尾。冒泡排序是一种稳定的排序方式。
*/
template<class T>
void CSortUtils<T>::BubbleSort(T *arrays, int size)
{
	for (int i = 0; i < size;++i)
	{
		for (int j = 1; j < size - i;++j)
		{
			if (arrays[j]<arrays[j-1])
			{
				Swap(arrays[j],arrays[j - 1]);
			}
		}
	}
}

/*
排序过程：将前面的区间（初始区间为1，包含第一个元素）视作有序区间，
然后将有序区间的后一元素插入到前面有序区间的适当位置。直至有有序区
间扩展到原区间的大小，排序结束。
分析总结：插入排序的时间复杂度达到O（n^2），排序的运行时间和待排序
元素的原始排列顺序密切相关。插入排序是一种稳定的排序方法。
*/
template<class T>
void CSortUtils<T>::InsertSort(T *arrays, int size)
{
	for (int i = 1; i < size;++i)
	{
		T temp = arrays[i];
		int j = i-1;
		for (; j>0&&temp<arrays[j];--j)//将第i个元素插入前面有序序列中
		{
			arrays[j+1] = arrays[j];				
		}
		arrays[j+1] = temp;
	}
}

/*
将无序数组分割为若干个子序列，子序列不是逐段分割的，而是相隔特定的增量的子序列，
对各个子序列进行插入排序；然后再选择一个更小的增量，再将数组分割为多个子序列进
行排序......最后选择增量为1，即使用直接插入排序，使最终数组成为有序.
希尔排序Shell Sort是基于插入排序的一种改进,增量的取值规则为第一次取总长度的一半,
第二次取一半的一半,依次累推直到1为止.
分析总结：希尔排序的时间复杂度为O（n的3/2次方），是一种不稳定的排序算法。
*/
template<class T>
void CSortUtils<T>::ShellSort(T *arrays, int size)
{	
	for (int nStep = size / 2; nStep > 0; nStep /= 2)//取步长
	{
		//从第nStep个元素，逐个对其所在组进行直接插入排序操作
		for (int i = nStep; i<size; i++)
		{
			int j = i;
			while (j - nStep >= 0 && arrays[j]<arrays[j - nStep])
			{
				//插入排序采用交换法
				Swap(arrays[j], arrays[j - nStep]);
				j -= nStep;
			}
		}
	}
}

/
/*
排序过程：快速排序应该是应用最广泛的排序算法，它是采用了分治的思想（这种思想很重要）。
其基本的思想就是任取待排序序列中的某个元素（元素的选取方式在一定程序上会影响实现过程和排序效率）作为标杆，
将待排序序列划分为左右两个子序列，左侧元素小于标杆元素，右侧元素大于标杆元素，标杆元素则排在这两个子序列的中间，
然后再对这两个子序列重复上述的方法，直至排序结束。
分析总结：快速排序的时间复杂度为O（nlogn），是一种不稳定的排序算法。
*/
template<class T>
void CSortUtils<T>::QuickSort(T *arrays, int left, int right)
{
	if (left < right)
	{
		int i = left - 1;
		int j = right + 1;
		T mid = arrays[(left + right) / 2];//标杆元素
		while (true)
		{
			while (arrays[++i] < mid);
			while (arrays[--j] > mid);
			if (i >= j)
			{
				break;
			}
			Swap(arrays[i], arrays[j]);
		}
	
		QuickSort(arrays, left, i - 1);
		QuickSort(arrays, j + 1, right);
	}
}

/*
排序过程：归并排序的原理比较简单，也是基于分治思想的。
它将待排序的元素序列分成两个长度相等的子序列，然后为
每一个子序列排序，然后再将它们合并成一个序列。
分析总结：归并排序最好、最差和平均时间复杂度都是O（nlogn），
是一种稳定的排序算法。
*/
template<class T>
void CSortUtils<T>::Merge(T *arrays, int left, int right)
{
	T *temp = new T[right-left+1];
	int mid = (left + right) / 2;
	int i = left, j = mid + 1, m = 0;
	while (i <= mid && j<= right)
	{
		if (arrays[i]>arrays[j])//将小的放前面
		{
			temp[m++] = arrays[j++];
		}
		else
		{
			temp[m++] = arrays[i++];
		}
	}

	while (i<=mid)//将多余的元素直接存入
	{
		temp[m++] = arrays[i++];
	}

	while (j <= right)//将多余的元素直接存入
	{
		temp[m++] = arrays[j++];
	}

	for (int n = left, m = 0; n <= right;++n,++m)
	{
		arrays[n] = temp[m];
	}

	delete temp;
}

template<class T>
void CSortUtils<T>::MergeSort(T *arrays, int left, int right)
{
	if (left < right)
	{
		int mid = (left+right) / 2;
		MergeSort(arrays,left,mid);//左
		MergeSort(arrays,mid+1,right);//右
		Merge(arrays, left, right);
	}
}

/*
排序过程：堆排序的过程分为两个步骤，第一步是根据初始输入数据，建立一个初始堆；
第二步是将堆顶元素与当前无序区间的最后一个元素进行交换，然后再从堆顶元素开始对堆进行调整。
分析总结：堆排序的算法时间复杂度为O（nlogn），它是一种不稳定的排序算法。
*/
template<class T>
void CSortUtils<T>::HeapAdjust(T *arrays, int pAdjust, int size)
{
	int pos = pAdjust;//父节点
	while (2*(pos+1)<size)
	{
		int lChild = 2 * pos + 1;
		if (arrays[lChild]>arrays[pos])//左孩子比父节点大
		{
			pos = lChild;
		}
		int rChild = lChild + 1;
		if (rChild<size&&arrays[rChild]>arrays[pos])//右孩子更大
		{
			pos = rChild;
		}

		if (pos != pAdjust)
		{
			Swap(arrays[pAdjust], arrays[pos]);
			pAdjust = pos;
		}
		else
		{
			break;
		}
	}
}

template<class T>
void CSortUtils<T>::HeapSort(T *arrays, int size)
{
	//建堆
	int pos = size / 2;
	for (int i = pos - 1; i >= 0;--i)
	{
		HeapAdjust(arrays,i,size);
	}
	//排序
	for (int j = size - 1; j > 0;)
	{
		Swap(arrays[0], arrays[j]);		
		HeapAdjust(arrays, 0, j);
		j--;
	}
}

/*
排序过程：排序树算法应用了AVL树的原理，只不过排序树不是平衡的，
它的特点就是父结点元素总是比左孩子元素要大却比右孩子元素要小。
根据这个特点，可以将原数组元素组织成排序树，然后在对排序树进行
中序遍历，中序遍历的结果就是排好序的序列。
分析总结：算法中排序树建立的时间复杂度是O（nlogn），中序遍历的
时间复杂度是O（n），故排序树排序的时间复杂度为O（nlogn）
*/
template<class T>
void CSortUtils<T>::CreateBST(BST &N, T *arrays, int size)
{
	N = NULL;
	for (int i = 0; i < size;++i)
	{
		BSTInsert(N,arrays[i]);
	}
}

template<class T>
void CSortUtils<T>::BSTInsert(BST &N, T value)
{
	if (NULL == N)
	{
		N = new Node(value);
		return;
	}

	if (value <= N->key)//
	{
		return BSTInsert(N->lChild, value);
	}

	return BSTInsert(N->rChild, value);
}

template<class T>
void CSortUtils<T>::InOrderTraverse(BST N, vector<T>& temp)
{
	if (NULL != N)
	{
		InOrderTraverse(N->lChild, temp);
		temp.push_back(N->key);
		//printf("%d,", N->key);
		InOrderTraverse(N->rChild, temp);
	}
}

template<class T>
void CSortUtils<T>::BSTreeSort(T *arrays, int size)
{
	BST N = NULL;

	CreateBST(N,arrays,size);
	vector<T> temp;
	temp.reserve(size);
	InOrderTraverse(N, temp);
	//int nLen = size;
	for (int i = 0; i < size;++i)//升序
	{
		arrays[i] = temp[i];
	}

	ReleaseTreeNode(N);
}

template<class T>
void CSortUtils<T>::ReleaseTreeNode(BST N)
{
	if (NULL != N)
	{
		ReleaseTreeNode(N->lChild);
		ReleaseTreeNode(N->rChild);
	
		delete N;
		N = NULL;
	}
}

/*
计数排序，适用于无符号整型
计数排序是一种非比较的排序算法，线性时间排序
优势：
计数排序在对于一定范围内的整数排序时，时间复杂度为O(N+K)（K为整数在范围）快于任何比较排序算法，因为基于比较的排序时间复杂度在理论上的上下限是O(N*log(N))。
缺点：
计数排序是一种牺牲空间换取时间的做法，并且当K足够大时O（K）>O(N*log(N)),效率反而不如比较的排序算法。并且只能用于对无符号整形排序。
时间复杂度：
O（N）  K足够大时为O（K）
空间复杂度：
O（最大数-最小数）
性能：
计数排序是一种稳定排序
*/
template<class T>
void CSortUtils<T>::CountSort(int *arrays, size_t size)
{
	assert(a);
	size_t max = a[0];
	size_t min = a[0];
	for (size_t i = 0; i < size; ++i)
	{
		if (a[i] > max)
		{
			max = a[i];
		}
			if (a[i] < min)
		{
			min = a[i];
		}
	}
	size_t range = max - min + 1;   //要开辟的数组范围 
	size_t* count = new size_t[range];
	memset(count, 0, sizeof(size_t)*range);  //初始化为0 
	//统计每个数出现的次数 
	for (size_t i = 0; i < size; ++i)   //从原数组中取数，原数组个数为size 
	{
		count[a[i] - min]++;
	}
	//写回到原数组 
	size_t index = 0;
	for (size_t i = 0; i < range; ++i)  //从开辟的数组中读取，开辟的数组大小为range 
	{
		while (count[i]--)
		{
			a[index++] = i + min;
		}
	}
	delete[] count;
}

测试代码：

#include "SortUtils.h"
int main(int argc, char* argv[])
{
	CSortUtils<int> sorter;
	int a[] = {55,28,27,5,48,32,11,10,92,5,3};
	int nLen = 11;

	//print
	printf("排序前：");
	for (int i = 0; i < nLen; ++i)
	{
		if (0 == i)
		{
			printf("%d", a[i]);
		}
		else
		{
			printf(",%d", a[i]);
		}
	}
	printf("\n");
	//sorter.QuickSort(a,0,nLen-1);
	//sorter.SelectSort(a, 10);
	//sorter.BubbleSort(a, 10);
	//sorter.InsertSort(a, 10);
	sorter.ShellSort(a, 11);
	//sorter.MergeSort(a, 0, nLen - 1);
	//sorter.HeapSort(a, 11);
	//sorter.BSTreeSort(a, 11);
	//print
	printf("排序后：");
	for (int i = 0; i < nLen; ++i)
	{
		if (0==i)
		{
			printf("%d", a[i]);
		}
		else
		{
			printf(",%d", a[i]);
		}
	}
	getchar();
	return 0;
}

各种排序的稳定性，时间复杂度和空间复杂度
​在这里插入图片描述
参考：http://www.cnblogs.com/kkun/archive/2011/11/23/2260312.html
http://blog.csdn.net/lcj_cjfykx/article/details/43924793

Away-Far
关注
专栏目录
常见的排序算法实现
qq_45813977的博客
08-10 914
本文部分代码参考2022年王道数据结构实现，所有代码均可运行。不做过多原理解释，可以结合王道内容来理解代码，最后在自己电脑上实现。
基本排序算法实现
qq_40148886的博客
03-15 131
一、简单选择排序 　　1、简单选择排序的思想是这样的：首先，找到数组中最小的元素，其次，将它和数组中的第一个元素交换位置。再次，在剩下的元素中寻找最小的元素，然后将它和数组中第二个元素交换位置，这样往复进行，知道到数组中最后一个元素的时候就变成了有序数组。 　　2、简单选择排序算法：对于长度为N的数组，需要N2/2次比较和N次交换。 　　3、下面是一次选择排序的流程：从下面的流程...
基础排序算法及代码实现
博客小站
08-25 218
交换类 插入排序类 选择排序类
基本的排序算法原理与实现
松子茶的专栏
08-25 3055
本节主要介绍基本的排序算法 ，即：插入排序，选择排序，冒泡排序.插入排序首先考虑data中的前两个元素，即data[0]和data[1]。如果它们的次序颠倒了，就交换它们。然后，考虑第三个元素data[2],将其插入到合适的位置上。如果data[2]同时小于data[0]和data[1],那么data[0]和data[1]都要移动一个位置；data[0]放在位置1上，data[1]放在位置2上，而将data[2]放在位置0上。如果data[2]小于data[1]，而不于data[0],那么只须把data[1
几种基本排序算法的实现
林竹清_清清清
04-16 229
package test.sort; import org.junit.Test; /** @Author lingl @Date 2020/4/16 */ public class SortTest { @Test public void test() { int[] array = new int[] {5, 3, 4, 1, 3, 6, 2}; quickSo...
python 常见的排序算法实现汇总
09-16
本文将深入探讨几种常见的排序算法及其Python实现，包括冒泡排序、选择排序、插入排序、希尔排序、快速排序和归并排序。这些算法主要分为比较类排序，它们通过元素之间的比较来决定顺序。 1. **冒泡排序**：冒泡...
python常用排序算法汇总
02-19
该程序包含7大排序算法: # sort.bubbleSort() #冒泡排序 # sort.shellSort() #希尔排序 # sort.insertionSort() #插入排序 # sort.Selectionsort1() #选择排序 # sort.heapSort() #堆排序 # sort.countSort() ...
基于C++实现的各种内部排序算法汇总
12-31
（另：至于堆排序算法，前面已经有一篇文章针对堆排序的算法实现做了详细的描述） C++实现代码如下： /************************************************************************* > File Name: sort.cpp > ...
C++实现各种排序算法类汇总
09-04
C++实现各种排序算法类汇总 C++实现各种排序算法类是一种常用的算法实现方式，旨在提供多种排序算法的实现代码，以便开发者可以根据实际情况选择合适的排序算法。下面是对该实现的详细介绍： 一、直接插入排序 ...
常用排序算法总结----选择排序(java实现)
Franky
08-07 248
选择排序（Selection Sort） 选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。 选择排序的主要优点与数据移动有关。如果某个元素位于正确的最终位置上，则它不会被移动。选择排序每...
常见排序算法及其实现
qq_39158142的博客
11-20 258
算法优劣： 执行效率 内存消耗，看是否是原地排序（既不需要额外的空间） 稳定性 ，即相同元素，如果排序前 a1 在 a2 前，排序完依旧是这样 根据比较来进行排序的算法有：冒泡，插入，选择 。 一 基于比较和交换的算法： 1 冒泡算法： 每次通过比较来判断与后一位的大小关系，来确定是否交换，每次内层循环结束，表明有一个最大的或者是最小的被筛选出来。如果某次循环没有进行过任何的交换，说...
各种常见排序算法实现
icebod的博客
03-19 763
各种常见排序算法实现 近日受一兄台影响，也想学习记录些东西，于是也尝试开始写博客。 排序算法算是最为简单经典的算法问题了，因此从这个开始学习记录，以加深印象。 其中常见的排序算法有： 选择排序 冒泡排序 插入排序 合并排序 快速排序 堆排序 以上排序算法一定无法罗列全部排序算法的大家族，但是暂且讨论以上的算法。 选择排序和冒泡排序属于蛮力解决问题的表现； 插入排序则使用减治法； 合并排序和...
十种基本排序算法
wolfGuiDao的博客
10-05 2251
十种基本排序算法 代码自己慢慢找哈 #define _CRT_SECURE_NO_WARNINGS #include<Windows.h> #include<stdio.h> #define MaxSize 10//归并排序，桶排序等排序时需要申请和原数组一样大小的空间时用到，方便修改 //快排 int QuickShortchild(int *str, int lef...
八大排序算法原理及实现
Yannick Jiang 的专栏
04-15 6164
原文链接：八大排序算法原理及实现 概述 排序有内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。 我们这里说说八大排序就是内部排序。 当n较大，则应采用时间复杂度为O(nlog2n)的排序方法：快速排序、堆排序或归并排序。 快速排序：是目前基于比较的内部排序中被认为是最...
几种简单排序算法总结以及实现
lilian的博客
03-18 138
以下例子均以升序排序为例，队列长队为n（即代码中的len） 冒泡排序 冒泡排序的本质在于交换，每一趟冒泡结束都选出最大的数放在队列的尾部，整个过程会执行n-1趟，每一趟从左到右依次比较相邻的两个数，如果左边的数比右边的大，则交换顺序。冒泡排序的算法时间复杂度是O(n2)O\left(n^2\right)O(n2) // 传进来的是变量的地址，所以可以真正地修改变量 void swap(int...
常用排序算法总结及代码实现
Fan的博客
07-13 415
排序算法可以说是我第一个接触的算法，将一个无序序列按某个规则进行有序排列，而排序算法多种多样，深入理解排序算法，选择最适合的那个算法去解决问题，是我们应该学习和掌握的。 1. 冒泡排序 冒泡排序算法是排序算法中最基础的一种，它的本质在于两个数之间的交换，如果按从小到大的顺序将某一无序序列进行排序，冒泡的思想就是每次通过交换的方式将当前剩余元素的最大值放到一端，直到元素的个数减少为0。 例如：存在一个无序序列{8，9，6，5，7，3，2，1，4，0}，使用冒泡算法按从小到大的顺序进行排序。 实现代码： #i
各种排序算法实现及总结
周大侠的专栏
08-21 664
本文主要比较一下各种排序的性能（平均时间复杂度和最差情况）和基本实现。 这个默认按照从小到大排列，输入的数据可以重复，假设输入的数组为A，下标从0到N-1注意在比较算法复杂度时，我们会关注键值的比较次数和交换次数。1、冒泡排序 冒泡排序如果不是因为名字比较好记，没有任何优势。它的思路是一趟又一趟的比较数组（或者链表也可以）中相邻的两个元素，如果前一个比后一个大，则交换。这样，每一轮之后，最大的那
常见排序算法汇总
Cong的专栏
10-31 287
常言道：温故而知新。最近有空复习了一下排序算，这里将各种基本排序算法实现总结了一遍，并整理到了一个类中，方便以后温习。各种排序实现，CSortUtils类文件：#ifndef _SORT_UTILS_H_ #define _SORT_UTILS_H_ #include &lt;vector&gt; using namespace std; template&lt;class T&gt; clas...
JAVA排序算法详解与实现
"这篇文档是关于JAVA排序算法的汇总，涵盖了多种常见的排序算法，并提供了相关的JAVA实现。排序算法包括插入排序、交换排序、选择排序、归并排序和基数排序。文档还提到了根据数据规模和初始顺序选择合适排序算法的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值