排序

最新推荐文章于 2024-06-06 09:35:49 发布
最新推荐文章于 2024-06-06 09:35:49 发布
阅读量247 收藏
点赞数 2
分类专栏： C语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a331683772/article/details/90584503
版权

复杂度分析

在这里插入图片描述

插入排序

1.基本思想

把待排序的记录按其大小逐个插入到一个已经排序好的有序序列中，直到所有的记录插入完为止，从而得到一个有序序列。

2. 过程

当插入第i(i>=1)个元素时，a[0],a[1],…,a[i-1]已经排好序，用a[i]的值与 a[i-1],a[i-2],…的值顺序进行比较，找到插入位置即将a[i]插入，原来位置上的元素顺序后移。

在这里插入图片描述

3.特性总结
  1. 元素集合越接近有序，直接插入排序算法的时间效率越高
  2. 时间复杂度：O(N^2)
  3. 空间复杂度：O(1)，它是一种稳定的排序算法
  4. 稳定性：稳定
    适合：数据量小，接近有序
4.实现
void InsertSort(int *array,int size)
{
	for (int i = 1; i < size; i++)
	{
		int key = array[i];
		//寻找key的插入位置
		int end = i - 1;
		while(key < array[end])
		{
			array[end + 1] = array[end];
			end--;
		}
		array[end + 1] = key;
	}
}
void SortTest()
{
	int a[] = { 8,4,6,7,1,3,9,};
	InserSort(a,sizeof(a)/sizeof(a[0]));
}

希尔排序

1.基本思想

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

2.过程

在这里插入图片描述

3.总结
  1. 希尔排序是对直接插入排序的优化。
  2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就 会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。
  3. 希尔排序的时间复杂度不好计算，需要进行推导，推导出来平均时间复杂度： O(N1.3—N2）
  4. 稳定性：不稳定
    适合数据量大，不接近有序
4.实现
void ShellSort(int *array, int size)
{
	int gap = 3;
	while (gap > 0)
	{
		for (int i = gap; i < size; ++i)
		{
			//待插入元素
			int key = array[i];
			//找key的插入位置：
			int end = i - gap;
			while (end >= 0 && key < array[end])
			{
				array[end + gap] = array[end];
				end = end - gap;
			}
			array[end + gap] = key;
		}
		gap--;
	}
}

void SortTest()
{
	int a[] = { 8,4,6,7,1,3,9,};
	ShellSort(a,sizeof(a)/sizeof(a[0]));
}

3.选择排序

1.基本思想

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

2.过程

在这里插入图片描述

3.总结
  1. 直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用
  2. 时间复杂度：O(N^2)
  3. 空间复杂度：O(1)
  4. 稳定性：不稳定
    适合数据量大，数据重复量大
4.实现
void SelectSort(int *array, int size)
{
	for (int i = 0; i < size - 1; i++)//趟数
	{
		int MaxPos = 0;
		for (int j = 1; j < size - i; ++j)//找到最大值的下标
		{
			if (array[j] > array[MaxPos])
			{
				MaxPos = j;
			}
		}
		if (MaxPos != size - 1 - i)
			Swap(&array[MaxPos], &array[size - 1 - i]);

	}
}
//双向同时找最大最小
void SelectSortOP(int *array, int size)
{
	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 = index + 1;
		}
		if (MaxPos != end)
			Swap(&array[MaxPos], &array[end]);
		if ( MinPos == end) //如果最小数是最后一个，再上一步交换后最小数已经交换到最大数的下标处
		{
			MinPos = MaxPos;
		}
		if (MinPos != begin)
			Swap(&array[MinPos], &array[begin]);
		begin++;
		end--;
	}
}

void SortTest()
{
	int a[] = { 8,4,6,7,1,3,9,};
	SelectSort(a,sizeof(a)/sizeof(a[0]));
	//SelectSortOP(a,sizeof(a)/sizeof(a[0]));
}

快速排序（递归）

1.基本思想

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

  1. hoare版本 2. 前后指针版本 3. 挖坑法
int Partion(int *array,int left,int right)
{
	int begin = left;
	int end = 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]);
	}
		if (begin != right -1)
			Swap(&array[begin], &array[right - 1]);//把基准值换到中间
		return begin;
}
int Partion1(int *array, int left, int right)
{
	int cur = left;
	int pre = cur - 1;
	int key = array[right - 1];
	while (cur < right)
	{
		if (array[cur] < key && ++pre != cur)
			Swap(&array[pre], &array[cur]);
		cur++;
	}
	if (++pre != right)
	{
		Swap(&array[pre], &array[right - 1]);
	}
	return pre;
}
int Partion2(int *array, int left, int right)
{
	int begin = left;
	int end = right - 1;
	int key = array[right - 1];
	while (begin < end)
	{
		//从前往后找比基准值大的元素，找到后填充end位置
		while (begin < end && array[begin] <= key)
		{
			begin++;
		}
		//填充end的位置
		if (begin < end)
		{
			array[end] = array[begin];
			end--;
		}
		//从后往前找比基准值小的元素，找到后填充begin的位置
		while (begin < end && array[end] >= key)
		{
			end--;
		}
		if (begin < end)
		{
			array[begin] = array[end];
			begin++;
		}
	}
	array[begin] = key;
	return begin;
}
void QuickSort(int* array, int left, int right)
{
//	if (right - left > 1)
//	{
//		int div = Partion2(array, left, right);//Partion Partion2
//	    QuickSort(array, left, div);
//      QuickSort(array, div + 1, right);
//  }
	
	if (right - left < 16)
	{
		InsertSort(array, right - left);
	}
	else
	{
		int div = Partion1(array, left, right);//Partion Partion2
		QuickSort(array, left, div);
		QuickSort(array, div + 1, right);
	}
}

快速排序（栈模拟递归）

导入头文件Stack.h,代码 ： https://blog.csdn.net/a331683772/article/details/90238944

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);

		int div = Partion2(array, left, right);

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

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

void SortTest()
{
	int a[] = { 8,4,6,7,1,3,9,};
	QuickSortNor(a, (sizeof(a) / sizeof(a[0])));
}

归并排序

1.基本思想

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

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)
		temp[index++] = array[begin2++];
}

void _MergeSort(int* array, int left, int right, int* temp)
{
	if (right - left > 1)
	{
		int mid = left + ((right - left) >> 1);
		// [left, mid)
		// [mid, right)
		_MergeSort(array, left, mid, temp);
		_MergeSort(array, mid, right, temp);
		MergeData(array, left, mid, right, temp);
		memcpy(array+left, temp+left, sizeof(int)*(right-left));
	}
}

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)
	{
		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);
		gap *= 2;
	}
	
	free(temp);
}

堆排序

void HeadAdjust(int *array, int size, int root)
{
	int child = root * 2 + 1;
	while (child < size)
	{
		if ((child + 1) < size && array[child] < array[child + 1])
		{
			child = child + 1;
		}
		if (array[child] > array[root])
		{
			Swap(&array[child], &array[root]);
			root = child;
			child = child * 2 + 1;
		}
		else
		{
			return;
		}
	}

}
void HeadSort(int *array, int size)
{
	int root = (size - 2) / 2;
	for (; root >= 0; --root)
		HeadAdjust(array, size, root);
	int end = size - 1;
	while (end)
	{
		Swap(&array[0], &array[end]);
		HeadAdjust(array, end, 0);
		end--;
	}
}
ChengQianO
关注
专栏目录
归并排序 详解
k_koris的博客
05-30 28万+
注：内容，图片来自于慕课网liuyubobobo老师的课程。 算法复杂度：O（nlogn）； 也许有很多同学说，原来也学过很多O（n^2）或者O（n^3）的排序算法，有的可能优化一下能到O（n）的时间复杂度，但是在计算机中都是很快的执行完了，没有看出来算法优化的步骤，那么我想说有可能是你当时使用的测试用例太小了，我们可以简单的做一下比较： 当数据量很大的时候 nlogn的优势将会比...
【数据结构与算法】：插入排序与希尔排序
Quietcoder的博客
03-14 2385
排序的稳定性是指在排序过程中，具有相等键值的元素在排序前后保持相同顺序的特性。简单来说，如果排序前两个相等的元素A和B（A出现在B之前），在排序后A仍然出现在B之前，那么这种排序算法就是稳定的；反之，如果排序后A和B的顺序发生了变化，这种排序算法就是不稳定的。稳定性在某些情况下很重要，尤其是当排序的键值是复合的，即基于多个字段进行排序时。在这种情况下，保持相等元素的初始顺序可能对保持数据的某种有意义的顺序非常关键。
插入排序
神韵
12-09 1万+
一、插入排序（InsertSort） 插入排序从第二个数开始，拿出第二个数进行向前插入排序，一直到最后一个数向前做插入排序。算法稳定。 插入排序的时间复杂度为O(n^2)，空间复杂度为O(1)。最好的时间复杂度是O(n)，最坏也就是平均是O(n^2) 二、图解 对于一串数字（3，5，2，1，4，10）进行插入从小到大排序，如下图演示 三、算法分析 /...
各种内部排序算法的比较及应用（插入排序、交换排序、选择排序、归并排序、基数排序）
最新发布
心碎烤肠的博客
06-06 1788
这篇文章总结了所有内部排序的适用场景，性质特点，以及空间和时间复杂度的考量； 前半部分是对内部排序的总结，后半部分是对所有内部排序的具体性能分析；
常见排序算法(插入排序，希尔排序，选择排序，堆排序，冒泡排序，快速排序，归并排序，计数排序，基数排序，桶排序）
2301_80288511的博客
04-21 2394
常见排序算法(插入排序，希尔排序，选择排序，堆排序，冒泡排序，快速排序，归并排序，计数排序，基数排序，桶排序）
交换排序，选择排序，冒泡排序
小S的博客
07-10 1747
交换排序，选择排序，冒泡排序
排序——交换排序
zdlynj的博客
05-14 2114
前面我们讲了直接插入排序和希尔排序这两种插入排序，以及直接选择排序和堆排序这两种选择排序。如果还有什么问题就请点击下面的链接插入排序选择排序那么今天我们就来讲一讲交换排序。
排序 - 冒泡排序
yangliusi的博客
07-30 2053
冒泡排序 冒泡排序（Bubble Sort）是一种简单稳定的排序算法。 这个算法的名字由来是因为越小的元素会经由慢慢交换“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。 排序原理 比较相邻的元素，如果第一个比第二个大，则交换他们的位置。 对每一对相邻的元素重复步骤1，从开始的第一对到结尾的最后一对，则最后的元素会是最大的数。 针对所有的元素重复以上的步骤，除了最后一个，每趟找出一个最大元素。 持续每次对越来越少的元素重复上面的步骤，直到没有任何一
八大排序算法(含时间复杂度、空间复杂度、算法稳定性)
Xpccccc的博客
10-13 5588
八大排序算法(含时间复杂度、空间复杂度、算法稳定性)
堆排序详细图解（通俗易懂）
oorik的博客
02-17 24万+
什么是堆 堆是一种叫做完全二叉树的数据结构，可以分为大根堆，小根堆，而堆排序就是基于这种结构而产生的一种程序算法。 堆的分类 大根堆:每个节点的值都大于或者等于他的左右孩子节点的值 小根堆:每个结点的值都小于或等于其左孩子和右孩子结点的值 两种结构映射到数组为: 大根堆: 小根堆: //父-->子:i--->左孩子:2*i+1, 右孩子:2*i+2; //子-->父:i--->(i-1)*2;(i为下标元素) 排序思想 1.首先将待排序的数...
快速排序法（详解）
热门推荐
小白的博客
07-01 58万+
假设对以下10个数进行快速排序： 6 1 2 7 9 3 4 5 10 8 我们先模拟快速排序的过程：首先，在这个序列中随便找一个数作为基准数，通常为了方便，以第一个数作为基准数。 6 1 2 7 9 3 4 5 10 8 在初始状态下，数字6在序列的第1位。我们的目标是将6挪到序列中间的某个位...
冒泡排序（超详细）
hcz666的博客
06-11 38万+
1、什么是冒泡排序？ 冒泡排序的英文Bubble Sort，是一种最基础的交换排序。之所以叫做冒泡排序，因为每一个元素都可以像小气泡一样，根据自身大小一点一点向数组的一侧移动。 冒泡排序的原理： 每一趟只能确定将一个数归位。即第一趟只能确定将末位上的数归位，第二趟只能将倒数第 2 位上的数归位，依次类推下去。如果有 n 个数进行排序，只需将 n-1 个数归位，也就是要进行 n-1 趟操作。 而 “每一趟 ” 都需要从第一位开始进行相邻的两个数的比较，将较大的数放后面，比较完毕之后向后挪一位继续比较下面
python数组排序方法详解（sort， sorted，argsort）
什么都干的派森
09-27 7万+
这三个排序方法应对日常工作基本够用 先说一下三者的区别 sort， sorted 是用在 list 数据类型中的排序方法 argsort 是用在 numpy 数据类型中的排序方法（ numpy 里也有一个 sort 方法，下面会讲） sort 和 sorted 的区别如下???? 先看两个简单的升序排序，分别使用 sorted 和 sort 方法 # sorted num_list = [1, 8, 2, 3, 10, 4, 5] ordered_list = sorted(num_list) print
插入排序、归并排序、堆排序和快速排序的稳定性分析
笔者从事电信媒体开发多年，愿意将多年的开发经验分享给同行
03-28 2019
在计算机科学中，排序是将一组数据按照特定顺序进行排列的过程。排序算法的效率和稳定性是评价其优劣的两个重要指标。稳定性指的是在排序过程中，相等的元素在排序后保持原有的相对顺序。本文将详细分析插入排序、归并排序、堆排序和快速排序这四种常见排序算法的稳定性，并通过浅显易懂的语言进行解释。
输入行数（奇数），输出对应菱形
a331683772的博客
11-19 1万+
分为上下两部分画出，下部分比上部分少一行。#include<stdio.h> #include<stdlib.h> int main() { int n = 0; //输入行数 int i = 0;//控制行数 int m = 0;//空格数 int z = 0;//星号数 printf("请输入行数（奇数）："); scanf("%d",&n);
字符数组内容逆序输出
a331683772的博客
12-18 3825
有一个字符数组的内容为:”student a am i”,请你将数组的内容改为”i am a student”.主要实现:先把每个单词逆序，在整体逆序输出。 代码：#include<stdio.h> #include<stdlib.h> #include<ctype.h> void reserves(char *start,char *end) { while(start<end)
输入一个数求其a+aa+aaa+aaaa+aaaaa......前n项的和
a331683772的博客
11-19 1137
#include<stdio.h> #include<stdlib.h> nt main() { int sum = 0; int psum =0; int n = 0; int m = 0; int i =0; printf("请输入数字和项数："); scanf("%d%d",&m,&n); for(i = 0 ;i<n;
1到 100 的所有整数中出现多少次数字9
a331683772的博客
11-15 1036
先判断个位是否为9，在判断十位为9。#include<stdio.h> #include<stdlib.h> int main() { int i = 0; int count = 0; for(i = 1;i <= 100;i++) { if(i%10 == 9) { count++; }
排序算法详解：内部排序与外部排序
"这篇文档详细介绍了各种排序算法，包括排序的定义、稳定性和不同类型的排序方法，如插入排序、交换排序、选择排序、归并排序、分配排序以及外部排序等。文档强调了排序的基本思想、性能分析以及各种排序算法的特点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值