数据结构与算法（二十二）：排序算法

于 2021-04-22 11:04:30 发布
阅读量172 收藏
点赞数
分类专栏： 数据结构学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lelelewei/article/details/115939117
版权

数据结构与算法（二十二）：排序算法

定义

在这里插入图片描述

排序的稳定性

假设ki = kj，且在排序前的序列中ri领先于rj(i < j)
如果排序后仍然ri领先，那么称所用的排序方法是稳定的；反之，称为不稳定。

影响因素

时间性能，辅助空间，算法的复杂性。都影响排序的算法性能。

排序算法

在这里插入图片描述

冒泡排序

基本思想：两两相邻记录的关键字，如果反序则交换，直到没有反序的记录为止。

要点：

  • 两两相邻的元素
  • 如果有n个元素，比较n-1次，每一轮减少一次比较
  • 从下往上比较，像冒泡泡一样。

原始冒泡排序的算法，这并不符合两两相邻的比较

#include <stdio.h>
void BubbleSort(int k[], int n)
{
	int temp;
	for(int i = 0;i< n-1; i++)
	{
		for(int j = i+1; j< n-1 ;j++)
		{
			if(k[i]> k[j])
			{
				temp = k[j];
				k[j] = k[i];
				k[i] = temp;
			}
		}
	}
}

int main()
{
	int i ,a[10] = {5,2,6,0,3,9,1,7,4,8};
	BubbleSort(a,10);
	
	printf("排序后: \n");
	for(i = 0;i < 10; i++)
		printf("%d\t",a[i]);
	
	printf("\n");
}

正宗的冒泡排序算法

#include <stdio.h>
void BubbleSort(int k[], int n)
{
	int temp, count1 = 0, count2 = 0;
	for(int i=0;i< n-1; i++)
	{
		for(int j = n-1; j > i ;j--)
		{
			count1++;
			if(k[i]> k[j])
			{
				count2++;
				temp = k[j - 1];
				k[j- 1 ] = k[j];
				k[j] = temp;
			}
		}
	}
	printf("总共进行了%d次比较，进行了%d移动\n",count1，count2);
}

int main()
{
	int i ,a[10] = {5,2,6,0,3,9,1,7,4,8};
	BubbleSort(a,10);
	
	printf("排序后: \n");
	for(i = 0;i < 10; i++)
		printf("%d\t",a[i]);
	
	printf("\n");
}

选择排序

基本思想：通过n-i次关键字间的比较，从n-i+1个记录中选出关键字最小的记录，并和第i个记录交换。
（类似原始的冒泡排序，但是区别在于，这个判断完了再交换，而不是立刻更改数据）

#include <stdio.h>
void SelectSort(int k[], int n)
{
	int temp, min;
	for(int i = 0;i< n-1; i++)
	{
		for(int j = i+1; j< n-1 ;j++)
		{
			min = i;
			if(k[min]> k[j])
			{
				min = j;
			}
		}
		if(min != i)
		{
			temp = k[min];
			k[min] = k[i];
			k[i] = temp;
		}
	}
}

int main()
{
	int i ,a[10] = {5,2,6,0,3,9,1,7,4,8};
	SelectSort(a,10);
	
	printf("排序后: \n");
	for(i = 0;i < 10; i++)
		printf("%d\t",a[i]);
	
	printf("\n");
}

效率相对来说比冒泡高一点

直接插入排序算法

基本操作将一个记录插入到已经排好序的有序表中，从而得到一个新的，记录数增加1的有序表。

#include <stdio.h>
void InsertSort(int k[], int n)
{
	int temp, min;
	for(int i = 1;i< n; i++)
	{
		if(k[i] < k[i-1])
		{
			temp = k[i];
			for(int j = i-1; k[j] > temp ;j--)
			{
				k[j + 1] = k[j];
			}
		k[j + 1] = temp;
		}		
	}
}

int main()
{
	int i ,a[10] = {5,2,6,0,3,9,1,7,4,8};
	InsertSort(a,10);
	
	printf("排序后: \n");
	for(i = 0;i < 10; i++)
		printf("%d\t",a[i]);
	
	printf("\n");
}

希尔排序

第一次跨度为4，第二次跨度为2，第三次跨度为0.
在这里插入图片描述
实现代码

#include <stdio.h>
void XierSort(int k[], int n)
{
	int temp, min;
	int gap = n;
	do
	{
		gap = gap/3 + 1
		for(int i = gap;i< n; i++)
		{
			if(k[i] < k[i-gap])
			{
				temp = k[i];
				for(int j = i-gap; k[j] > temp ;j-=gap)
				{
					k[j + gap] = k[j];
				}
			k[j + gap] = temp;
			}		
		}
	}while(gap > 1);
}

int main()
{
	int i ,a[10] = {5,2,6,0,3,9,1,7,4,8};
	XierSort(a,10);
	
	printf("排序后: \n");
	for(i = 0;i < 10; i++)
		printf("%d\t",a[i]);
	
	printf("\n");
}

堆排序

之前讲过的排序算法，比较次数比较多，导致算法复杂度增加。
堆排序：对选择排序进行改进，复杂度O(Nlogn)，利于之前排序的结果。

大顶堆：每个节点都大于等于其左右孩子的节点。
小顶堆：每个节点都小于等于其左右孩子的节点。
在这里插入图片描述
要点：根结点一定是堆中结点最大或者最小的，如果按照层序遍历的方式进行编号，则结点之间满足如下关系
在这里插入图片描述
（左为大顶堆，右为小顶堆）下标i与2i和2i+1是双亲和子女关系
则存储结果如下
在这里插入图片描述
在这里插入图片描述
堆排序算法的基本思想：利用堆进行排序的算法

  • 将待排序的序列构造成一个大顶堆（小顶堆）
  • 此时，整个序列的最大值就是堆顶的根结点，将它移走（就是将其与堆数组的末尾元素交换，此时末尾元素就是最大值）
  • 然后将剩余的n-1个序列重新构造成一个堆，这样就会得到n个元素中的此大值。
  • 如此反复执行，得到一个有序序列
#include <stdio.h>
void HeapAdjust(int k[],int s, int n)
{
	int i, temp;
	temp = k[s];
	for(i = 2*s;i <=n;i *=2)
	{
		if(i< n && k[i] < k[i+1])
		{	
			i++;
		}
		if(temp >=k[i])
		{	
			break;
		}
		k[s] = k[i];
		s = i;
	}
	k[s] = temp;
}
void swap(int k[],int i, int j)
{
	int temp;
	temp = k[i];
	l[i] = k[j];
	k[j] = temp;
}
void HeapSort(int k[], int n)
{
	int i ;
	for(i = n/2; i> 0;i--)
	{
		HeapAdjust(k ,i , n);
	}
	for(i =n;i >1; i++)
	{
		swap(k, 1, i);
		HeapAdjust(k ,1 , i-1);
	}
}

int main()
{
	int i ,a[10] = {-1,5,2,6,0,3,9,1,7,4};
	HeapSort(a,9);
	
	printf("排序后: \n");
	for(i = 0;i < 10; i++)
		printf("%d\t",a[i]);
	
	printf("\n");
}

归并排序

归并排序：就是利用归并的思想实现的排序方法，原理是假设初始序列有n个记录，可以看成是n个有序的子序列，每个子序列的长度为1，然后两两归并，得到n/2（向上取整）个长度为2或1 的有序子序列，再两两归并，如此重复，直到得到一个长度为n的有序序列为止，这种排序方法称为2路归并排序。
在这里插入图片描述

递归实现

#include <stdio.h>
//实现归并，把结果存在list1里面
void merging(int *list1,int list1_size, int *list2, int list2_size)
{
	int temp[MAXSIZE];
	int i, j ,k, m;

	while(i < list1_size && j< list2_size)
	{
		if(list1[i]<list2[j])
		{
			temp[k++] = list1[i++];
		}
		else
		{
			temp[k++] = list2[j++];
		}
	}
	while(i < list1_size)
	{
		temp[k++] = list1[i++];
	}
	while(j < list2_size)
	{
		temp[k++] = list1[j++];
	}
	for( m=0; m< (list1_size + list2_size);m++)
	{
		list1[m] = temp[m];
	}
}
void MergeSort(int k[], int n)
{
	if(n >1)
	{
	int *list1 = k;
	int list1_size = n/2;
	int *list2 = k + n/2;
	int list1_size = n - list1_size;
	
	MergeSort(list1 , list1_size);
	MergeSort(list2 , list2_size);

	merging(list1,list1_size,list2,list2_size);
	}
	
}

int main()
{
	int i ,a[10] = {5,2,6,0,3,9,1,7,4,8};
	MergeSort(a,10);
	
	printf("排序后: \n");
	for(i = 0;i < 10; i++)
		printf("%d\t",a[i]);
	
	printf("\n");
}

迭代实现

#include <stdio.h>
#define MAXSIZE  10


void MergeSort(int k[], int n)
{
	int i ,left_min,left_max,right_min,right_max;
	int *temp = (int *)malloc (n * sizeof(int));
	
	for(i = 1;i<n; i *=2)
	{
		for( left_min = 0;left_min < n-i; letf_min = right_max)
		{
			right_min = left_max = left_min + i;
			right_max = left_max + i;
			
			if(right_max >n)
			{
				right_max = n;
			}
			next = 0
			while(left_min <left_max && right_min <right_max)
			{
				if(k[left_min] < k[right_min]
				{
					temp[next++] = k[left_min];
				}
				else
				{
					temp[next++] = k[right_min];
				}
			}
			while(left_min <left_max)
			{
				k[--right_min] = k[--left_min];
			}
			while(next >0)
			{
				k[--right_min] =temp[--next];
			}
		}
	}
}

int main()
{
	int i ,a[10] = {5,2,6,0,3,9,1,7,4,8};
	MergeSort(a,10);
	
	printf("排序后: \n");
	for(i = 0;i < 10; i++)
		printf("%d\t",a[i]);
	
	printf("\n");
}

快速排序算法

#include <stdio.h>
void swap(int k[],int low , int high)
{
	int temp;
	temp = k[low];
	k[low] = k[high];
	k[high] = temp;
}
int Partition(int k[],int low, int high)
{
	int point;
	point = k[low];
	while(low <high)
	{
		while(low <high && k[high] >= point)
		{
			high--;
		}
		swap(k ,low,high);
		while(low <high && k[low] <= point)
		{
			low++;
		}
		swap(k ,low,high);
	}
	return low;
}
void QSort(int k[], int low, int high)
{
	int point;
	if(low< high)
	{
		point = Partition(k,low,high); //计算基准点计算，一般选取第一个作为基准点
		QSort(k,low,point-1);
		QSort(k,point +1,high);
	}
}
void QuickSort(int k[], int n)
{
	QSort(k,0,n-1);
}

int main()
{
	int i ,a[10] = {5,2,6,0,3,9,1,7,4,8};
	QuickSort(a,10);
	
	printf("排序后: \n");
	for(i = 0;i < 10; i++)
		printf("%d\t",a[i]);
	
	printf("\n");
}

总结

在这里插入图片描述
在这里插入图片描述

lelelewei
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法：排序算法
Dreaming5498的博客
07-16 376
排序算法冒泡排序快速排序插入排序直接插入排序希尔排序选择排序选择排序：堆排序归并排序基数排序（桶排序）排序算法代码 冒泡排序 冒泡排序（Bubble Sort）一种交换排序，它的基本思想是：两两比较相邻记录的 关键字，如果反序则交换，直到没有反序的记录为止。这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端。 冒泡排序算法的运作如下: 比较相邻的元素。如果第一个比第二个大(升...
数据结构与算法（二）—— 算法
云卷云舒的架构师之路
05-20 439
一、算法定义 算法是解决特定问题求解步骤的描述，在计算机中表现为指令的有限序列，并且每条指令表示一个或多个操作。 二、算法的特性 1、输入输出 算法具有零个或多个输入，至少有一个或多个输出。输入可以是零个，但输出是一定要的。输出的形式可以是打印输出，也可以是返回一个或多个值等。 2、有穷性 是指算法在执行有限的步骤之后，自动结束而不会出现...
【数据结构】---七种排序方法详述
05-06 1596
排序：使数据按照某个或某些关键字的大小，递增（默认升序）或递减的排列起来的操作。 稳定性：假设在待排序的序列中，存在多个具有相同关键字的记录，若经过排序，这些记录相对次序保持不变 内部排序：数据元素全部放在内存中的排序 外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序 常见的排序算法： 直接插入排序 将待排序的记录按其关键码值的大小逐个插入到一个已经排好...
数据结构之排序算法（五）-直接插入排序，希尔排序，直接选择排序
tuke_tuke的博客
04-06 4795
直接插入排序：时间复杂度：O（n^2） 基本算法思路是：把后面待排序的记录按其关键字的大小逐个插入到一个已经排好序的有序序列中，直到所有记录插完为止，得到一个新的有序序列。（无序插入前面有序） 算法步骤：对数组a 1，设置监视哨a[i],将待插结果的值赋值给temp 2, 设置开始查找的位置j=i-1; 3，在数组j后面搜索，如果temp将第j个记录后移，直到temp>=a[j] 4,
冒泡排序和选择排序
热门推荐
Fearless的博客
04-18 1万+
两个比较简单的排序算法就放到一起写了1.冒泡排序1.1思想冒泡排序的思想是比较两两相邻的关键字，如果反序则进行交换，直到没有反序的为止。设想一个数组按照升序排列，经过第一轮比较之后最大的数就被放在最后了，因此剩下的比较中就不需要将它再参与进来，第二轮比较中第二大的数据被放在了倒数第二的位置，它的位置也就股定了，也不需要参与剩余的比较。因此我们需要两层循环，外层循环控制比较的轮数，和数组元素的个数有...
bubbleSort (冒泡排序)
darkbus111的专栏
12-12 390
bubbleSort (冒泡排序)   void BubbleSort(int *a, int len)  {   int dwCount,i,j,temp;   for (dwCount=0;dwCount  {    for (i=len-1;i>dwCount;i--)//不断比较和交换相邻的两个数    {     if (a[i]    {
经典算法之直接插入排序（三种实现）
进击的程序猿
06-03 4769
直接插入排序(Insertion Sort)的基本思想是：每次将一个待排序的记录，按其关键字大小插入到前面已经排好序的子序列中的适当位置，直到全部记录插入完成为止。设数组为a[0…n-1]。 1. 初始时，a[0]自成1个有序区，无序区为a[1..n-1]。令i=1 2. 将a[i]并入当前的有序区a[0…i-1]中形成a[0…i]的有序区间。 3. i++并重复
恋上数据结构与算法第二季课件pdf
10-29
在"恋上数据结构与算法第二季"的课程中，我们深入探讨了这个领域的核心概念。本课程旨在通过丰富的实例和详细的解释，帮助学习者掌握这些关键知识，并提升编程能力。 首先，排序算法是任何程序员都需要熟悉的工具。...
C++ 数据结构与算法 排序算法
08-17
本文件将四大排序算法通过“「程序算法之排序」冒泡排序、插入排序、选择排序与快速排序”一文编写出,欢迎下载学习(文章链接:https://blog.csdn.net/Pomelo_ABC/article/details/126015013)
数据结构与算法复习（Java）：排序、字符串、数组、链表、二分查找、二叉树.zip
01-15
算法分类：排序算法（如冒泡排序、快速排序、归并排序），查找算法（如顺序查找、二分查找、哈希查找），图论算法（如Dijkstra最短路径算法、Floyd-Warshall算法、Prim最小生成树算法），动态规划，贪心算法，回溯法...
冒泡排序（c语言）
qq_25366423的博客
09-20 164
#include <stdio.h> void bubbleSort(int arr[], int n); void smallBubbleSort(int arr[], int n); int main() { int arr[] = {49, 38, 65, 97, 76, 13, 27, 49}; bubbleSort(arr, 8); for (int i = 0; i < 8; ++i) { printf("%d ", arr[i])...
数据结构十大经典排序算法总结
猫敷雪
08-12 3861
算法概述 算法分类 十种常见排序算法可以分为两大类： 比较类排序：通过比较来决定元素间的相对次数，由于其时间复杂度不能突破O(nlog⁡n)O(n \log n)O(nlogn)，因此也称为非线性时间比较类排序。 非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。 算法复杂度 在面试中面试官一般会重点查考时间复杂度为O(n*logn)的排序算法，比如快速排序、归并排序和堆排序，这就需要我们掌握其原理和手撕算法。 相关概念
C++实现常用排序算法（快速排序、选择排序、直接插入排序）
li123_123_的博客
11-09 481
对数组进行排序 Given an array of integers nums, sort the array in ascending order. Example 1: Input: nums = [5,2,3,1] Output: [1,2,3,5] Example 2: Input: nums = [5,1,1,2,0,0] Output: [0,0,1,1,2,5] 在leetco...
数据结构之排序(六)——各种排序方法的比较
daocaoren_的博客
08-15 1842
时间性能 按平均时间性能来分，有三类排序方法： 时间复杂度为O(nlogn)O(nlogn)O(nlogn)方法有： 快速排序、堆排序和归并排序，其中以快速排序为最好； 时间复杂度为O(n2)O(n^2)O(n2)方法有： 直接插入排序 、冒泡排序和简单选择排序，其中以直接插入为最好，特别是对那些关键字近似有序的记录序列尤为如此； 时间复杂度为O(n)O(n)O(n)方法有：基数...
快速排序 冒泡排序 希尔排序 归并排序 选择排序 插入排序 详解
weixin_46663642的博客
08-14 438
选择排序 时间复杂度O(n^2) 空间复杂度O(1) /** 选择排序算法就是通过n-i次关键字的比较，从n-i+1个记录中选出关键字最小的 记录，并和第i(1<=i<=n)个记录交换 **/ #include<stdio.h> void SelectSort(int k[],int n) { int i,j,min,temp,count1=0,count2=0; for(i=0;i<n;i++) { min=i; for(j=i+1;j<n;j
数据结构排序部分
weixin_43489294的博客
09-22 558
1．改进的算法里，只有归并算法稳定。 2 . 从待排序的记录个数n的大小来看n越小，采用简单排序n越大，采用改进的排序方法 （n越小，O()和O()的差距越小，输入和调试简单算法比改进算法要少用许多时间） 3.几种排序方式 ： 4. 对任意n个关键字排序的比较次数至少为­┌┐ 基于比较的排序方法中，每次比较两个关键字后，尽可能出现两种可能的转移情况。假设整个排序过程至少需要做t次比较，则显然会有2t种情况，由于n个记录共有n!种不同的排列，因而必须有n!种不同的比较路径，...
光纤振动传感器的研究.doc
最新发布
07-16
传感器
光纤位移传感器实验.doc
07-16
传感器
算法与数据结构课件PPT第八章
07-16
总结来说，第八章内容涵盖了排序算法的核心原理和实践应用，从直观易懂的直接插入排序到高效的二分插入排序，这些知识对于理解数据结构和算法设计至关重要。掌握排序技巧不仅可以提升程序性能，也是其他高级算法和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值