【数据结构】八大排序算法（经典）

最新推荐文章于 2023-07-23 20:04:18 发布

Huang_ZhenSheng

最新推荐文章于 2023-07-23 20:04:18 发布

阅读量306

点赞数 5

文章标签：数据结构算法

本文链接：https://blog.csdn.net/weixin_47132900/article/details/120315127

版权

常见的排序算法

插入排序

直接插入排序：

void InsertSort(int* a, int n)
{
	for (int i = 0; i < n - 1; i++)
	{
		int end = i;
		int tmp = a[end + 1];
		while (end >= 0)
		{
			if (a[end] > tmp)
			{
				a[end + 1] = a[end];
				end--;
			}
			else
			{
				break;
			}
		}
		a[end + 1] = tmp;
	}
}

希尔排序：

void ShellSort(int*a, int n)
{
	//gap > 1预排序
	//gap == 1直接插入排序
	int gap = n;
	while (gap > 1)
	{
		gap = gap / 3+1;//控制gap最后一组为1
		//间隔为gap的多组排序;
		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 = end - gap;
				}
				else
				{
					break;
				}
			}
			a[end + gap] = tmp;
		}
	}
}

选择排序

直接选择排序：

void swap(int*x, int*y)
{
	int tmpp = *x;
	*x = *y;
	*y = tmpp;
}
void SelectSort(int*a, int n)
{
	int begin = 0;
	int end = n - 1;
	while (begin < end)
	{
		//选出[begin，end]
		int min = begin;
		int max = begin;
		for (int i = begin; i <= end; i++)
		{
			if (a[i] > a[max])
			{
				max = i;
			}
			if (a[i] < a[min])
			{
				min = i;
			}
		}
		swap(&a[begin], &a[min]);
		swap(&a[end], &a[max]);
		begin++;
		end--;
	}
}

思考：这样会出现什么问题？

当begin就是max的时候，会出现错误，同理当end就是min的时候

这个时候更新一下max

void SelectSort(int*a,int n)
{
	int begin = 0;
	int end = n - 1;
	while (begin < end)
	{
		int max = begin;
		int min = begin;
		for (int i = begin; i <= end; i++)
		{
			if (a[i] > a[max])
			{
				max = i;
			}
			if (a[i] < a[min])
			{
				min = i;
			}
		}
		//知道了a[max],a[min]
		swap(&a[min],&a[begin]);
		if (begin == max)
		{
			max = min;
			swap(&a[end], &a[max]);
		}
		begin++;
		end--;
	}
}

时间复杂度：一次选2个数：O(N^2)

最好的时间复杂度：O(N^2)，就算有序也得遍历一遍，选出2个，没有办法判断“有序了不用遍历”这种场景

堆排序：

详见：堆排序

交换排序

冒泡排序：

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

时间复杂度：(n-1)(n-2)(n-3)(n-4)..... O(N^2)

优化：
void BubbleSort(int*a, int n)
{
	int enxchange = 0;
	for (int j = 0; j < n ; j++)
	{
		for (int i = 1; i < n-j; i++)
		{
			if (a[i-1] > a[i])
			{
				swap(&a[i - 1], &a[i]);
				enxchange = 1;
			}
		}
		if (enxchange == 0)
		{
			break;
		}
	}
}
最好：顺序有序就是最好O(N)，在怎样也得进去一圈

直接插入跟冒泡最好的情况都是O(N)
但是直接插入针对接近有序的情况次数更少，更好一些

快排：快排专题

归并排序(递归)

void _MergeSort(int*a,int left,int right,int*tmp)
{
	if (left >= right)
		return;
	int mid = left + (right - left) / 2;
	//[left, mid][mid+1,right]
	_MergeSort(a, left, mid, tmp);
	_MergeSort(a, mid+1, right, tmp);
	//归并
	int begin1 = left,end1 = mid;
	int begin2 = mid+1, end2 = right;
	int index = left;
	while (begin1 <= end1 && begin2 <= end2)
	{
		if (a[begin1] < a[begin2])
		{
			tmp[index] = a[begin1];
			index++;
			begin1++;
		}
		else
		{
			tmp[index] = a[begin2];
			index++;
			begin2++;
		}
	}
	while (begin1 <= end1)
	{
		tmp[index++] = a[begin1++];
	}
	while (begin2 <= end2)
	{
		tmp[index++] = a[begin2++];
	}
	//归并后的结果，拷贝回到原数组
	for (int i = left; i <= right; i++)
	{
		a[i] = tmp[i];
	}
}
void MergeSort(int*a ,int n)
{
	int*tmp = (int*)malloc(sizeof(int)* n);
	_MergeSort(a, 0, n-1, tmp);
	free(tmp);
}
PrintSort(int*a,int n)
{
	for (int i = 0; i < n; i++)
	{
		printf("%d ",a[i]);
	}
}
int main()
{
	int a[] = { 6, 1, 2, 7, 9, 3, 4, 5, 10, 8 };
	int n = sizeof(a) / sizeof(int);
	int left = 0;
	int right = n - 1;
	MergeSort(a ,n);
	PrintSort(a,n);
	return 0;
}

归并排序（非递归）

_MergeSortNonR(int*a,int n)
{
	int* tmp = (int*)malloc(sizeof(int)*n);
	for (int groupNum = 1; groupNum < n; groupNum = groupNum * 2)
	{
		for (int i = 0; i < n; i = i + 2 * groupNum)
		{
			int begin1 = i; int end1 = i + groupNum - 1;
			int begin2 = i + groupNum; int end2 = i + groupNum * 2 - 1;
			int index = begin1;
			while (begin1 <= end1 && begin2 <= end2)
			{
				if (a[begin1] < a[begin2])
				{
					tmp[index] = a[begin1];
					index++;
					begin1++;
				}
				else
				{
					tmp[index] = a[begin2];
					index++;
					begin2++;
				}
			}
			while (begin1 <= end1)
			{
				tmp[index] = a[begin1];
				index++;
				begin1++;
			}
			while (begin2 <= end2)
			{
				tmp[index] = a[begin2];
				index++;
				begin2++;
			}
		}
		for (int i = 0; i < n; i++)
		{
			a[i] = tmp[i];
		}
	}
	free(tmp);
}
void PrintSort(int*a,int n)
{
	for (int i = 0; i < n; i++)
	{
		printf("%d ",a[i]);
	}
}
int main()
{
	int a[] = { 10, 6, 7, 1, 3, 9, 4, 2 };
	int n = sizeof(a) / sizeof(int);
	_MergeSortNonR(a,n);
	PrintSort(a,n);
	return 0;
}

如果多1个或者2个数会怎样？

加一下判断条件:(注意调试！！！)

if (begin2 >= n)
			{
				begin2 = n + 1;
				end2 = n;
			}
			if (end1 >= n)
			{
				end1 = n - 1;

			}
			if (end2 >= n)
			{
				end2 = n - 1;
			}

非比较排序：计数排序

PrintSort(int*a,int n)
{
	for (int i = 0; i < n; i++)
	{
		printf("%d ",a[i]);
	}
}

void CountSort(int*a,int n)
{
	int min = a[0];
	int max = a[0];
	for (int i = 1; i < n; i++)
	{
		if (a[i] < min)
		{
			min = a[i];
		}
		if (a[i] > max)
		{
			max = a[i];
		}
	}
	int range = max - min + 1;
	int*count = (int*)calloc(range,sizeof(int));
	//统计次数
	for (int i = 0; i < n; i++)
	{
		count[a[i] - min]++;
	}
	int i = 0;
	for (int j = 0; j < range; j++)
	{
		//根据count数组排序
		while (count[j]--)
		{
			a[i++] = j + min;
		}
	}
}

int main()
{
	int a[] = { 2,5,3,0,2,3,0,3};
	int n = sizeof(a) / sizeof(int);
	int left = 0;
	int right = n - 1;
	/*MergeSort(a ,n);*/
	CountSort(a,n);
	PrintSort(a,n);
	return 0;
}