九种排序算法(C++实现)

这里是常用的九种排序算法的C++实现过程,附有详细的代码注释。因为要放假走人了所以具体细节日后再补充。

(以下所有代码均在VS2015与WIN10环境下执行成功)

2019.7.23更新:借鉴引用[3]文章的一张图来便于理解
九种排序算法(C++实现)_第1张图片

1. 插入排序

时间复杂度平均O(n2),最好O(n),最差O(n2),空间复杂度O(1),就地、稳定的排序;
思路为:从第一与第二个元素开始,不断考虑后缀的元素,将其插入到前缀中合适其的位置,随着插入,其后的所有位置都需要改变。类似于打扑克时的抽牌,不过这里的牌是全部知道的。

template<typename T> void insertionsort(T data[], int n)
{
	for (int i = 1, j; i < n; i++)
	{
		T tmp = data[i];
		for (j = i; j > 0 && tmp < data[j - 1]; j--)  //注意只有<才会移动,=不动的
			data[j] = data[j - 1];   //插入的数(也就是每次后缀的第一个数)不断与其前面的数字比较,比其大就向前交换,直至比它小或到数组头
		data[j] = tmp;  //最后退出的那个位置被tmp赋值进去补充即可
	}
}

2. 选择排序:最近似于人查找的方法

时间复杂度平均O(n2),最好O(n2),最差O(n2),空间复杂度O(1),就地、不稳定的排序;
思路为:遍历当前数组,查找数组中最小(大)的元素,将其与首元素(末元素)进行交换,然后降低搜索区间与交换区间。

template<typename T> void selectionsort(T data[], int n)
{
	for (int i = 0, j, least; i < n - 1; i++)   //i的最大值定为n-1,是为了保证在j在n时停止循环防止越界
	{
		for (j = i + 1, least = i; j < n; j++)  //每层外循环,将最小值位置i向后移动一位
			if (data[j] < data[least])			//如果处于最小值位置之后的元素比j小,则一直将位置传递给least
				least = j;
		if (i != least)							//此条件表示当前数已是最小时不需要交换,增加n-1次索引比较,减少某些特殊的交换次数
			swap(data[i], data[least]);			//最后直接交换i和least的元素即可,由于前面的循环,此时的least必然是后缀中最小元素对应的位置
												//这里就出现不稳定的原因,当数组中存在多个相同的数a时,可能在前面的a会被交换到后面的位置去(小的数在数组偏后的地方)
	}
}

3. 冒泡排序

时间复杂度平均O(n2),最好O(n),最差O(n2),空间复杂度O(1),就地、稳定的排序;
思路为:从头开始向尾遍历,如果后面的数比前面的数小(大),就交换,一直换到最后,再减小区间继续交换。

template<typename T> void bubblesort(T data[], int n)
{
	bool flag = false;
	while (!flag)
	{
		flag = true;    //作为标识符,当遍历之后仍为true,表示当前数组已经有序,直接跳出即可
		for (int i = 0; i < n - 1; i++)
		{
			if (data[i] > data[i + 1])  //遍历式交换,最终当前区间的最后一个数必然是区间内的最大数
			{
				swap(data[i], data[i + 1]);  //交换过程没有出现交叉,所以是稳定的
				flag = false;
			}
		}
		n--; //n递减,因为每过一次循环,当前区间的最后一个数都已经排序完成,所以通过此来减小区间
	}
}

4. 希尔排序

时间复杂度平均O(n1.3),最好O(n),最差O(n2),空间复杂度O(1),就地、不稳定的排序;
思路为:根据增量序列将整个数组区间划分为多个h子序列,之后根据增量序列依次递减重新划分重新排序,最后在一个序列中重排实现;
算法核心:增量序列,即shell序列的选取和确定。

template<typename T> void shellsort(T data[], int n)
{
	int k = 0, m = 1, increments[20];
	while (m < n / 3)						// 动态定义间隔序列(这是最常见的shell增量序列,这几十年对此的研究层出不穷,有更好的存在)    
	{
		increments[k++] = m;
		m = m * 3 + 1;						// {1,4,13,40,121,....的通用shell序列
	}
	for (m = k-1; m >= 0; m--)              //重复使用m,此处作用是遍历increment序列(从大到小)
	{
		int h = increments[m];              //h代表当前的分割步长,即增量序列中的数据提取

		/*从这里开始,实现对输入数组的分割与排序*/
		for (int i = h; i < 2 * h; i++)     //此处开始根据步长h来对数组分割,比如初始h=4,n=17,那么这里的i会取值4567四个数,实现数组的四段分割
		{

			/*从这里开始,实现对于被分割的数组的排序过程*/  //这里是对于每个分割的数组的单独排序算法,可选用不同的
			for (int j = i; j < n;)   //j为输入的初始值,j+h为下一位置,j
			{
				T temp = data[j];     //从当前数组的最左侧开始
				k = j;				  //保留j的数值,使用k来代替j进行插入排序运行
				while (k - h > 0 && temp < data[k - h])   //此处选用的是插入排序
				{
					data[k] = data[k - h];
					k -= h;			  //注意不是k--,步长为h
				}
				data[k] = temp;		  //最后退出的那个位置被temp赋值进去补充即可
				j += h;
			}

			/*以下是对于选择排序的尝试过程,可惜失败了*/
			//for (int j = i-h, k, least; j < n - h; j += h)
			//{
			//	for (k = j , least = j; k < n; k += h)		//每层外循环,将最小值位置i向后移动一位
			//	{
			//		cout << "k: " << k << endl;
			//		if (data[k] < data[least])			//如果处于最小值位置之后的元素比j小,则一直将位置传递给least
			//			least = k;
			//	}
			//	if (k != least)							//此条件表示当前数已是最小时不需要交换,增加一定的索引比较,减少某些特殊的交换次数
			//		swap(data[k], data[least]);			//最后直接交换i和least的元素即可,由于前面的循环,此时的least必然是后缀中最小元素对应的位置
			//}


		}
	}
}

5. 堆排序

时间复杂度平均O(nlog2n),最好O(nlog2n),最差O(nlog2n),空间复杂度O(1),就地、不稳定的排序
思路为:根据输入的数组重新建堆,不断地将堆的顶部与数组区间的尾部交换(交换后下滤并减小区间,保证堆的最大值一直在顶部)
算法核心:建堆,取最大值

template<typename T> void moveDown(T data[], int first, int last)  //堆的下滤算法,first为堆顶(数组的第一位),last为堆尾(数组的最后一位)
{													   //从堆的最底层开始,反层次遍历的顺序遍历每个有孩子的节点(自下而上,由浅至深),孩子比自己大就交换,继续按着孩子原来的位置下滤
	int largest = 2 * first + 1;                       //这里的largest计算的是first节点对应的左孩子位置
	while (largest <= last)							   //判断最大的孩子是否还在区间内
	{
		if (largest < last && data[largest] < data[largest + 1])   //此处判断largest是否刚好为末节点,或者查看first的左孩子右孩子哪边大,largest取大边
			largest++;
		if (data[first] < data[largest])               //first作为父节点,与其最大的孩子比较,如果孩子大就换上来;如果不是,代表该节点稳健,跳出
		{
			swap(data[first], data[largest]);          //大的子节点largest和父节点first交换,继续判断first的两个孩子与其的大小关系
			first = largest;
			largest = 2 * first + 1;
		}
		else
			//largest = last + 1;
			break;
	}
}

template<typename T> void heapsort(T data[], int size)
{	
	for (int i = size / 2 - 1; i >= 0; --i)    //建堆,floyid建堆法,即自下而上地下滤每个节点。从size的中部选值,保持所取值都是有孩子的节点,避免无关计算
		moveDown(data, i, size - 1);

	cout << "建堆后数组为:   ";
	for (int i = 0; i < size; i++)
		cout << data[i] << " ";
	cout << endl;

	for (int i = size - 1; i >= 1; --i)        //开始实质的堆排序,即不断地将data[0](当前的最大数)交换到数组的区间末尾
	{
		swap(data[0], data[i]);
		moveDown(data, 0, i - 1);			   //通过每次交换之后的下滤,保证数组的首元素一直都是最大值
	}
}

6. 快速排序

时间复杂度平均O(nlog2n),最好O(nlog2n),最差O(n2),空间复杂度O(nlog2n),不就地、不稳定的排序;
思路为:将整个数组不断的分而治之,到最后变成只有一个元素的数组(1个元素自然不需要排序),真正的排序发生在数组的不断的划分过程中;
算法核心:递归划分。

int partition(int save[], int lo, int hi)      //数组的划分函数,中心点为pivot,在划分之后,其大于左侧的所有数,小于右侧的所有数。划分到最后只剩一个元素,数组也就排序好了
{
	int p = save[lo];
	int l = lo, h = hi;
	while (lo < hi)                            //记下save[lo]的数值,从lo开始不断交替比对,当lo=hi时即找到中位点
	{
		while ((lo < hi) && (p <= save[hi]))
			hi--;
		save[lo] = save[hi];
		while ((lo < hi) && (p >= save[lo]))
			lo++;
		save[hi] = save[lo];
	}
	save[lo] = p;
	return lo;
}

void quicksort(int save[], int lo, int hi)
{
	if (hi - lo < 2)return;
	int mi = partition(save, lo, hi - 1);      //确定中位点(不是中点,是中位点pivot)
	quicksort(save, lo, mi);				   //通过在划分后两段区间内不断递归划分,到最后只剩单个一个元素(即hi-lo=1)时,划分完毕的同时也排序完毕
	quicksort(save, mi + 1, hi);
}

7. 归并排序

时间复杂度平均O(nlog2n),最好O(nlog2n),最差O(nlog2n),空间复杂度O(n),不就地、稳定的排序;
思路为:将整个数组不断的分而治之,到最后变成只有一个/两个元素的数组,然后将各个数组两两归并在一起(排序发生在归并过程中),归并完即完成排序;
算法核心:数组元素的归并。

template<typename T> void merge(T data[], int lo, int mi, int hi)//这是一个大循环变小循环再到大循环的过程,最后的小循环都是只有两个元素或只有一个元素(两种情况都是直接return),然后慢慢归并排序到一起(最后的大循环)
{
	cout << "lo: " << lo << " mi: " << mi << " hi: " << hi << endl;
	int i1 = 0, i2 = lo, i3 = mi;								 //此处将i1作为temp的下标,i2作为数组data[lo,mi-1]的下标,i3作为数组data[mi,hi-1]的下标
	T *temp = new T[hi - lo];                                    //每次循环创建一个临时数组temp,用来存储当前区间排序后的元素
	while ((i2 < mi) || (i3 < hi))								 //从data分割的前后两个数组不断的相互比较,较小值进入temp,然后对应的区间下标++;如果达到某个区间全部比较完(下标到达上界),则另一个数组的元素按顺序进temp
	{
	//归并排序的初始指针i2与i3指向均为左右两区间的头位置,随着不断地向temp数组中赋值而移动

		//下面的判断语句的意思为:左边条件初始往往为true,而右边的判断i3 < hi为第一位,当出现i3 == hi
		//此时表示右区间已满,所以继续执行左区间的赋值语句(前后条件的放置与括号顺序相当讲究)
		if ((i2 < mi) && (!(i3 < hi) || (data[i2] <= data[i3])))
			temp[i1++] = data[i2++];
		cout << "i2: " << i2 << endl;
		if ((i3 < hi) && (!(i2 < mi) || (data[i3] < data[i2])))
			temp[i1++] = data[i3++];
		cout << "i3: " << i3 << endl;
		cout << "i1: " << i1 << endl;
		cout << endl;
	}

	for (int i = 0; i < hi-lo; i++)				//这里的赋值是将临时数组temp存储的排序值传递进data中原本应该对应的区间内,temp内的数值大小恒定为hi-lo
	{
		data[i + lo] = temp[i];					//所排序的区间均为[lo,hi]区间,所以data[i+lo]为temp中所排序的每个数值对应的真实数值
		cout << "temp" << "[" << i << "]:" << temp[i] << " ";
	}
	cout << endl;
	for (int i = 0; i < hi - lo; i++)			//此处用于查看当前data数组的排序情况
		cout << "data" << "[" << i + lo << "]:" << data[i] << " ";
	cout << endl;
	delete[] temp;
}

template<typename T> void mergesort(T data[], int lo, int hi)
{
	if (hi - lo < 2) return;
	int mi = (lo + hi) / 2;
	mergesort(data, lo, mi); mergesort(data, mi, hi);
	merge(data, lo, mi, hi);
}

8.基数排序

时间复杂度平均O(nk),最好O(nk),最差O(n*k),空间复杂度O(n+k),不就地、稳定的排序;
思路为:从各个数的基数(个位,十位,百位,以此类推)开始比较排序,一直比完最高位的基数;
算法核心:基数必为10种数,位数可选定值或选用数组最大数的位数。

template<typename T> void radixsort(T data[], int n)
{
	int i, j, k, factor;
	const int radix = 10;
	const int digits = 10;
	queue<T> queues[radix];                                        //一组队列,用于存储不同基数的数据(每一级基数都仅且对应9个数)
	for (i = 0, factor = 1; i < digits; factor *= radix, i++)      //digits表示最大位数,默认为10位,此处遍历10遍。也可以优化算法为当前数据中最大的数的那一位
	{
		for (j = 0; j < n; j++)
			queues[(data[j] / factor) % radix].push(data[j]);	   //每个数据,根据当前位数取余得到其基数,存入对应的队列中(对列恒定为0-9)
		for (j = k = 0; j < radix; j++)
			while (!queues[j].empty())							   //按基数顺序遍历每个队列,重新将数据覆盖原数组data的同时,清空所有队列
			{
				data[k++] = queues[j].front();
				queues[j].pop();
			}
	}
	cout << "基数排序" << endl;
}

9. 计数排序(桶排序)

时间复杂度平均O(n+k),最好O(n+k),最差O(n+k),空间复杂度O(n+k),不就地、稳定的排序;
思路为:使用一种数据结构作为计数器存储每个数字的出现次数,然后按照数字的大小和存储的数目依次输出;
算法核心:最大的值不要太大,适用于小范围多数据的排序。

template<typename T> void countingsort(T data[], const int n)
{
	long i;
	long largest = data[0];
	long *temp = new long[n];       //建存所有数的数组temp
	for (int i = 1; i < n; i++)
		if ((largest < data[i]))
			largest = data[i];      //选出数组中的最大值
	unsigned long *count = new unsigned long[largest + 1];   //建议计数容器
	for (i = 0; i <= largest; i++)  //初始化计数容器
		count[i] = 0;
	for (i = 0; i < n; i++)         //根据data属数组中的数据,出现一次,对应的数值+1
		count[data[i]]++;

	/*以下是正统的计数排序过程*/
	for (i = 1; i <= largest; i++)  //把计数容器count内的单个容器数值,遍历成依次叠加的
		count[i] = count[i - 1] + count[i];
	for (i = n - 1; i >= 0; i--)    //反向遍历数组data,将其根据计数容器中的位置开始依次放置
	{
		temp[count[data[i]] - 1] = data[i];
		count[data[i]]--;           //计数器中对应的元素开始递减,完成循环后与初始计数器(每个元素的数量)保持一致。
	}
	for (i = 0; i < n; i++)         //temp中的数据已经排序完成,将其重新赋值给data中
		data[i] = temp[i];
	
	/*以下为桶排序的一种特殊形式,即直接将按计数器的顺序将其对应的每个元素直接赋值*/
	//int num = 0;
	//for (i = 0; i <= largest; i++)
	//{
	//	while (count[i] != 0)
	//	{
	//		data[num] = i;
	//		num++; count[i]--;
	//	}
	//}


}

相关的测试用例主函数:本人自己设计了一个数组,对所有的排序算法的函数输入该数组及其长度(有些需要输入起始点0),具体的代码如下:

int main()
{
	int a[] = { 21,1,32,13,56,32,89,54,31,456,324,734,78,123,325,3,7,124 };
	int n = sizeof(a) / sizeof(int);
	cout << "原数组为:       ";
	for (int i = 0; i < n; i++)
		cout << a[i] << " ";
	cout << endl;

	//insertionsort(a, n);		//插入排序
	//selectionsort(a, n);		//选择排序
	//bubblesort(a, n);			//冒泡排序
	//shellsort(a, n);			//希尔排序
	//heapsort(a, n);			//堆排序
	//quicksort(a, 0, n);		//快速排序
	//mergesort(a, 0, n);		//归并排序
	//radixsort(a, n);			//基数排序
	countingsort(a, n);			//计数排序(桶排序)

	cout << "排序后的数组为: ";
	for (int i = 0; i < n; i++)
		cout << a[i] << " ";
	cout << endl;

	return 0;
}

引用相关书籍与博客:
[1] 邓俊辉. 数据结构(C++语言版)(第3版)[M]. 清华大学出版社, 2013.
[2] AdamDrozdek, 乔兹德克, 徐丹, et al. C++数据结构与算法[M]. 清华大学出版社, 2014.
[3] https://www.cnblogs.com/onepixel/articles/7674659.html

你可能感兴趣的:(算法总结,排序算法,C++)