常见排序算法

最新推荐文章于 2024-08-26 21:46:59 发布

真得学12138

最新推荐文章于 2024-08-26 21:46:59 发布

阅读量289

点赞数 3

文章标签：排序算法算法数据结构 c语言

本文链接：https://blog.csdn.net/qq_73781875/article/details/137958320

版权

插入

直接插入排序

动图演示

特性

1、元素越接近有序，直接插入排序效率越高

2、时间复杂度O(n^2)，最好情况复杂度为O(n)

3、空间复杂度O(1)

4、是一个稳定的排序算法

// 插入排序（升序）
void InsertSort(int* a, int n)
{
	for(int i = 0; i < n - 1; i++)
	{
		//用end记录有序序列最后一个元素下标，第一趟排序有序序列最后一个元素下标为0
		int end = i;
		//tmp记录两两比较较大数，第一趟时记录有序序列后一个
		int tmp = a[end + 1];
		//单趟
		//在有序序列中找到比tmp小的则会break退出插入
		//可能找完有序序列没有符合的，则会end=-1退出，将tmp插入0处
		while (end >= 0)
		{
			//end前移找比tmp小的，将比tmp大的后移一位，end自减将有序序列编译一遍查找
			if (a[end] >= tmp)
			{
				a[end + 1] = a[end];
				end--;
			}
			//找到比tmp小的数停下退出
			else
			{
				break;
			}
		}
		//将tmp插入比tmp小的后一位
		a[end + 1] = tmp;
	}
}

希尔排序

演示

特性

1、希尔排序时直接插入排序的优化，在gap>1时都是在预排序，当gap=1时接近有序，再用插入排序会使效率快很多

2、时间复杂度O(n^2)，但最好情况时间复杂度为O(n^1.3)

3、排序不稳定

void ShellSort(int* a, int n)
{
	int gap = n;
	//gap>1时都是在预排序，当gap=1时接近有序相当于使用直接插排
	while(gap > 1)
	{
		gap = gap / 2;
		//单趟，与插排类似
		for (int i = 0; i < n - gap; i++)
		{
			int end = i;
			int tmp = a[end + gap];
			while (end >= 0)
			{
				if (a[end] >= tmp)
				{
					a[end + gap] = a[end];
					end -= gap;
				}
				else
				{
					break;
				}
			}
			a[end + gap] = tmp;
		}
	}
}

选择

选择排序

动图演示

特性

1、时间复杂度O(n^2)

2、空间复杂度O(1)

3、不稳定

void SelectSort(int* a, int n)
{
	int  begin = 0, end = n - 1;
	while (begin < end)
	{
		//选择排序的基本思想是每次排序定下一个最大或最小的位置
		//优化一下，每趟把最大和最小一起定位
		int maxi = begin, mini = begin;
		for (int i = begin; i <= end; i++)
		{
			if (a[i] < a[mini])
			{
				mini = i;
			}
			if (a[i] > a[maxi])
			{
				maxi = i;
			}
		}
		// 最小值放在序列开头
		Swap(&a[mini], &a[begin]);
		//防止最大的数在begin位置被换走
		if (begin == maxi)
		{
			maxi = mini;
		}
		//最大值放在序列结尾
		Swap(&a[maxi], &a[end]);
		end--;
		begin++;
	}
}

堆排序

特性

1、时间复杂度O(n*logn)

2、空间复杂度O(1)

3、不稳定

void Swap(HPDataType* p1, HPDataType* p2)
{
	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
 
void AdjustDown(HPDataType* a, int size, int parent)
{
	int child = parent * 2 + 1;
 
	while (child < size)
	{
		if (child + 1 < size && 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)
{
	assert(a);
 
	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]);
		AdjustDown(a, end, 0);
		end--;
	}

交换

冒泡排序

动图演示

特性

1、时间复杂度O(n^2)

2、空间复杂度O(1)

3、稳定

void Swap(int* a, int* b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}

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

快速排序

hoare法

演示

为了应对一些特殊情况，比如1，5，8，7，4，3，6这种情况，第一趟拿key=1时，这一趟排序就没有意义，这时可以考虑三数取中，从头尾中三个位置取一个中间值就好了

int GetMidi(int* a, int begin, int end)
{
	int midi = (begin + end) / 2;
	if (a[midi] > a[begin])
	{
		if (a[begin] > a[end])
			return begin;
		else if (a[end] > a[midi])
			return midi;
		else
			return end;
	}
	else
	{
		if (a[midi] > a[end])
			return midi;
		else if (a[end] > a[begin])
			return begin;
		else
			return end;
	}
}

int PartSort1(int* a, int begin, int end)
{
	int midi = GetMidi(a, begin, end);
	Swap(&a[midi], &a[begin]);
	int keyi = begin;
	int left = begin, right = end;
	while(left < right)
	{
		while (a[right] >= a[keyi] && left < right)
		{
			right--;
		}
		while (a[left] <= a[keyi] && left < right)
		{
			left++;
		}
		Swap(&a[right], &a[left]);
	}
	Swap(&a[keyi], &a[right]);
	return right;
}

void QuickSort(int* a, int left, int right)
{
	if (left >= right)
		return;
	int key = PartSort1(a, left, right);
	QuickSort(a, left, key);
	QuickSort(a, key + 1, right);
}

挖坑法

演示

int PartSort2(int* a, int left, int right)
{
	int midi = GetMidi(a, left, right);
	Swap(&a[midi], &a[left]);
	int hole = left;
	int key = a[left];
	while (right > left)
	{
		while (right > left && a[right] >= key)
		{
			right--;
		}
		a[hole] = a[right];
		hole = right;
		while (right > left && a[left] <= key)
		{
			left++;
		}
		a[hole] = a[left];
		hole = left;
	}
	a[hole] = key;
	return hole;
}
void QuickSort(int* a, int left, int right)
{
	if (left >= right)
		return;
	int key = PartSort2(a, left, right);
	QuickSort(a, left, key);
	QuickSort(a, key + 1, right);
}

前后指针法

演示

int PartSort3(int* a, int left, int right)
{
	int midi = GetMidi(a, left, right);
	Swap(&a[midi], &a[left]);
	int prev = left;
	int cur = left + 1;
	int key = left;
	while (cur <= right)
	{
		if (a[cur] < a[key] && ++prev != cur)
			Swap(&a[prev], &a[cur]);
		cur++;
	}
	Swap(&a[prev], &a[key]);
	return prev;
}

void QuickSort(int* a, int left, int right)
{
	if (left >= right)
		return;
	int key = PartSort3(a, left, right);
	QuickSort(a, left, key);
	QuickSort(a, key + 1, right);
}

非递归快排

非递归就是用栈模拟递归排序，先将left和right入栈，出栈排序，找到key值，再将left和key-1、key+1和right分别入栈，注意入栈出栈顺序。

void QuickSortNonR(int* a, int left, int right)
{
	Stack s;
	StackInit(&s);
	StackPush(&s, left);
	StackPush(&s, right);
	while (!StackEmpty(&s))
	{
		int right = StackTop(&s);
		StackPop(&s);
		int left = StackTop(&s);
		StackPop(&s);
		int key = PartSort3(a, left, right);
		if (left < key - 1)
		{
			StackPush(&s, left);
			StackPush(&s, key - 1);
		}
		if (right > key + 1)
		{
			StackPush(&s, key + 1);
			StackPush(&s, right);
		}
	}
	StackDestroy(&s);
}

快排特性

1、时间复杂度O(n*logn)，最坏情况会出现O(n^2)

2、空间复杂度O(logn)~O(n)

3、不稳定

归并排序

演示

特性

1、时间复杂度O(n*logn)

2、空间复杂度O(n)

3、稳定

4、归并排序大部分是用来处理磁盘的外排序问题

递归归并

void _MergeSort(int* a, int begin, int end, int* tmp)
{
	if (begin >= end)
	{
		return;
	}
	int mid = (begin + end) / 2;
	_MergeSort(a, begin, mid, tmp);
	_MergeSort(a, mid + 1, end, tmp);
	int begin1 = begin, end1 = mid;
	int begin2 = mid + 1, end2 = end;
	int i = begin;
	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++];
	}
	memcpy(a + begin, tmp + begin, sizeof(int) * (end - begin + 1));
}

void MergeSort(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		perror("malloc fail");
		return;
	}
	_MergeSort(a, 0, n - 1, tmp);
	free(tmp);
	tmp = NULL;
}

非递归归并

void MergeSortNonR(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		perror("malloc fail");
		return;
	}
	int gap = 1;
	while (gap < n)
	{
		printf("gap:%2d->", gap);
		for (size_t i = 0; i < n; i += 2 * gap)
		{
			int begin1 = i, end1 = i + gap - 1;
			int begin2 = i + gap, end2 = i + 2 * gap - 1;
			// [begin1, end1][begin2, end2] 归并
			//printf("[%2d,%2d][%2d, %2d] ", begin1, end1, begin2, end2);
			// 边界的处理
			if (end1 >= n || begin2 >= n)
			{
				break;
			}

			if (end2 >= n)
			{
				end2 = n - 1;
			}
			//printf("[%2d,%2d][%2d, %2d] ", begin1, end1, begin2, end2);
			int j = begin1;
			while (begin1 <= end1 && begin2 <= end2)
			{
				if (a[begin1] < a[begin2])
				{
					tmp[j++] = a[begin1++];
				}
				else
				{
					tmp[j++] = a[begin2++];
				}
			}

			while (begin1 <= end1)
			{
				tmp[j++] = a[begin1++];
			}

			while (begin2 <= end2)
			{
				tmp[j++] = a[begin2++];
			}

			memcpy(a + i, tmp + i, sizeof(int) * (end2 - i + 1));
		}

		printf("\n");

		gap *= 2;
	}
	free(tmp);
}

计数（非交换）排序

计数排序就是统计数字出现的个数，然后再按顺序复制回原数组。

特性

1、时间复杂度O(MAX(n,range))

2、空间复杂度O(range)

3、稳定

4、效率非常快，但是使用场景非常有限，适合元素范围集中的，且只适合数字排序

void CountSort(int* a, int n)
{
	int max = a[0], min = a[0];
	for (int i = 1; i < n; i++)
	{
		if (max < a[i])
		{
			max = a[i];
		}
		if (min > a[i])
		{
			min = a[i];
		}
	}
	int range = max - min + 1;
	int* tmp = (int*)calloc(sizeof(int), range);
	if (tmp == NULL)
	{
		printf("calloc fail\n");
		return;
	}
	//统计次数
	int i = 0;
	while (i < n)
	{
		tmp[a[i++] - min]++;
	}
	i = 0;
	for (int j = 0; j < range; j++)
	{
		while (tmp[j]--)
		{
			a[i++] = j + min;
		}
	}
}