5.排序算法 [C语言]

产品喵dandan米娜

 关注

阅读 88

2022-02-19

文章目录

插入

InsertSort

//1.先写单趟
//2.再写多趟
//画图!!
void InsertSort(int* a, int n)
{
	assert(a);
	assert(n >= 0);
	//多躺排序
	//end下标从0~n-2
	for (int i = 0; i < n-1; i++)
	{
		//1.先写单趟排序
	//把tmp插入到数组[0,end]的有序区间中
		int end = i;
		int tmp = a[end+1];
		while (end >= 0)
		{
			if (tmp < a[end])
			{
				a[end + 1] = a[end];
				end--;
			}
			else
			{
				break;
			}
		}
		//end移到-1时,需要把tmp放到a[0]里面
		//tmp>=a[end]也需要把tmp放到a[end]后面
		a[end + 1] = tmp;
	}
}

//时间复杂度O(N^2)

image-20220216122449357

ShellSort

void ShellSort(int* a, int n)
{
	int gap = n;
	while (gap > 1) // n/3/3/3.../3 == 1  -》 3^x = n  x就是这个while循环跑的次数
	{
		//+1保证最后依次gap是1
		gap = (gap / 3 + 1);
		//先预排序,gap=1时直接插入排序
		// 最坏的情况：逆序，gap很大的时-》O(N)
		// ...
		//gap很小时本来应该是O(N*N),但是经过前面的预排序，数组已经很接近有序的，所这里还是O(N)
		for (int i = 0; i < n - gap; i++)
		{
			int end = i;
			int tmp = a[end + gap];
			while (end >= 0)
			{
				if (tmp < a[end])
				{
					a[end + gap] = a[end];
					end -= gap;
				}
				else
				{
					break;
				}
				//end移到<0时,需要把tmp放到a[end+gap]里面
				//tmp>=a[end]也需要把tmp放到a[end+gap]后面
				a[end + gap] = tmp;
			}
		}
	}
}
//平均复杂度O(N^1.3)  因为gap不确定
// gap为3的情况：O(log3(N) * N) 这里log3(N)是以3为底N的对数

image-20220216132015236

对比测试

void TestOP()
{
	srand(time(0));
	const int N = 100000;
	int* a1 = (int*)malloc(sizeof(int) * N);
	int* a2 = (int*)malloc(sizeof(int) * N);
	int* a3 = (int*)malloc(sizeof(int) * N);
	int* a4 = (int*)malloc(sizeof(int) * N);
	int* a5 = (int*)malloc(sizeof(int) * N);
	int* a6 = (int*)malloc(sizeof(int) * N);

	for (int i = 0; i < N; ++i)
	{
		a1[i] = rand();
		a2[i] = a1[i];
		a3[i] = a1[i];
		a4[i] = a1[i];
		a5[i] = a1[i];
		a6[i] = a1[i];

	}

	int begin1 = clock();
	InsertSort(a1, N);
	int end1 = clock();

	int begin2 = clock();
	ShellSort(a2, N);
	int end2 = clock();

	//int begin3 = clock();
	//SelectSort(a3, N);
	//int end3 = clock();

	//int begin4 = clock();
	//HeapSort(a4, N);
	//int end4 = clock();

	//int begin5 = clock();
	//QuickSort(a5, 0, N - 1);
	//int end5 = clock();

	//int begin6 = clock();
	//MergeSort(a6, N);
	//int end6 = clock();

	printf("InsertSort:%d\n", end1 - begin1);
	printf("ShellSort:%d\n", end2 - begin2);
	//printf("SelectSort:%d\n", end3 - begin3);
	//printf("HeapSort:%d\n", end4 - begin4);
	//printf("QuickSort:%d\n", end5 - begin5);
	//printf("MergeSort:%d\n", end6 - begin6);

	free(a1);
	free(a2);
	free(a3);
	free(a4);
	free(a5);
	free(a6);
}

选择

SelectSort

void SelectSort(int* a, int n)
{
	int left = 0;
	int right = n - 1;
	while (left < right)
	{
		int minIndex = left;
		int maxIndex = left;
		//选出最大的值和最小的值
		for (int i = left; i <= right; i++)
		{
			if (a[i] < a[minIndex])
			{
				minIndex = i;
			}
			if (a[i] > a[maxIndex])
			{
				maxIndex = i;
			}
		}
		Swap(&a[left], &a[minIndex]);
		//极端情况下需要修正,第一个数恰好是最大的数,但它又要进行交换,改变了maxIndex的位置
		if (left == maxIndex)
		{
			maxIndex = minIndex;
		}
		Swap(&a[right], &a[maxIndex]);
		++left;
		--right;
	}
}
//N N-2 N-4
//O()

HeapSort

//排大根堆
void AdjustDown(int* a, int n, int root)
{
	int parent = root;
	int child = parent * 2 + 1;
	while (child < n)
	{
		//选出大的孩子
		//先检查是否有越界再访问
		if (child+1 < n && a[child+1] > a[child])
		{
			++child;
		}
		if (a[child]>a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

void HeapSort(int* a, int n)
{
	//排升序,建大堆
	for (int i = (n-1-1)/2; i >= 0 ; i--)
	{
		AdjustDown(a, n, i);
	}
	//选出最大的数,交换到最后去
	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		//选次大的
		//左右子树均为大堆,只需一次向下调整就能从n-1选出原来n里面次大的数
		AdjustDown(a, end, 0);
		end--;
	}

对比测试

InsertSort:1144
ShellSort:8
SelectSort:5162
HeapSort:7

交换

BubbleSort

void BubbleSort(int* a, int n)
{
	/*for (int i = 0; i < n; i++)
	{
		for (int j = 1; j < n-i; j++)
		{
			if (a[i-1]>a[i])
			{
				Swap(&a[i - 1], &a[i]);
			}
		}
	}*/

	//或者优化一下
	for (int end = n; end > 0; end--)
	{
		int exchange = 0;
		for (int i = 1; i < end; i++)
		{
			if (a[i - 1] > a[i])
			{
				Swap(&a[i - 1], &a[i]);
				exchange = 1;
			}
		}
		if (exchange == 0)
		{
			//说明没有发生交换,也就是前面的恰好是有序的
			break;
		}
	}
}

QuickSort

void QuickSort(int* a, int begin, int end)
{
	if (begin >= end)
		return;
	int left = begin, right = end;
	int keyi = left;
	while (left < right)
	{
		//要保证相遇位置的值一定比key先小,要让right先走
		//找小
		//left < right防止越界 
		while (left < right && a[right] >= a[keyi])
		{
			--right;
		}
		//找大
		while (left < right && a[left] <= a[keyi])
		{
			++left;
		}
		//交换
		Swap(&a[left], &a[right]);
	}
	int meeti = left;
	Swap(&a[keyi], &a[left]);

    //分治思想
	//[begin,meeti-1] meeti [meeti+1,end]
	QuickSort(a, begin, meeti - 1);
	QuickSort(a, meeti+1, end);
}

PartSort

void QuickSort(int* a, int begin, int end)
{
	//区间有多个值时才继续,一个值都没有就return
	if (begin >= end)
		return;
	int keyi = PartSort1(a, begin, end);

	//[begin,keyi-1] keyi [keyi+1,end]
	QuickSort(a, begin, keyi - 1);
	QuickSort(a, keyi +1, end);
}
//时间复杂度理想情况 O(N*logN)
//最坏情况 O(N^2) 
//空间复杂度O(logN) 树的高度

用QuickSort去排一个有序的序列,比InsertSort还慢
InsertSort:1143
ShellSort:7
SelectSort:5092
HeapSort:7
QuickSort:1309

左右指针法

//单趟排序 hoare版本 -- 左右指针法
int PartSort1(int* a, int left, int right)
{
	int keyi = left;
	while (left < right)
	{
		//要保证相遇位置的值一定比key先小,要让right先走
		//找小
		//left < right防止越界 
		while (left < right && a[right] >= a[keyi])
		{
			--right;
		}
		//找大
		while (left < right && a[left] <= a[keyi])
		{
			++left;
		}
		//交换
		Swap(&a[left], &a[right]);
	}
	Swap(&a[keyi], &a[left]);
	return left;
}

挖坑法

//挖坑法
int PartSort2(int* a, int left, int right)
{
	//先把left作为key保存起来,left的位置天生是一个坑
	int key = a[left];
	while (left < right)
	{
		//找小
		while (left < right && a[right] >= key)
		{
			--right;
		}
		//放到左边的hole中,右边就形成新的hole
		a[left] = a[right];

		//找大
		while (left < right && a[left] <= key)
		{
			++left;
		}
		//放到右边的hole中,左边就形成新的hole
		a[right] = a[left];
	}
	//相遇
	a[left] = key;
	return left;
}

image-20220216221213007

前后指针法

cur prev 一前一后
cur去找比keyi位置小的值
找到小之后,++prev,再交换prev和cur位置的值
直到数组尾
最后交换prev和keyi位置的值
    
思想: 把小的往左边留,大的往右边留,prev++是为了跟上cur

image-20220217184512797

//前后指针法
int PartSort3(int* a, int left, int right)
{
	//三数取中优化
	int midIndex = GetMidIndex(a, left, right);
	Swap(&a[left], &a[midIndex]);
	int keyi = left;
	int prev = left, cur = left + 1;
	while (cur <= right)
	{
		if (a[cur] < a[keyi] && ++prev != cur)
		{
			//prev++;
			//prev和cur相同时,交换也没影响
			Swap(&a[prev], &a[cur]);
		}
		cur++;
	}
	Swap(&a[keyi], &a[prev]);
	return prev;
}

优化

三数取中优化

int GetMidIndex(int* a, int left, int right)
{
	int mid = (left + right) >> 1;//位运算效率比除法高
	//left mid right
	if (a[left] < a[mid])
	{
		if (a[mid] < a[right])
		{
			return mid;
		}
		else if (a[left] > a[right])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
	else //a[left] > a[mid]
	{
		if (a[mid] > a[right])
		{
			return mid;
		}
		else if (a[left] < a[right])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
}

//单趟排序 hoare版本 -- 左右指针法
int PartSort1(int* a, int left, int right)
{
	int midIndex = GetMidIndex(a, left, right);
	Swap(&a[left], &a[midIndex]);

	int keyi = left;
	while (left < right)
	{
		//要保证相遇位置的值一定比key先小,要让right先走
		//找小
		//left < right防止越界 
		while (left < right && a[right] >= a[keyi])
		{
			--right;
		}
		//找大
		while (left < right && a[left] <= a[keyi])
		{
			++left;
		}
		//交换
		Swap(&a[left], &a[right]);
	}
	Swap(&a[keyi], &a[left]);
	return left;
}

三数取中优化后,恰好是有序的数据
InsertSort:1134
ShellSort:8
SelectSort:5144
HeapSort:7
QuickSort:1

1000w的随机数据排序:
InsertSort:0
ShellSort:1217
SelectSort:0
HeapSort:2530
QuickSort:593

小区间优化

void QuickSort(int* a, int begin, int end)
{
	//区间有多个值时才继续,一个值都没有就return
	if (begin >= end)
		return;

	//1.如果这个子区间数据较多,继续选key单趟,分割子区间分治递归
	//2.如果子区间数据较少,再去分治递归不太划算
	if (end-begin > 10)
	{
		int keyi = PartSort3(a, begin, end);

		//[begin,keyi-1] keyi [keyi+1,end]
		QuickSort(a, begin, keyi - 1);
		QuickSort(a, keyi + 1, end);
	}
	
	else
	{
		//考虑到分割中间的较小子区间
		InsertSort(a + begin, end - begin + 1);
	}
}

非递归

void QuickSortNonR(int* a, int begin, int end)
{
	Stack st;
	StackInit(&st);
	StackPush(&st, begin);
	StackPush(&st, end);

	while (!StackEmpty(&st))
	{
		int left, right;
		//先入左后入右,出来时就先出右后出左
		right = StackTop(&st);
		StackPop(&st);
		left = StackTop(&st);
		StackPop(&st);

		int keyi = PartSort3(a, left, right);
		if (left<keyi-1)
		{
			StackPush(&st, left);
			StackPush(&st, keyi-1);
		}
		if (keyi+1<right)
		{
			StackPush(&st, keyi + 1);
			StackPush(&st, right);
		}
	}
	StackDestroy(&st);
}

对比测试

InsertSort:1137
ShellSort:8
SelectSort:5149
HeapSort:8
QuickSort:5

    //优化过后:
InsertSort:1129
ShellSort:8
SelectSort:5112
HeapSort:8
QuickSort:1

归并

MergeSort

image-20220217215653597

void _MergeSort(int* a, int left, int right, int* tmp)
{
	if (left >= right)
	{
		return;
	}
	int mid = (left + right) >> 1;
	//[left, mid] [mid+1, right]
	_MergeSort(a, left, mid, tmp);
	_MergeSort(a, mid+1, right, tmp);

	//两段有序子区间归并到tmp再拷贝回去
	int begin1 = left, end1 = mid;
	int begin2 = mid+1, end2 = right;
	int i = left;
	while (begin1 <= end1 && begin2 <= end2)
	{
		if (a[begin1] < a[begin2])
		{
			tmp[i++] = a[begin1++];
		}
		else
		{
			tmp[i++] = a[begin2++];
		}
	}
	//一个先结束,就把另一个的全放进去
	while (begin1 <= end1)
	{
		tmp[i++] = a[begin1++];
	}
	while (begin2 <= end2)
	{
		tmp[i++] = a[begin2++];
	}
	//拷贝回去
	for (int j = left; j <= right; j++)
	{
		a[j] = tmp[j];
	}
}
void MergeSort(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	_MergeSort(a, 0, n - 1, tmp);
	free(tmp);
}

时间复杂度O(N*logN)
每一层归并都是N
logN层

空间复杂度O(N)

InsertSort:1141
ShellSort:7
SelectSort:5085
HeapSort:7
QuickSort:1
MergeSort:8

MergeSortNonR

image-20220217225434686

void _Merge(int* a, int* tmp, int begin1, int end1, int begin2, int end2)
{
	//两段有序子区间归并到tmp再拷贝回去
	int i = begin1;
	int j = begin1;
	while (begin1 <= end1 && begin2 <= end2)
	{
		if (a[begin1] < a[begin2])
		{
			tmp[i++] = a[begin1++];
		}
		else
		{
			tmp[i++] = a[begin2++];
		}
	}
	//一个先结束,就把另一个的全放进去
	while (begin1 <= end1)
	{
		tmp[i++] = a[begin1++];
	}
	while (begin2 <= end2)
	{
		tmp[i++] = a[begin2++];
	}
	//拷贝回去
	for (; j <= end2; j++)
	{
		a[j] = tmp[j];
	}
}

void MergeSortNonR(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}

	int gap = 1;//gap=1表示一一归并
	while (gap < n)
	{
		for (int i = 0; i < n; i += 2 * gap)
		{
			//[i,i+gap-1] [i+gap, i+2*gap-1]
			_Merge(a, tmp, i, i + gap - 1, i + gap, i + 2 * gap - 1);
		}
		gap *= 2;
	}
	free(tmp);
}

//非递归
void MergeSortNonR(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}

	int gap = 1;//gap=1表示一一归并
	while (gap < n)
	{
		for (int i = 0; i < n; i += 2 * gap)
		{
			//[i,i+gap-1] [i+gap, i+2*gap-1]
			int begin1 = i, end1 = i + gap - 1, begin2 = i + gap, end2 = i + 2 * gap - 1;
			//分析知,如果第二个小区间不存在就不需要归并
			if (begin2 >= n)
			{
				break;
			}
			//如果第二个小区间存在,但是不够gap个,结束位置越界
			//修正一下
			if (end2 >= n)
			{
				end2 = n - 1;
			}
			_Merge(a, tmp, begin1, end1, begin2, end2);
		}
		gap *= 2;
	}
	free(tmp);
}

image-20220217232321910

非比较排序

CountSort

绝对映射

统计出每个数出现的次数
A[i]是几就对Count数组对应位置的值++

统计出次数再排序

相对映射

映射时减去最小的那个值

image-20220218124130379

void CountSort(int* a, int n)
{
	int max = a[0], min = a[0];
	for (int i = 0; i < n; i++)
	{
		if (a[i] > max)
			max = a[i];
		if (a[i] < min)
			min = a[i];
	}
	int range = max - min + 1;
	int* count = (int*)malloc(sizeof(int) * range);
	if (count == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	//数组初始化为0
	memset(count, 0, sizeof(int) * range);
	//统计次数
	for (int i = 0; i < n; i++)
	{
		//相对映射
		count[a[i] - min]++;
	}
	//把数据写回去 count数组里放的是数据出现的次数
	int i = 0;
	for (int j = 0; j < range; j++)
	{
		while (count[j]--)
		{
			a[i++] = j + min;
		}
	}
	free(count);
}
//时间复杂度O(2*N+range)
//只适合一组数据,数据的范围比较集中
//空间复杂度O(range)
//如果数据集中,效率很高
//并且只适合整数 浮点数,字符串不行 因为没有用到比较

内排序

外排序

总结

image-20220218124621778

稳定性

image-20220218125421203

相关推荐

5.排序算法

云岭逸人 43 0 0

5.排序检索数据

凯约 79 0 0

5.堆栈算法

程序员漫画编程 44 0 0

C语言排序算法

编程练习生J 56 0 0

【C语言】排序算法 -------- 计数排序

尤克乔乔 36 0 0

5. C++对C语言增强以及扩展

双井暮色 25 0 0

【C语言】【排序算法】----- 归并排序

看山远兮 31 0 0

快速排序算法-C语言

非凡兔 38 0 0

C语言笔记33 •单链表经典算法OJ题-5.分割链表•

狐沐说 35 0 0

C语言分析基础排序算法——计数排序

孟佳 9 0 0

精彩评论（0）

0 0 举报