排序

最新推荐文章于 2022-04-26 14:53:52 发布
最新推荐文章于 2022-04-26 14:53:52 发布
阅读量327 收藏 1
点赞数 3
分类专栏： DS
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/PNUHC/article/details/97370846
版权

常见排序算法

在这里插入图片描述

1 插入排序

基本思想：
直接插入排序是一种简单的插入排序法，其基本思想是：把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 。
当插入第i(i>=1)个元素时，前面的array[0],array[1],…,array[i-1]已经排好序，此时用array[i]的排序码与array[i-1],array[i-2],…的排序码顺序进行比较，找到插入位置即将array[i]插入，原来位置上的元素顺序后移。

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>

//void Insertsort(int* array, int size)
//{
//	
//	for(int i = 1; i < size; ++i)
//	{
//		int key = array[i];
//		int end = i - 1;
//		while (end >= 0 && key < array[end])
//		{
//			array[end + 1] = array[end];
//			end--;
//		}
//		array[end + 1] = key;
//	}
//}
//
//int main()
//{
//	int arr[6] = { 5, 2, 4, 6, 1, 3 };
//	int size = sizeof(arr) / sizeof(arr[0]);
//	Insertsort(arr, size);
//	for (int i = 0; i < size; ++i)
//	{
//		printf("%d ", arr[i]);
//	}
//	printf("\n");
//	system("pause");
//	return 0;
//}
void Insertsort(int* arr, int size)
{
	for (int i = 1; i < size; ++i)
	{
		int key = arr[i];//key 只是个标记，保存下标i的数组元素值（key用来和arr[end]作比较，最后插入到相应的位置）
		int end = i - 1;//key标记的数组元素的前一个元素作为end的初始值，然后比较，让end往前走
		while (end >= 0 && arr[end] > key)
		{
			arr[end + 1] = arr[end];//比key小的话让end上的元素往后移动一个
			end--;//end往前走继续进行比较
		}
		//出循环的话key已经找到要插入的位置end+1
		arr[end + 1] = key;//将key插入到应该排序的位置
	}
}
int main()
{
	int arr[6] = { 5, 2, 4, 6, 1, 3 };
	int size = sizeof(arr) / sizeof(arr[0]);
	Insertsort(arr, size);
	for (int i = 0; i < size; ++i)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
	system("pause");
	return 0;
}

直接插入排序的特性总结：

  1. 元素集合越接近有序，直接插入排序算法的时间效率越高
  2. 时间复杂度：O(N2)
  3. 空间复杂度：O(1)，它是一种稳定的排序算法
  4. 稳定性：稳定

2 希尔排序( 缩小增量排序 )

希尔排序法又称缩小增量法。希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分成组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
//(1)希尔排序比插入排序多了一层gap由size / 3 + 1 ---> 1 的循环
//(2)将插入里面的移动1全部改为移动gap，只有i不需要移动gap（还是++i）
void Shellsort(int* arr, int size)
{
	//int gap = size / 3 + 1;定义gap初值
	for (int gap = size / 3 + 1;; gap >= 1; --gap)//或者while(gap > 0)
	{
		//for (int i = 1; i < size; ++i)//注意这里是i++，并不是i+gap，因为可以让多组同时去调整排序
		for (int i = gap; i < size; ++i)//注意i是从gap开始的
		{								/因为gap之前的元素属于分了gap组中每组的0号下标元素，而我们插入直接从1号元素开始，因为第一个元素只有一个元素必有序
			int key = arr[i];
			int end = i - gap;
			while (end >= 0 && key < arr[end])
			{
				arr[end + gap] = arr[end];
				end -= gap;
			}
			arr[end + gap] = key;
		}
		//上面while(gap > 0)的时候
		//这里需要多加 gap-=1；
	}
}
int main()
{
	int arr[6] = { 5, 2, 4, 6, 1, 3 };
	int size = sizeof(arr) / sizeof(arr[0]);
	Shellsort(arr, size);
	for (int i = 0; i < size; ++i)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
	system("pause");
	return 0;
}

希尔排序的特性总结：

  1. 希尔排序是对直接插入排序的优化。
  2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就
    会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。
  3. 希尔排序的时间复杂度不好计算，需要进行推导，推导出来平均时间复杂度： O(N1.3-N2）
  4. 稳定性：不稳定

3 选择排序

基本思想：
每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完 。
直接选择排序：

  • 在元素集合array[i]–array[n-1]中选择关键码最大(小)的数据元素
  • 若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中的最后一个（第一个）元素交换
  • 在剩余的array[i]–array[n-2]（array[i+1]–array[n-1]）集合中，重复上述步骤，直到集合剩余1个元素
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
//选择排序
void Swap(int* a, int* b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}
//void Selectsort(int* arr, int size)
//{
//	for (int i = 0; i < size - 1; i++)
//	{
//		int maxpos = 0;
//		//int maxpos = i;
//
//		for (int j = 1; j < size - i; j++)
//			//for(int j = i; j <= size - 1 - i; j++)
//		{
//			if (arr[maxpos] < arr[j])
//				maxpos = j;
//		}
//		if (maxpos != size - 1 - i)
//			Swap(&arr[maxpos], &arr[size - 1 - i]);
//	}
//}

//我写的
//选择排序就是首先将数组的首元素（或最后一个元素）当成有序元素
//然后第一个（或者最后一个元素）先不管，去size - 1 - 1 个元素的数组里面寻找最小的（或者最大的）然后用minpos（或maxpos）标记
//整个循环有size - 2 次（其中size - 1 代表整个数组的大小，因为循环i是从0开始的）【也就是说 外层循环 i：0 - (size-2)】
//上面size-2 比整个数组范围[0 - (size - 1)]少一个：是因为，把size - 2 个元素排好了序以后，最后一个则必定在它应该在的位置
//找最大值时：寻找区间是[0, size - 1 - i]   maxpos 初始值是 0
//找最小值时：寻找区间是[i + 1, size - 1]	minpos 初始值是 i
//找最大值时：maxpos 应该放在 size - 1 - i 的位置，故里层循环结束后，判断maxpos是否在size - 1 - i处，若不在交换
//找最小值时：minpos 应该放在 i 的位置，故里层循环结束后，判断minpos是否在i处，若不在交换
//不用管ls写的

#if 0
void Selectsort1(int* arr, int size)//找最小值(i从前往后走)
{
	for (int i = 0; i <= size - 2; ++i)
	{
		int minpos = i;
		for (int j = i + 1; j <= size - 1; ++j)
		{
			if (arr[j] < arr[minpos])
				minpos = j;
		}
		if (minpos !=  i)
			Swap(&arr[minpos], &arr[i]);
	}

}
#endif

#if 0
//void Selectsort2(int* arr, int size)//找最大值(i从后往前走)
//{
//	for (int i = 0; i <= size - 2; ++i)
//	{
//		int maxpos = 0;
//		for (int j = 0; j <= size - 1 - i; ++j)
//		{
//			if (arr[j] > arr[maxpos])
//				maxpos = j;
//		}
//		if (maxpos != size - 1 - i)
//			Swap(&arr[maxpos], &arr[size - 1 - i]);
//	}
//}
void Selectsort2(int* arr, int size)//找最大值(i从后往前走)
{
	for (int i = size - 2; i >= 0 ; --i)
	{
		int maxpos = 0;
		for (int j = 0; j <= size - 1 - i; ++j)
		{
			if (arr[j] > arr[maxpos])
				maxpos = j;
		}
		if (maxpos != size - 1 - i)
			Swap(&arr[maxpos], &arr[size - 1 - i]);
	}
}

int main()
{
	int arr[6] = { 5, 2, 4, 6, 1, 3 };
	int size = sizeof(arr) / sizeof(arr[0]);

	Selectsort1(arr, size);
	for (int i = 0; i < size; ++i)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");

	Selectsort2(arr, size);
	for (int i = 0; i < size; ++i)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");

	system("pause");
	return 0;
}
#endif


//选择排序：法二：同时找maxpos 和 minpos
void SelectSortOP(int* array, int size)
{
	// [有5个标记：begin end ：表示未排序的区间；maxpos minpos：标记begin到end区间内的最大值和最小值 index:从前往后遍历去寻找maxpos或minpos]
	int begin = 0;
	int end = size - 1;

	while (begin < end)
	{
		int maxPos = begin;
		int minPos = begin;

		int index = begin + 1;
		while (index <= end)
		{
			if (array[index] > array[maxPos])
				maxPos = index;

			if (array[index] < array[minPos])
				minPos = index;

			++index;
		}

		if (maxPos != end)//若最大值不在末尾，将其置于末尾，不一定是数组末尾，而是begin-end区间的最后一个元素：end处
			Swap(&array[maxPos], &array[end]);

		// 注意：如果在放大元素之前，小元素刚好在end的位置
		//必须更新minPos的位置  因为小元素位置已经发生改变
		if (minPos == end)///重点理解[易忽略]如果minpos刚好走到了end处，而此处因为前面将最大值arr[maxpos]与arr[end]已经交换,但是maxpos和end的位置没变，只是数值交换
			minPos = maxPos;/上一步交换了以后会使原来在minpos处的最小值被交换到maxpos位置处，故需要让minpos指向maxpos处才是真正的最小值处

		if (minPos != begin)//若最小值不在起始，将其置于起始，不一定是数组起始，而是begin-end区间的第一个元素：begin处
			Swap(&array[minPos], &array[begin]);

		begin++;
		end--;
	}
}
int main()
{
	int arr[6] = { 5, 2, 4, 6, 1, 3 };
	int size = sizeof(arr) / sizeof(arr[0]);

	SelectSortOP(arr, size);
	for (int i = 0; i < size; ++i)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");

	system("pause");
	return 0;
}

直接选择排序的特性总结：

  1. 直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用
  2. 时间复杂度：O(N2)
  3. 空间复杂度：O(1)
  4. 稳定性：不稳定

4 堆排序

堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是通过堆来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆。

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
//建小堆降序
void Swap(int* a, int* b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}

//向下调整法
void adjustdown(int* arr, int size, int parent)
{
	int child = parent * 2 + 1;
	if (parent < size)
	{
		while (child < size)//走到child = size - 1 的位置（堆末）
		{
			if (child + 1 < size && arr[child + 1] < arr[child])//用child保存两个孩子节点里面较小的
				child += 1;										//升序建大堆找较大的；降序建小堆找较小的
			if (arr[parent] > arr[child])//别再忘了，要调整的节点比较小的大的话，交换   (我的错误之处)
									//反之，建大堆升序的时候，要调整的节点比较大的小的话，交换
			{
				Swap(&arr[child], &arr[parent]);
				parent = child;
				child = parent * 2 + 1;
			}
			else
				return;
			
		}
	}
}

//建堆：升序建大堆，降序建小堆（这个函数中不影响）
void Heapsort(int* arr,int size)//小堆
{
	int nleaf = (size - 2) >> 1;//找倒数第一个非叶节点
	for (int i = nleaf; i >= 0; --i)//建小堆
		adjustdown(arr, size, i);
	for (int j = size - 1; j >= 0; j--)
	{
		Swap(&arr[0], &arr[j]);//交换根节点和未排序部分数组最后一个的元素
		adjustdown(arr, j, 0);//将根节点出的心交换过来的节点重新调整到相应位置
	}
}
int main()
{
	int arr[] = { 5, 9, 3, 7, 6, 2, 4, 0, 1, 8 };
	Heapsort(arr, 10);
	for (int i = 0; i < 10; ++i)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
	system("pause");
	return 0;
}

直接选择排序的特性总结：

  1. 堆排序使用堆来选数，效率就高了很多。
  2. 时间复杂度：O(N*logN)
  3. 空间复杂度：O(1)
  4. 稳定性：不稳定

5 交换排序

基本思想：
基本思想：所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。

冒泡排序

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
void my_swap(int* a, int* b)//交换的时候传地址（通过这两个地址去寻找对应变量）
{							//形参仅仅是实参的一份临时拷贝（如果不传地址的话就仅仅交换的是临时拷贝的形参的值，并不会影响实参）
	int tmp = 0;            //临时变量的类型是要交换的值得类型（对应）
	tmp = *a;				//交换的是地址解引用之后的值（要交换的值）
	*a = *b;
	*b = tmp;
}
void bubblesort(int* arr,int size)//传数组名及其大小
{
	for (int i = 0; i < size - 1; i++)//要冒泡的趟数（数组元素-1）
	{
		int flag = 0;//一个交换函数是否运行的标记，运行了变为1，否则为0
		for (int j = 0; j < size - 1 - i; j++)//遍历未排序的数组元素
		{
			if ((*(arr + j)) >(*(arr + j + 1)))
			{
				my_swap(&(*(arr + j)), &(*(arr + j + 1)));//交换元素直至最大数排在（此次遍历的）最后一位
				flag = 1;//若交换函数执行，则标记一下
			}
		}
		if (flag == 0)//若为 0，则说明上一次遍历时交换函数没有执行，即数组排序已（提前）完成
			return;
	}
}
int main()
{
	int a = 1;
	int b = 2;
	my_swap(&a, &b);
	printf("a == %d b == %d\n", a, b);
	int arr[10] = { 70, 55, 94, 65, 66, 28, 69, 44, 29, 35 };
	bubblesort(arr, 10);
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", *(arr + i));
	}
	printf("\n");

	system("pause");
	return 0;
	
}

冒泡排序的特性总结：

  1. 冒泡排序是一种非常容易理解的排序
  2. 时间复杂度：O(N2)
  3. 空间复杂度：O(1)
  4. 稳定性：稳定

6 快速排序

快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。
将区间按照基准值划分为左右两半部分的常见方式有：

  1. hoare版本
  2. 挖坑法
  3. 前后指针版本

快速排序优化
　　5. 三数取中法选key
　　6. 递归到小的子区间时，可以考虑使用插入排序

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>

void Swap(int* a, int* b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}
//插入排序**【注意：这里插入排序需要修改参数(int* array,size)-->(left,right)】**
//void InsertSort(int* array, int size)
void InsertSort(int* array, int left,int right)
{
	//for(int i = 1; i < size; ++i)
	for (int i = left + 1; i < right; ++i)
	{
		// 待插入元素
		int key = array[i];

		// 找key的插入位置：与前面已经排序好的元素从后往前比较
		int end = i - 1;
		while (end >= 0 && key < array[end])
		{
			array[end + 1] = array[end];
			end -= 1;
		}

		// 插入元素
		array[end + 1] = key;
	}
}

//快速排序
// a  b  c


//三数取中法：寻找left mid right 的（数组）中间数
int GetMiddleIndex(int* array, int left, int right)
{
	int mid = left + ((right - left) >> 1);//left mid right 其中mid是left 和 right 的平均值
	if (array[left] < array[right - 1])//其实就是三个数之间比大小，return中间大小的那个数
	{
		if (array[mid] < array[left])//比左小，说明left是中间数
			return left;
		else if (array[mid] > array[right - 1])//比右大， 说明right - 1 是中间数 
			return right - 1;
		else
			return mid;
	}
	else
	{
		if (array[mid] > array[left])
			return left;
		else if (array[mid] < array[right - 1])
			return right - 1;
		else
			return mid;
	}
}

// [left, right)：数组大小是[0-(size-1)],到时候传的是left:0   right: size  故[left, right)表示的是数组区间 所以下面的 end = right - 1;
//数组只能取到 left 到 right - 1

//1.hoare法：以数组末端元素作为基准值key
int Partion1(int* array, int left, int right) //返回值是key的下标（begin和end 重合处）
{
	int begin = left;
	int end = right - 1;
	int mid = GetMiddleIndex(array, left, right);
	Swap(&array[mid], &array[right - 1]);//三数取中法优化后将中间数放于数组末尾right-1处

	int key = array[right - 1];

	while (begin < end)
	{
		// 从左往右找比基准值大的元素，找到之后停止
		while (begin < end && array[begin] <= key)
			begin++;

		// 从右往左找比基准值小的元素，找到之后停止
		while (begin < end && array[end] >= key)
			end--;

		if (begin != end)
			Swap(&array[begin], &array[end]);//这里交换的是begin和end下标对应的数组元素的交换，并不影响begin和end的位置
	}
	//走出循环以后begin和end必相等	重要：因为begin先走，而end后走,故当begin与end重合时，也就是出循环时，begin必定落在end上，
	//而此时end在比key大的区间的第一个元素处，然后就可以直接将重合的这个位置和key交换，就可以达到用基准值key将数组分为[左比其小][右比其大]的两个区间
	if (begin != right - 1)//将基准值放于begin和end的重合处
		Swap(&array[begin], &array[right - 1]);

	return begin;
}

//2.挖坑法：先用begin去找第一个比key大的元素
//	然后用该元素去覆盖key处（这里应该理解为：用key作为基准值将数组末尾处【三数取中法处理以后才是数组末尾，也可能不是】的值保存，也就相当于这里有一个可以填充（掩盖）的坑）
//  让begin从前往后走去寻找比key大的元素，然后填end处坑
//	让end从后往前走去寻找比key小的元素，然后填begin处坑
//  每填坑完一次坑以后让begin++或者end--移动一个去循环
//	最后出循环和hoare法一样：begin先走一步导致begin和end重合，而此时end处是坑（因为上一次end已经赋值给begin处填坑），用key来填该坑
int Partion2(int* array, int left, int right) //返回值是key的下标（begin和end 重合处）
{
	int begin = left;
	int end = right - 1;
	int mid = GetMiddleIndex(array, left, right);
	Swap(&array[mid], &array[right - 1]);

	int key = array[right - 1];//也是用数组末尾元素（三数取中法优化后将中间值放于数组末尾即可）作为基准值

	while (begin < end)
	{
		// 从前往后找比基准值大的元素，找到后填充end位置的坑
		while (begin < end && array[begin] <= key)
			begin++;

		// 填充end位置的坑：因为end位置处用key已经标记，所以覆盖其以后还可以用key找到它
		if (begin < end)
		{
			array[end] = array[begin];
			end--;
		}

		// 从后往前找比基准值小的元素，找到后填充begin位置的坑
		while (begin < end && array[end] >= key)
			end--;

		if (begin < end)
		{
			array[begin] = array[end];
			begin++;
		}
	}
	//出循环和hoare法一样：begin先走一步导致begin和end重合，而此时end处是坑（因为上一次end已经赋值给begin处填坑），可以直接用key来填即可
	array[begin] = key;
	return begin;
}

//3.前后指针法：	cur：当前指针，无条件往后走，若cur处的值小于基准值key，那么让prev往后走一个；
//					prev:标记开始时cur的前一个位置处  （1）当cur处的值小于基准值key时，prev往后走一个	
//													  （2）当cur走完数组，循环结束后，prev再往后一个
//					当cur走完数组，循环结束后，prev再往后一个以后，交换prev和key出的值就OK了
int Partion3(int* array, int left, int right) //返回值是key的下标（begin和end 重合处）
{
	int cur = left;// cur标记当前指针的位置
	int prev = cur - 1;//prev标记开始时cur的前一个位置处
	int mid = GetMiddleIndex(array, left, right);
	Swap(&array[mid], &array[right - 1]);
	int key = array[right - 1];//也是用数组末尾元素（三数取中法优化后将中间值放于数组末尾即可）作为基准值


	while (cur < right)//cur这个标记从数组开始走到结尾，则循环结束（每次循环往后走一个）
	{
		if (array[cur] < key && ++prev != cur)//当arr[cur]的值小于key时，prev才往后走一个
											  //注意：当&&前面条件成立的话才会执行后面的++prev
			Swap(&array[cur], &array[prev]);//当prev+1不等于cur时，即pre和cur中间有[ >=key ]元素，并且prev当前一定指向的是[ >=key ]元素，然后交换cur处的元素和prev处的元素

		++cur; //每次循环pcur无条件往后走一个
	}
	///重点理解///if后面括号里的++prev会让prev往后走一个，与判断提交无关，若if (array[cur] < key && ++prev != cur)这种情况，前面的array[cur] < key条件成立了以后才会执行++prev
	if (++prev != right)//出循环后（cur走到数组末尾的下一个位置处）
						//如果prev没有走到倒数第一处[此时cur走到结尾后一处]，让prev再往后走一个（到比key大的区间的第一个元素处），将key值放入prev处
		Swap(&array[prev], &array[right - 1]);

	return prev;
}

void QuickSort(int* array, int left, int right)
{
	if (right - left < 16)//优化1：三数取中法 优化2：当递归到未排序的数组区间小于某个值（一般是16）时，采用插入排序
		//InsertSort(array, right - left);//这里不能这样传参
		InsertSort(array, left, right);
	//此时要用到递归，当下面第二层的QuickSort(array, div + 1, right);传来时，必须区分left，right
	//否则，要是直接传两个参数，第二个参数按照(right - left)传参时
	//插入排序中默认按照下标全从0开始到right - left
	//这时，排序的话会出错，后半段排不进去插入排序而直接出递归
	//所以，必须在插入排序(InsertSort)中指明要传的区间left，right.
	else
	{
		// 按照基准值将区间分割成左右两部分
		// 左侧小于基准值 基准值 右侧大于基准值
		int div = Partion1(array, left, right);//Partion函数的区间都是左闭右开，[left, right)：数组大小是[0-(size-1)],传的是left:0   right: size  故[left, right)表示的是数组区间 因为函数体中的 end = right - 1;
		QuickSort(array, left, div);//同理如上，div取不到的
		QuickSort(array, div + 1, right);//同理如上，right取不到的
	}
}


#if 0
//非递归实现快排
#include "Stack.h"
void QuickSortNor(int* array, int size)
{
	int left = 0;
	int right = size;
	Stack s;
	StackInit(&s);
	StackPush(&s, right);
	StackPush(&s, left);

	while (!StackEmpty(&s))
	{
		left = StackTop(&s);
		StackPop(&s);
		right = StackTop(&s);
		StackPop(&s);

		if (right - left > 1)
		{
			int div = Partion3(array, left, right);

			// 保存右半部分区间
			StackPush(&s, right);
			StackPush(&s, div + 1);

			// 保存左半部分区间
			StackPush(&s, div);
			StackPush(&s, left);
		}
	}
}
#endif





int main()
{
	int arr[] = { 3, 4, 2, 9, 1, 7, 6, 0, 8, 5 };
	QuickSort(arr, 0, sizeof(arr) / sizeof(arr[0]));
	for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i)
		printf("%d ", arr[i]);
	printf("\n");
	system("pause");
	return 0;
}

快速排序的特性总结：

  1. 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序
  2. 时间复杂度：O(N*logN)
  3. 空间复杂度：O(logN)
  4. 稳定性：不稳定

7 归并排序

基本思想：
归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide andConquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。 归并排序核心步骤：
在这里插入图片描述

#define _CRT_SECURE_NO_WARNINGS 1
#include <malloc.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include <stdio.h>
//归并排序

//这一步的目的：将两个有序的子序列按顺序合并成一个有序的序列放入temp中（排序）
void mergeData(int* array, int left,int mid, int right, int *temp)
{
	int begin1 = left, end1 = mid;
	int begin2 = mid, end2 = right;
	int index = left;

	while (begin1 < end1 && begin2 < end2)//将有序序列的元素进行比较
	{
		if (array[begin1] < array[begin2])
			temp[index++] = array[begin1++];
		else
			temp[index++] = array[begin2++];
	}
	//能走下来说明左右子区间至少有一个遍历完了
	while (begin1 < end1)//能走下来说明左右子区间至少有一个遍历完了
		temp[index++] = array[begin1++];
	while (begin2 < end2)//若begin2 < end2说明右边还没有遍历完，继续将剩余的元素放入temp
		temp[index++] = array[begin2++];
}

//这一步是递归（循环）将array分为若干个子区间，并且结合第一步对子区间进行排序
void _mergeSort(int* array, int left, int right, int* temp)
{
	if (right - left > 1)//如果左右之间有元素，继续分割为更小的子区间
	{
		int mid = left + ((right - left) >> 1);//将原数组以中间元素为基准分割成两个子序列
		_mergeSort(array, left, mid, temp);//对左序列进行归并排序(左闭右开)
		_mergeSort(array, mid, right, temp);//对右序列进行归并排序(左闭右开)
		mergeData(array, left, mid, right, temp);//将排序后的左右子序列进行合并，合并后放入temp中
		memcpy(array + left, temp + left, sizeof(int)*(right - left));//将temp中的有序序列拷贝到array中
	}
}

void mergeSort(int* array, int size)//再封装一层，是函数参数个数减少
{
	int* temp = (int*)malloc(sizeof(int)*size);
	if (NULL == temp)
	{
		assert(0);
		return;
	}
	_mergeSort(array, 0, size, temp);
	free(temp);
}

//非递归
void MergeSortNor(int* array, int size)
{
	int* temp = (int*)malloc(sizeof(int)*size);
	if (NULL == temp)
	{
		assert(0);
		return;
	}
	int gap = 1;
	while (gap < size)
	{
		//让区间开始是归并所有最小区间（其实传的相邻三个元素，但是只取前两个元素）
		//gap每次增长一倍,使区间逐渐扩大（gap *= 2）
		//到最后最大区间（当 gap 等于 size-1 时，即归并整个数组）
		for (int i = 0; i < size; i += 2 * gap)
		{
			int left = i;
			int mid = left + gap;
			int right = mid + gap;
			if (mid >= size)
				mid = size;
			if (right >= size)
				right = size;
			mergeData(array, left, mid, right, temp);
		}
		memcpy(array, temp, sizeof(int)* size);//每次（全部）拷贝size元素到arr，直到最后一次arr完全有序
											　//memcpy( a, b, len);把b给a拷贝len长度（单位：字节）
		gap *= 2;
	}
	free(temp);
}



int main()
{
	int arr[] = { 3, 4, 2, 9, 1, 7, 6, 0, 8, 5 };
	mergeSort(arr, sizeof(arr) / sizeof(arr[0]));

	//MergeSortNor(arr, sizeof(arr) / sizeof(arr[0]));
	for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i)
		printf("%d ", arr[i]);
	printf("\n");
	system("pause");
	return 0;
}

归并排序的特性总结：

  1. 归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。
  2. 时间复杂度：O(N*logN)
  3. 空间复杂度：O(N)
  4. 稳定性：稳定

8 非比较排序

思想：计数排序又称为鸽巢原理，是对哈希直接定址法的变形应用。 操作步骤：

  1. 统计相同元素出现次数
  2. 根据统计的结果将序列回收到原来的序列中
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<string.h>


void Countsort(int* arr, int size)
{
	//找数据范围
	int maxValue = arr[0];
	int minValue = arr[0];
	for (int i = 0; i < size; ++i)
	{
		if (arr[i] > maxValue)
			maxValue = arr[i];
		if (arr[i] < minValue)
			minValue = arr[i];
	}

	int range = maxValue - minValue + 1;
	//int* pCount = calloc(range, sizeof(int));
	int* pCount = (int*)malloc(sizeof(int)*range);
	memset(pCount, 0, sizeof(int)*range);
	if (NULL == pCount)
	{
		assert(0);
		return;
	}
	//统计每个元素出现的次数
	for (int i = 0; i < size; ++i)
	{
		pCount[arr[i] - minValue]++;
	}
	//排序（对pCount中的元素进行回收）
	int index = 0;
	for (int i = 0; i < range; ++i)
	{
		while (pCount[i])
		{
			arr[index++] = i + minValue;
			pCount[i]--;
		}
	}
	free(pCount);
}

int main()
{
	int arr[10] = { 1, 0, 3, 2, 0, 1, 3, 2, 1, 2 };
	int size = sizeof(arr) / sizeof(arr[0]);
	Countsort(arr, size);
	for (int i = 0; i < size; ++i)
		printf("%d ", arr[i]);
	printf("\n");
	system("pause");
	return 0;
}

计数排序的特性总结：

  1. 计数排序在数据范围集中时，效率很高，但是适用范围及场景有限。
  2. 时间复杂度：O(MAX(N,范围))
  3. 空间复杂度：O(范围)
  4. 稳定性：稳定
排序方法平均情况最好情况最坏情况辅助空间稳定性
冒泡排序O(n2)O(n)O(n2)O(1)稳定
简单选择排序O(n2)O(n2)O(n2)O(1)稳定
直接插入排序O(n2)O(n)O(n2)O(1)稳定
希尔排序O(nlogn)~O(n2)O(n1.3)O(n2)O(1)不稳定
堆排序O(nlogn)O(nlogn)O(nlogn)O(1)不稳定
归并排序O(nlogn)O(nlogn)O(nlogn)O(n)稳定
快速排序O(nlogn)O(nlogn)O(n2)O(nlogn)~O(n)不稳定
PHONER'S NUHC
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
排序查询
12-14
排序查询按单个字段排序按表达式 / 别名排序按函数排序按多个字段排序 排序查询：SELECT 查询列表 FROM 表 WHERE 筛选条件 ORDER BY 排序列表(ASC/DESC) AEC/DESC = 升序/降序，默认为升序 ORDER BY 支持单个字段、...
排序算法（直接插入排序、折半排序、直接选择排序、快速排序与归并排序）
04-04
提供五种排序算法的C++实现方法，输入（待排序元素个数、排序码上界（采用随机生成数组方式）），可选择输出（原始数组、排序后数组、原始数组有序度和无序度、排序过程中数据比较次数与数据移动次数、数组中出现...
排序（冒泡、选择、插入、希尔、快排、归并、优先队列、堆排序）
4/帽子的博客
02-23 286
https://img-blog.csdn.net/20161009190728886
比较排序算法
aijianxie8808的博客
07-14 325
比较排序算法分类 比较排序（Comparison Sort）通过对数组中的元素进行比较来实现排序。 比较排序算法（Comparison Sorts） Category Name Best Average Worst Memory Stability 插入排序 （InsertionSorts） ...
快速排序基准位置的选取方法和快速排序优化
中都
10-27 3999
一、 快速排序基准位置的选取方法 1.固定位置法（就是选取的基准是固定的、一般是数组的第一个元素） 2.随机选取基准法 /** * 快速排序，递归实现 * 时间复杂度：好：O(无序)(nlog2n),坏(有序)：O(n^2) * 空间复杂度： * 稳定性：不稳定 * (每次分割比较均匀的时候 效率较高 */ public class LianXi { public sta...
六大排序算法：插入排序、希尔排序、选择排序、冒泡排序、堆排序、快速排序
热门推荐
HanMeng的博客
07-24 57万+
文章目录：1. 插入排序2.希尔排序 1. 插入排序 步骤： 1.从第一个元素开始，该元素可以认为已经被排序 2.取下一个元素tem，从已排序的元素序列从后往前扫描 3.如果该元素大于tem，则将该元素移到下一位 4.重复步骤3，直到找到已排序元素中小于等于tem的元素 5.tem插入到该元素的后面，如果已排序所有元素都大于tem，则将tem插入到下标为0的位置 6.重复步骤2~5 动图演示如下： 思路：   在待排序的元素中，假设前n-1个元素已有序，现将第n个元素插入到前面已经排好的序列中，使得前n个
十大排序算法详解（一）冒泡排序、选择排序、插入排序、快速排序、希尔排序
HK的博客
06-27 18万+
冒泡排序、选择排序、插入排序、快速排序、希尔排序
C++ sort()排序详解
晴空๓
05-05 39万+
本文对C++中的sort()做了一个比较详细的说明，包括为什么选择使用sort()、sort()函数的实现原理、sort()的使用方法等等。
C语言——冒泡排序
记录学习点滴
03-13 43万+
冒泡排序的原理是：从左到右，相邻元素进行比较。每次比较一轮，就会找到序列中最大的一个或最小的一个。这个数就会从序列的最右边冒出来。 以从小到大排序为例，第一轮比较后，所有数中最大的那个数就会浮到最右边；第二轮比较后，所有数中第二大的那个数就会浮到倒数第二个位置……就这样一轮一轮地比较，最后实现从小到大排序。 代码如下 #include<stdio.h> void BBsort(int arr[], int size) { int j,i,tem; for (i = 0; i ..
快速排序详解
LiangXiay的博客
11-19 11万+
1.什么是快速排序 我们知道排序有很多种，常见的如希尔排序，插入排序，选择排序，堆排序等等，而快速排序也是排序家族中的一员。因为其在大多数情况下有着优秀的综合性能，快速排序的快速也算是实至名归，接下来就为大家讲解快速排序的思想与实现。 2.快速排序的核心思想 快速排序通过多次比较与交换来完成排序。而这个过程又被分为了多次重复单趟排序，接下来我们先从每一趟的排序讲起。 快速排序的单趟排序思想是： 在一个无序数组中取一个数key，每一趟排序的最终目的是：让key的左边的所有数小于key，key的右边都
常用十大排序算法
qq_51664685的博客
04-26 13万+
列举了常见的十大内部排序算法：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序，计数排序，桶排序。
【数据结构】八大排序(超详解+附动图+源码)
Edward_Asia的博客
11-21 8万+
前言 所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。 生活中各种地方都需要用到排序，所以学好排序算法是非常重要的。 排序分为 内部排序 和 外部排序。 内部排序：数据元素全部放在内存中的排序。外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。 这部分主要是内部排序。排序讲解都以升序为例。 常见的排序算法： // 排序实现的接口 // 插入排序 void InsertSort(int* arr..
冒泡排序_冒泡排序_
09-30
C++实现冒泡排序，多层次，快速实现排序算法
关键字排序
06-02
多关键字排序
帆软：排序问题（通过帆软设置或者sql排序）
02-26
帆软：排序问题（通过帆软设置或者sql排序） 测试文件 + sql 脚本
300ssm_jsp_mysql 记账管理系统.zip（可运行源码+sql文件+文档）
06-28
管理员需要配置的功能模块如下： （1）系统用户管理，管理员能够对系统中存在的用户的信息进行合理的维护操作，可以查看用户的信息以及在线进行密码的更换； （2）用户管理，管理员可以对该系统中用户进行管理，这个模块主要针对企业中的员工用户，管理员能够对这类的用户信息进行线上化的维护管理； （3）财务管理，该模块是整个系统的核心模块内容，在该模块的设计上，是通过对用户输入的收入、支出情况进行完整的内容查看，并且能够在线新增财务信息。 （4）财务统计，在财务统计的功能模块中，管理员可以看到当前所有用户累计的财务支出以及收入的情况，可以实现有效的数据统计工作。 本次的系统业务设计上是通过B/S结构来进行相应的管理系统搭建的。通过MVC三层框架结构来对整个系统中的不同功能模块实现分层的开发。在整个开发的过程中通过对不同的角色用户进行不同的功能权限的分配来对整个系统进行完整的设计。通过对不同的记账管理系统进行研究分析，了解到当下的记账管理系统普遍在收入、支出的统计上作为系统的核心要素来进行设计，在收支的系统自动统计上也需要进行有效的合理的内容设计。并且不同人员输入的信
一个简单的计数器，带有 2 个多路复用 SSD 和 2 个推送 btns 以递增或复位，使用分层架构在基于 stm32 ARM
06-28
一个简单的计数器，带有 2 个多路复用 SSD 和 2 个推送 btns 以递增或复位，使用分层架构在基于 stm32 ARM 的微控制器上运行
yolov8算法火焰和烟雾识别训练权重+数据集
最新发布
06-28
yolov8算法火焰和烟雾识别训练权重， 包含15000多火焰和烟雾识别数据集（有网盘链接），数据集目录已经配置好，划分好 train，val, test，并附有data.yaml文件，yolov5、yolov7、yolov8，yolov9等算法可以直接进行训练模型，txt格式标签， 数据集和检测结果参考：https://blog.csdn.net/zhiqingAI/article/details/124230743 数据集配置目录结构data.yaml： nc: 2 names: - fire - smoke
docker python3:10版本 镜像
06-28
docker python3:10 版本 镜像
C语言等多种方式实现通讯录排序
12-27
该编程问题要求使用C语言实现一个通讯录排序程序，输入包含n个朋友的姓名、生日和电话号码，输出时按照年龄从大到小排列。输入和输出格式有具体规定，且保证所有人的生日都是唯一的。提供的代码示例展示了基本的冒泡...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值