简易排序算法实现

最新推荐文章于 2022-05-25 00:16:17 发布

ice_玖闻于世丶

最新推荐文章于 2022-05-25 00:16:17 发布

阅读量216

点赞数 1

分类专栏：数据结构文章标签：排序算法数据结构

本文链接：https://blog.csdn.net/weixin_42357849/article/details/105982680

版权

数据结构专栏收录该内容

11 篇文章 1 订阅

订阅专栏

一.排序介绍。

排序概念：

排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。
内部排序：数据元素全部放在内存中的排序。
外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。

常见的排序算法：

二.排序算法的实现。

(一)插入排序。

直接插入排序：
直接插入排序是一种简单的插入排序法，其基本思想是：把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列。
例如：5，2，4，6，1；

将数组5，2，4，6，1，3进行升序排列：
①直接插入排序：

void PrintArray(int *arr, int left, int right)
{
	int i = 0;
	for (i = left; i <= right; ++i)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}

void Swap(DataType* a, DataType* b)//交换函数
{
	DataType tem = *a;
	*a = *b;
	*b = tem;
}

void InertSort_1(int* arr, int left, int right)//直接插入排序
{
	int i = 0;
	for (i = left + 1; i <= right; ++i)
	{
		int key = arr[i];
		int end = i - 1;
		while (end >= left && key < arr[end])
		{
			arr[end + 1] = arr[end];
			end--;
		}
		arr[end + 1] = key;
	}
}

// 直接插入，调用Swap函数
void InsertSort_2(int *arr, int left, int right)
{
	int i = left + 1;
	for (i = left + 1; i <= right; ++i)
	{
		int end = i - 1;
		while (end >= left && arr[end + 1] < arr[end])
		{
			Swap(&arr[end + 1], &arr[end]);
			end--;
		}
	}
}

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

	//InertSort_1(arr,0,sz-1);//直接插入排序
	InsertSort_2(arr, 0, sz - 1);//直接插入Swap交换排序

	PrintArray(arr, 0, sz - 1 );//打印数组

	return 0;
}

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

②二分查找插入：

void BinInsertSort(int *arr, int left, int right)
{
	int low, high, mid;//low 
	int tem, j;
	for (int i = left + 1; i <= right; i++)
	{
		low = left;
		high = i - 1;
		tem = arr[i];
		while (low <= high)
		{
			mid = (low + high) / 2;
			if (tem < arr[mid])
				high = mid - 1;
			if (tem >= arr[mid])
				low = mid + 1;
		}
		for (j = i; j > low; --j)//挪出low位置
		{
			arr[j] = arr[j - 1];
		}
		arr[low] = tem;//tem插入的位置是low
	}
}

③两路插入排序：

void TwoWayInsertSort(int *arr, int left, int right)//两路插入排序
{
	int n = right - left + 1;//
	int *tem = (int*)malloc(sizeof(int)*n);//申请新的空间

	tem[0] = arr[left];
	int start, final;
	start = final = 0;
	int key = 0;
	for (int i = left + 1; i <= right; ++i)
	{
		key = arr[i];
		if (key < tem[start])//1.插在start前面
		{
			start = (start - 1 + n) % n;
			tem[start] = key;
		}
		else if (key > tem[final])//2.直接插到final后
		{
			final++;
			tem[final] = key;
		}
		else//3.两者之间
		{
			int end = final;
			final++;
			while (key < tem[end])
			{
				tem[(end + 1) % n] = tem[end];
				end = (end - 1 + n) % n;
			}
			tem[(end + 1) % n] = key;
		}
	}
	for (int i = 0; i<n; ++i)//将tem 移入arr 中
	{
		arr[i] = tem[start];
		start = (start + 1) % n;
	}
	free(tem);
}

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

void ShellSort(int *arr, int left, int right)//希尔排序 
{
	int gap = right - left + 1;//总长度
	while (gap > 1)//增量必须大于1
	{
		gap = gap / 3 + 1;//gap增量的确定。
		for (int i = left; i <= right - gap; ++i)
		{
			int end = i;
			int tem = arr[end + gap];
			while (end >= left && tem<arr[end])
			{
				arr[end + gap] = arr[end];//
				end -= gap;
			}
			arr[end + gap] = tem;
		}
	}

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

(二)选择排序。

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

在元素集合array[i]–array[n-1]中选择关键码最大(小)的数据元素
若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中的最后一个（第一个）元素交换
在剩余的array[i]–array[n-2]（array[i+1]–array[n-1]）集合中，重复上述步骤，直到集合剩余1个元素

//直接选择排序
static int GetMinIndex(int *arr, int left, int right)
{
	int index = left;
	int min = arr[left];//保存在小得值
	for (int i = left + 1; i <= right; ++i)
	{
		if (min > arr[i])
		{
			min = arr[i];
			index = i;
		}
	}
	return index;//最小值得下标
}

void SelectSort(int *arr, int left, int right)
{
	int i = 0;
	for (i = left; i < right; i++)
	{
		int index = GetMinIndex(arr, i, right);//获取最小值的下标
		if (index != i)
		{
			Swap(&arr[index], &arr[i]);
		}
	}
}

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

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

//堆排序
static void AdjustDown(int *arr, int n, int start)//形成小堆
{
	int i = start;
	int j = 2 * i + 1;
	while (j < n)
	{
		if (j+1 < n && arr[j] <arr[j + 1])
			j++;
		if (arr[i] < arr[j])
		{
			Swap(&arr[i], &arr[j]);
			i = j;
			j = 2 * i + 1;
		}
		else
			break;
	}
}

void HeapSort(int *arr, int left, int right)//堆排序
{
	int n = right - left + 1;//数据长度
	int cur = (n - 1) / 2;//
	while (cur > left)
	{
		AdjustDown(arr, n, cur);
		cur--;
	}
	int end = right;
	while (end >= left)
	{
		Swap(&arr[left], &arr[end]);
		AdjustDown(arr, end - left, 0);
		end--;
	}
}

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

(三)交换排序。

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

void BubbleSort(int *arr, int left, int right)//冒泡排序
{
	for (int i = left; i < right; ++i)
	{
		bool inser = false;
		for (int j = left; j < right - i; ++j)
		{
			if (arr[j]>arr[j + 1])
				Swap(&arr[j], &arr[j + 1]);
			inser = true;
		}
		if (!inser)//没进第二个for则退出
			break;
	}
}

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

②快速排序：
基本思想为：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

int Partition(int* arr, int left, int right)
{
	int key = arr[left];
	while (left < right)
	{
		while (left<right && arr[right] >= key)
			right--;
		Swap(&arr[left], &arr[right]);
		while (left<right && arr[left]<key)
			left++;
		Swap(&arr[left], &arr[right]);
	}
	return left;//确定pos左边的值比arr[pos]小，右边的值比arr[pos]大
}

void QuickSort(int *arr, int left, int right) //快速排序
{
	if (left >= right)
		return;
	if (right - left + 1 <= M)
		InsertSort_1(arr, left, right);
	else
	{
		int pos = Partition(arr, left, right);
		QuickSort(arr, left, pos - 1);
		QuickSort(arr, pos + 1, right);
	}
}

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

(四)归并排序。

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide andConquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

void _MergeSort(int *ar, int left, int right, int *tmp)
{
	if (left >= right)
		return;
	int mid = (left + right) / 2;
	_MergeSort(ar, left, mid, tmp);
	_MergeSort(ar, mid + 1, right, tmp);

	int begin1 = left; //左区间 [left,mid]
	int end1 = mid;
	int begin2 = mid + 1;//右区间[mid+1, right]
	int end2 = right;

	int i = left;
	while (begin1 <= end1 && begin2 <= end2)
	{
		if (ar[begin1] < ar[begin2])
			tmp[i++] = ar[begin1++];
		else
			tmp[i++] = ar[begin2++];
	}

	while (begin1 <= end1)
		tmp[i++] = ar[begin1++];
	while (begin2 <= end2)
		tmp[i++] = ar[begin2++];

	memcpy(ar + left, tmp + left, sizeof(int)*(right - left + 1));
}

void MergeSort(int *ar, int left, int right)
{
	int n = right - left + 1;
	int *tmp = (int*)malloc(sizeof(int)*n);

	_MergeSort(ar, left, right, tmp);

	free(tmp);
}

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

ice_玖闻于世丶

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录