考研数据结构(八):八大排序算法实现(建议收藏)

最新推荐文章于 2023-08-23 22:11:51 发布
最新推荐文章于 2023-08-23 22:11:51 发布
阅读量477 收藏 19
点赞数
分类专栏： 数据结构 文章标签： 数据结构 算法 八大排序算法 快速排序 冒泡选择排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43619271/article/details/120855739
版权

八大排序算法

1.插入排序

(1).直接插入排序

#include <stdio.h>
#include <stdlib.h> 

// 直接插入排序

// (哨兵版本)
void insertSort1(int a[],int n) {
	// a[0] 是哨兵 
	for(int i = 2; i <= n; i ++) {
		a[0] = a[i];
		int j;
		// 找寻要插入的位置,发挥哨兵的作用 
		for(j = i - 1; a[j] > a[0]; j --) {
				a[j + 1] = a[j];
		}
		a[j + 1] = a[0];
	} 
	return ;
}

// (非哨兵版本) 
void insertSort2(int a[],int n) {
	for(int i = 2; i <= n; i ++) {
		a[0] = a[i];
		int j;
		// 寻找合适的插入位置并且移动相应的元素 
		for(j = i - 1; j >= 1; j --) {
			if(a[j] > a[0]) {
				a[j + 1] = a[j];
			} else {
				break;
			}
		} 
		a[j + 1] = a[0];
	} 
	return ;
}

int main() {
	int a[12];
	
	printf("请输入要排序的序列:\n"); 
	
	for(int i = 1; i <= 10; i ++) {
		scanf("%d",&a[i]);
	}
	
	insertSort1(a,10);
	
	printf("直接插入排序 排序后的序列:\n");
	for(int i = 1; i <= 10; i ++) {
		printf("%d ",a[i]);
	}
	
	return 0;
}

(2).折半插入排序

#include <stdio.h>
#include <stdlib.h> 

// 折半插入排序

void middleInsertSort(int a[],int n) {
	// a[0] 是哨兵 
	for(int i = 2; i <= n; i ++) {
		a[0] = a[i];
		// 折半查找合适的插入位置 
		int low = 1,high = i - 1;
		while(low <= high) {
			int mid = low + high >> 1;
			if(a[mid] > a[0]) high = mid - 1;
			else low = mid + 1;
		}
		// 后移 
		for(int j = i - 1; j >= low; j --) {
			a[j + 1] = a[j];
		}
		// 赋值 
		a[low] = a[0];
	}
	return ;
}

int main() {
	int a[12];
	
	printf("请输入要排序的序列:\n"); 
	
	for(int i = 1; i <= 10; i ++) {
		scanf("%d",&a[i]);
	}
	
	middleInsertSort(a,10);
	
	printf("折半插入排序 排序后的序列:\n");
	for(int i = 1; i <= 10; i ++) {
		printf("%d ",a[i]);
	}
	
	return 0;
}

(3).希尔排序

#include <stdio.h>
#include <stdlib.h> 

// 希尔排序

void shellSort(int a[],int n) {
	// a[0] 是哨兵 
	
	// 确定增量 
	for(int d = n / 2; d >= 1; d /= 2) {
		// 分子表
		for(int i = 1; i < d + 1; i ++) {
			// 对每个子表进行排序
			for(int j = i + d; j <= n; j ++) {
				a[0] = a[j];
				int k;
				for(k = j - d; k > 0 && a[k] < a[0]; k -= d) {
					a[k + d] = a[k];
				} 
				a[k + d] = a[0];
			} 
		} 
	} 
	
	return ;
}

int main() {
	int a[12];
	
	printf("请输入要排序的序列:\n"); 
	
	for(int i = 1; i <= 10; i ++) {
		scanf("%d",&a[i]);
	}
	
	shellSort(a,10);
	
	printf("希尔排序 排序后的序列:\n");
	for(int i = 1; i <= 10; i ++) {
		printf("%d ",a[i]);
	}
	
	return 0;
}

2.交换排序

(1).冒泡排序

#include <stdio.h>
#include <stdlib.h> 

// 冒泡排序One:元素下标从 1 开始,从后往前冒泡 
void bubbleSortOne(int a[],int n) {
	for(int i = 1; i < n; i ++) {
		for(int j = n; j > i; j --) {
			if(a[j] > a[j - 1]) {
				int temp = a[j];
				a[j] = a[j - 1];
				a[j - 1] = temp;
			}
		}
	}
	return ;
}

// 冒泡排序Two:元素下标从 1 开始,从前往后冒泡 
void bubbleSortTwo(int a[],int n) {
	for(int i = n; i > 1; i --) {
		for(int j = 1; j < i; j ++) {
			if(a[j] > a[j + 1]) {
				int temp = a[j];
				a[j] = a[j + 1];
				a[j + 1] = temp;
			}
		}
	}
	return ;
}

int main() {
	int a[12];
	
	printf("请输入要排序的序列:\n"); 
	
	for(int i = 1; i <= 10; i ++) {
		scanf("%d",&a[i]);
	}
	
	bubbleSortTwo(a,10);
	
	printf("冒泡排序(元素下标从 1 开始,从前往后冒泡) 排序后的序列:\n");
	for(int i = 1; i <= 10; i ++) {
		printf("%d ",a[i]);
	}
	
	return 0;
}

(2).快速排序

#include <stdio.h>
#include <stdlib.h> 

int partition(int a[],int low,int high) {
	// 每次选取第一个位置作为中间枢纽 
	int pivot = a[low];
	while(low < high) {
		// 从末尾开始寻找 
		while(low < high && a[high] >= pivot) high --;
		a[low] = a[high];
		// 从头部开始寻找 
		while(low < high && a[low] <= pivot) low ++;
		a[high] = a[low];
	}
	a[low] = pivot;
	return low;
}



void quickSort(int a[],int low,int high) {
	if(low < high) {
		int pos = partition(a,low,high);
		quickSort(a,low,pos - 1);
		quickSort(a,pos + 1,high);
	}
	return ;
}

int main() {
	int a[12];
	
	printf("请输入要排序的序列:\n"); 
	
	for(int i = 1; i <= 10; i ++) {
		scanf("%d",&a[i]);
	}
	
	quickSort(a,1,10);
	
	printf("快速排序 排序后的序列:\n");
	for(int i = 1; i <= 10; i ++) {
		printf("%d ",a[i]);
	}
	
	return 0;
}

3.选择排序

(1).简单选择排序

#include <stdio.h>
#include <stdlib.h> 

// 简单选择排序 
void selectSort(int a[],int n) { 
	for(int i = 1; i <= n; i ++) {
		int pos = i,value = a[i];
		for(int j = i + 1; j <= n; j ++) {
			if(a[j] < value) {
				value = a[j];
				pos = j;
			}
		}
		// 每次从未排序的序列中选取一个最小的量与当前位置进行交换 
		int temp = a[pos];
		a[pos] = a[i];
		a[i] = temp;
	}
	
	return ;
}

int main() {
	int a[12];
	
	printf("请输入要排序的序列:\n"); 
	
	for(int i = 1; i <= 10; i ++) {
		scanf("%d",&a[i]);
	}
	
	selectSort(a,10);
	
	printf("简单选择排序 排序后的序列:\n");
	for(int i = 1; i <= 10; i ++) {
		printf("%d ",a[i]);
	}
	
	return 0;
}

(2).堆排序

#include <stdio.h>
#include <stdlib.h>

/*
	堆 : 一颗完全二叉树
	大根堆 : 所有 父节点的内容 > 子节点的内容
	小根堆 : 所有 父节点的内容 < 子节点的内容  

*/

/*
	heapify : 找到 父节点, 左子节点,右子节点 三者的最大值
			  与父节点进行交换 
	不断 heapify ,就可构造一个 堆 
*/ 

/*
	堆编号的特点 : 假设 顶根堆的编号是 0,可以用一个一维数组表示这个堆
		parent = (i - 1) / 2;(向下取整)
		c1 = 2i + 1;
		c2 = 2i + 2; 
*/ 

void swap(int arr[],int i,int j) {
	int temp = arr[i];
	arr[i] = arr[j];
	arr[j] = temp;
	return ;
}

// 从某个父节点开始做 heapify 操作 
void heapify(int tree[],int n,int i) {
	// 递归出口函数 
	if(i >= n) return ; 
	// i 表示 父节点编号 
	int c1 = 2 * i + 1;
	int c2 = 2 * i + 2;
	int max = i;
	
	// 除了要保证保证最大值外还要保证 c1 和 c2 不会出界 
	if(c1 < n && tree[c1] > tree[max]) {
		max = c1;
	} 
	if(c2 < n && tree[c2] > tree[max]) {
		max = c2;
	}
	
	if(max != i) {
		swap(tree,i,max);
		// 继续做一次 heapify 
		heapify(tree,n,max);
	} 
	
	return ;
} 

void build_heap(int tree[],int n) {
	int last_node = n - 1;
	// 从最后一个节点的根节点编号开始进行heapify操作 
	int parent = (last_node - 1) / 2;
	int i;
	for(int i = parent;i >= 0; i --) {
		heapify(tree,n,i);
	}
	return ;
} 


// 每次将当前根节点与最后一个节点进行交换,之后再对根节点进行 heapify 操作 
void heap_sort(int tree[],int n) {
	build_heap(tree,n);
	int i;
	// 从最后一个节点出发 
	for(int i = n - 1; i >= 0; i --) {
		swap(tree,i,0);
		// 根节点与最后一个节点交换后再进行 heapify 操作 
		heapify(tree,i,0);
	}
	return ;
} 

int main() {
	
	int tree[] = {2,5,90,1,10,4};
	int n = 6;
	// 给与任意一个序列,构建一个堆 
//	build_heap(tree,n);
	heap_sort(tree,n); 
	
	for(int i = 0; i < n; i ++) {
		printf("%d ",tree[i]);
	}
	
	return 0;
}

4.归并排序

#include <stdio.h>
#include <stdlib.h> 

void merge(int a[],int low,int mid,int high) {
	// 开辟一个临时辅助数组 
	int b[12]; 
	for(int i = low; i <= high; i ++) {
		b[i] = a[i];
	}
	
	int i = low,j = mid + 1,k = low;
	while(i <= mid && j <= high) {
		if(b[i] > b[j]) {
			a[k ++] = b[j ++];
		} else {
			a[k ++] = b[i ++];
		}
	}
	
	while(i <= mid) a[k ++] = b[i ++];
	while(j <= high) a[k ++] = b[j ++];
	
	
	return ; 
}

// 归并排序 
void mergeSort(int a[],int low,int high) { 
	if(low < high) {
		int mid = low + high >> 1;
		// 递归操作 
		mergeSort(a,low,mid);
		mergeSort(a,mid + 1,high);
		merge(a,low,mid,high);
	}
	return ;
}

int main() {
	int a[12];
	
	printf("请输入要排序的序列:\n"); 
	
	for(int i = 1; i <= 10; i ++) {
		scanf("%d",&a[i]);
	}
	
	mergeSort(a,1,10);
	
	printf("归并排序 排序后的序列:\n");
	for(int i = 1; i <= 10; i ++) {
		printf("%d ",a[i]);
	}
	
	return 0;
}
潘小蓝
关注
  • 0
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
2014河北工业大学数据结构考研真题
11-08
从给定的文件信息中，我们可以看到，这是一份2014年的河北工业大学计算机科学与技术考研数据结构真题。为帮助考生更好地理解和掌握数据结构的知识，我们将对该试题进行详细的解析和总结。 一、填空题 1. 称算法的...
数据结构考研资料大汇总 全集 考研必备
09-06
│ 考研数据结构，各种算法的经解分析.doc │ 考研用算法.doc │ 计算机数据结构考研讲义.pdf │ 计算机考研大纲.doc │ 资料列表.bat │ ├─数据结构-考研复习题 │ │ 第10章 排序.doc │ │ 第11章 文件...
考研数据结构——(排序)
Seven597的博客
07-17 615
第一趟（d增量设为4；⭐即n(元素个数)/2）⭐排序前（划分成多个子表，按增量d划分，例如1+d，1+2d，1+3d为一个子表）⭐排序后（就是子表内进行直接插入排序）第二趟（d=4/2=2）⭐排序前⭐排序后第三趟（d=4/2/2=1）⭐排序前⭐排序后⭐总览🌙具体步骤本次示例为中间部分，快排的思想是选中一个元素,将其他元素与该元素进行比较，小的在该元素左侧，大的在该元素右侧；建辅助队列数组。...
考研数据结构——排序
纸城的博客
05-04 606
人生哪有最好，把每一个当下做到最好，就很不错了呀。 以下是干货，以考试主要考查的重点内容为主体，讲述过程以方便大家记忆为上，并不面面俱到。 首先得知道排序分内部排序和外部排序。 内部排序：排序整个过程中数据在内存中。 外部排序：排序整个过程中数据会有出现在内、外存之间调动的情况。 考研主要考内部排序。 内部主要排序分三大类（这里是大的类别名不是排序算法的名字）：插入排序、交换...
数据结构中的八大排序算法
azi8860的博客
08-29 100
一、冒泡排序 思想：重复走访过要排序的序列，一次比较两个元素，如果他们的顺序错误就将他们进行交换，一次冒上来的是最小的，其次是第二小。 时间复杂度：O(n^2) 空间复杂度:O(1) 稳定性：稳定 　　 /** * 冒泡排序 * @param disOrderArray * @return */ public s...
（考研系列）常见排序算法一览
Charles_ke的博客
07-22 2565
0、算法概述 0.1 算法分类 十种常见排序算法可以分为两大类： 非线性时间比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此称为非线性时间比较类排序。 线性时间非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此称为线性时间非比较类排序。  0.2 算法复杂度 0.3 相关概念 ...
考研-排序算法
忘眠的博客
05-31 260
文章目录六、排序大纲分类及稳定性分析代码【模板】快速排序题目描述输入格式输出格式样例 #1样例输入 #1样例输出 #1提示 六、排序 大纲 六、排序 　　(一)排序的基本概念 (二)插入排序 　　1.直接插入排序 　　2.折半插入排序 (三)气泡排序(bubble sort) (四)简单选择排序 (五)希尔排序(shell sort) 　　(六)快速排序 (七)堆排序 　　(八)二路归并排序(merge sort) (九)基数排序 　　(十)外部排序 (十一)排序算法的分析与应用 分类及稳定性分析 根据是
考研数据结构
12-02
考研数据结构知识点总结 一、时间复杂度 * 时间复杂度是衡量算法性能的重要指标，通常用大O符号表示。 * 时间复杂度的计算方法：对于一个算法，如果其执行时间随着问题规模n的增加而增加，并且增加的速度可以用一...
数据结构复习总结心得最终版.pdf
12-28
本复习总结涵盖了数据结构的基础知识，主要针对研究生考研复习，特别是408计算机考研大纲的要求。 首先，第一章绪论讨论了不同类型的存储结构。顺序存储是最简单的形式，元素在内存中连续存放，便于随机访问，但...
数据结构串讲笔记.docx
02-27
本文将从数据结构的概念、逻辑结构、存储结构、顺序存储、链表算法、栈、队列、树、二叉树遍历、哈夫曼树、图论、最小生成树、最短路径、拓扑序列、关键路径、二分查找、哈希表、排序算法等方面进行总结。...
考研数据结构--排序汇总（自用）
qq_40691051的博客
11-19 762
1、插入排序: 1)直接插入排序: 哨兵版: void insertSort(int A[], int n) { int i, j; for(i = 2; i <= n; i++) { A[0] = A[i]; //负责为哨兵，A[0]不存放元素 for(j = i - 1; A[0] < A[j]; j--) A[j+1] = A[j]; A[j+1] = A[0]; } } 普通版: void insertSort2(int A[], int n
数据结构考研 - 排序（C语言）
SonnyLe
07-25 675
1. 插入类排序 1.1 直接插入排序 void InsertSort(int R[ ], int n) { int i, j; int temp; for (i=1;i&amp;amp;lt;n;++i) { temp=R[i]; //将待插入关键字暂存于temp中 j=i-1; /* 下面这个循环完成了从待排关键词之前的关键词开始扫描*/ ...
考研数据结构：第八章 排序
m0_57180439的博客
08-23 467
本文详细介绍了数据结构中的插入排序、冒泡排序、堆排序、选择排序、归并排序，相信对你的学习一定有所帮助
【数据结构】最全排序汇总 | 考研
LumosJ
02-03 1643
本文主要内容 1. 排序及其相关概念的介绍 2. 常见排序及其算法实现 3. 排序算法复杂度及稳定性分析 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 目录本文主要内容前言一、排序及其相关概念的介绍二、常见排序及其算法实现1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 一、排序及其相关概念的介绍 排序：使一串记录，按照其中的某个或
考研数据结构之排序小结
qq_41562704的博客
10-06 1070
排序的问题比较杂，想通过这篇博客理顺一下，基础的概念这里不累述。 总体的知识框架如下： 1、关于适用场景： ①直接插入排序适用于排序表和数据量不大的排序表； ②取一大堆数据中K个最大（小）的元素，优先选用堆排序； ③大规模排序，希尔排序均能达到较好的效果; ④快速排序的平均性能达到O(nl...
排序算法【考研/408】
imomoe的博客
08-28 1938
【知识框架】 排序的稳定性： 就是如果排序前 2个变量A\B的值都是1，且他们是A B这样排的，排序完后他们变成B A这样排了，就说明这个排序算法不稳定（算法优劣与稳定性无关 内部排序：排序时，元素全部放在内存中排序 外部排序：排序时，元素在内外存间移动 插入排序 直接插入排序 第一个直接不选，从第二个开始，把第二个数值给哨兵，然后开始从第二个向前比较 折半插入排序 假设现在移动55，先用折半查找对55前面搜一下55要插到哪（因为前面都...
考研学习之数据结构排序算法学习
过客璇璇的博客
10-18 275
一.直接插入排序 1.1代码 #include <stdio.h> /** 直接插入排序 */ void insertSort(int A[],int n){ int i,j; //依次将A[2]~A[n] 插入到前面已排序的序列中 for(i=2;i<=n;i++){ //若 A[i]关键码小于前去，将A[i]插入有序表 if(A[i]<A[i-1]){ A[0] = A[i];//复制哨兵，A[0]不存放元素 //从后往前寻找待插入的位
数据结构第八章——排序,考研必备
haust_允谦的博客
11-21 614
数据结构第八章——排序 什么是排序？ 排序：将一组杂乱无章的数据按一定规律顺序依次排列起来 存储结构——记录序列以顺序表存储 #define MAXSIZE 20//设记录不超过20个 typedef int KeyType;//设关键字为整型量（int） typedef struct{ KeyType key;//关键字 InfoType otherinfo;//其他数据项 }RedType; typedef struct{ RedType r[MAXSIZE + 1];//存储顺序表的向量 in
数据结构—八大排序算法
weixin_44864840的博客
07-22 298
排序分为内部排序和外部排序。 内部排序就是在内存中排序，如果数据很大，不能全部读入内存，就需要访问外村，称为外部排序。 - — -1.冒泡排序- — - 基本思想： 两两比较相邻记录的关键字，如果反序则交换，直到没有反序的记录为止。这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端。 时间复杂度O(n²) 空间复杂度O(1) def sort(arry): n=len(...
考研数据结构经典算法
最新发布
09-11
数据结构和算法是考研计算机科学与技术专业的重要内容之一，以下是一些经典的数据结构和算法，供你参考： 数据结构： 1. 数组 (Array) 2. 链表 (Linked List) 3. 栈 (Stack) 4. 队列 (Queue) 5. 树 (Tree) 6. 图 (Graph) 7. 哈希表 (Hash Table) 经典算法： 1. 排序算法：如冒泡排序、选择排序、插入排序、归并排序、快速排序等。 2. 查找算法：如顺序查找、二分查找、哈希查找等。 3. 图算法：如深度优先搜索 (DFS)、广度优先搜索 (BFS)、最短路径算法 (Dijkstra、Floyd-Warshall)、最小生成树算法 (Prim、Kruskal)等。 4. 字符串匹配算法：如暴力匹配、KMP算法、Boyer-Moore算法等。 5. 贪心算法 (Greedy Algorithm) 6. 动态规划 (Dynamic Programming) 这些都是经典的数据结构和算法，掌握它们对于考研复习是非常重要的。建议你深入学习每个数据结构和算法的原理、特点和应用场景，并进行实践和练习，加强对其的理解和掌握。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

潘小蓝

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值