数据结构——排序

已于 2024-07-16 10:17:05 修改
阅读量3.1k 收藏 6
点赞数 61
分类专栏： 数据结构与算法基础 文章标签： 数据结构 排序 插入排序 希尔排序 快速排序 选择排序 堆排序
于 2024-07-15 22:06:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79431343/article/details/137049637
版权

目录

1.排序概述

1.排序的概念

2.排序方法的分类 

3.稳定排序与不稳定排序 

4.存储结构

 代码示例：

2.插入排序 

1.直接插入排序 

代码示例：

性能分析 

2.折半插入排序 

代码示例 ：

算法分析 

3.希尔排序 

代码示例：

算法分析 

3.交换排序

1.冒泡排序

冒泡排序原理

代码示例：

 冒泡排序的改进

代码示例：

算法分析 

2.快速排序 

快排的原理

代码示例： 

算法分析 

4.选择排序

1.简单选择排序 

排序原理 

代码示例：

 算法分析

2.堆排序

排序原理 

筛选过程代码示例：

堆排序算法代码示例：

算法性能分析 

5.归并排序 

算法分析 

6.基数排序 

算法分析 

7.各种排序方法的综合比较 

26ff58e595104fbcaab4eaf643596515.png

1.排序概述

1.排序的概念

0a6a3556eb02458486e434c456b934fc.png

cb3115366de04dc49a7e396e1c3ba666.png

2.排序方法的分类 

a6881d6ca1b840bb9f3395d64fd245bd.png

fa0adcd4f86c44b19ab4f37d644cd264.png

5ee36d7ac0b6414fb91bca612776a1db.png

b650c0e31a1c47d08d0688cfd5c0caa4.png

65d44a22a9fb42a2aa121adffaef4afb.png

7f5584ddfd85465d8b3a9e3e4c7929d1.png

3.稳定排序与不稳定排序 

ee6641ab5c08400fb8fa2ddbbba60560.png

a146d954a5ed48dbb7c36f4d7d372d81.png

962e85dbf3b64659ab1d7a3b72ccc5ea.png

25aecb9fa17a4ec09e75298b2fa4c887.png

0b0cbf28e2e146f2b7d2b210d2a33b6b.png

4.存储结构

87702e60ad92475b91ce717ad83a4d15.png

 代码示例：

#define maxsize 20

typedef struct {
	int key;
}redtype;

typedef struct {
	redtype r[maxsize + 1];
	int len;
}sqlist;

2.插入排序 

185e2bd5e47245fe84b837c69310fc0f.png

886189863edb4ac5981998fc9a237a37.png

acbd52a332b34151bab04fd6f8d029e2.png

4ad635fdee0d48119bd07d95c5fe104c.png

485c656a64f44989b26eb8474acf1073.png

1.直接插入排序 

026d9356387741c283c087e264686603.png

590d28450f4b470a9ee92d438988cf90.png

92f6499fffa34a41899aebe4e89f1130.png

代码示例：

void insertsort(sqlist &l) {
	int i,j;
	for(i = 2; i <= l.len; ++i) {
		if(l.r[i].key < l.r[i - 1].key){
			l.r[0] = l.r[i];
			for(j = i - 1; l.r[0].key < l.r[j].key; --j) {
				l.r[j + 1] = l.r[0];
			}
		}	
	}
}

性能分析 

96cbc0b7d82e45b09b58cfdf6f6c8053.png

d1841ddc54e04579ab2c4ef870b769d6.png

6ab1476b89b848ea9f6102007d5993cf.png

94fc5e9c762d4327a35cb18e6e337f31.png

7d586466a7f0400fade3c0972a4531cf.png

8f94a2b70a784c90897c9b13bf8af2ea.png

2.折半插入排序 

60a44f8b432641a08a504e4c97095465.png

1d4f797c516544daa177df54d6ca82f8.png

代码示例 ：

void binsertsort(sqlist &l) {
	for(int i = 2; i <= l.len; ++i) {
		l.r[0] = l.r[i];
		int low = 1;
		int high = i - 1;
		while(low <= high) {
			int mid = (low + high) / 2;
			if(l.r[0].key < l.r[mid].key)
				high = mid - 1;
			else low = mid + 1;
		}
		for(int j = i - 1; j >= high + 1; --j) {
			l.r[high + 1] = l.r[0];
		}
	}
}

算法分析 

9dafa52ec13349258d754bc1c4d838fc.png

759d793985924404aafe002be5ec14b9.png

5e4c7214a4da4916963937636a73cba6.png

3.希尔排序 

dcb7818d1c564c67b15f1a73db929f00.png

d636af1f62e941a1b9ac2e8f41293d0d.png

56c67546d1254989b3fe25120b65c212.png

1261cc5c62a048b19058e5ada6d30bd4.png

307b0088cf4947f186c4fc1851643235.png

77b4cf3d0f914bf5bdd666f70c47aec0.png

9448b5ecc4114ee1bd0e541a05a503bf.png

代码示例：
void shellinsert(sqlist &l, int dk) {
	int i,j;
	for(i = dk + 1; i <= l.len; ++i) {
		if(l.r[i].key < l.r[i - dk].key) {
			l.r[0] = l.r[i];
			for(j = i - dk; j > 0 && (l.r[0].key < l.r[j].key); j = j - dk) {
				l.r[j + dk] = l.r[i];
			}
			l.r[j + dk] = l.r[0];
		}
	}
}

void shellsort(sqlist &l, int dlta[], int t) {
	for(int k = 0; k < t; ++k) {
		shellinsert(l, dlta[k]);
	}
}

算法分析 

1f9d55942fd742a6a56a55de037eaf49.png

734936cd4aa74b2ab1850bd6654c1827.png

f32a477a9f774ace8218924c6e479408.png

96f2edf6f24543e9b3ce75009e42a248.png

4329ebbfead94215bee17a8f26e460c3.png

3.交换排序

1.冒泡排序

冒泡排序原理

代码示例：
void bubblesort(sqlist &l) {
	int m,n,j;
	redtype x;
	for(m = 1; m <= n - 1; m++) {
		for(j = 1; j <= n - m; j++) {
			if(l.r[j].key > l.r[j + 1].key) {
				x = l.r[j];
				l.r[j] = l.r[j + 1];
				l.r[j + 1] = x;
			}
		}
	}
}

 冒泡排序的改进

 

代码示例：
void bubblesort2(sqlist &l) {
	int m,n,j;
	int flag = 1;
	redtype x;
	for(m = 1; m <= n - 1 && flag == 1; m++) {
		flag = 0;
		for(j = 1; j <= n - m; j++) {
			if(l.r[j].key > l.r[j + 1].key) {
				flag = 1;
				x = l.r[j];
				l.r[j] = l.r[j + 1];
				l.r[j + 1] = x;
			}
		}
	}
}

算法分析 

 

 

2.快速排序 

快排的原理

 

 

代码示例： 

int partition(sqlist &l,int low,int high) {
	l.r[0] = l.r[low];
	int pivotkey = l.r[low].key;
	while(low < high) {
		while(low < high && l.r[high].key >= pivotkey)
			--high;
		l.r[low] = l.r[high];
		while(low < high && l.r[low].key <= pivotkey)
			++low;
		l.r[high] = l.r[low];
	}
	l.r[low] = l.r[0];
	return low;
}

void qsort(sqlist &l,int low,int high) {
	if(low < high) {
		int pivotloc = partition(l,low,high);
		qsort(l,low,pivotloc - 1);
		qsort(l,pivotloc + 1,high);
	}
}

int main() {
	sqlist l;
	qsort(l,1,l.len);
	return 0;
}

算法分析 

90c1873c8a7c4acf8c7e92bc24cd09c3.png

8b8b3bd8a65e47d599c656b676dfc9c5.png

13cf3db8266d452d8140b1093ee51aed.png

4d09cdfb78a24bef9906a3a0cf22d8c3.png

6672b065f38d46b7a3aeb2fe85a1af9f.png

4.选择排序

1.简单选择排序 

排序原理 

7ba48362b46348c7890e15fe00456fe6.png

cbfd538c1d424461a08884bc092b50b6.png

0a5689374db142e491463c54bcf6b6f2.png

803a489875b949ff9df6fb42a12691a4.png

代码示例：
void selectsort(sqlist &l) {
	int i,j,k;
	for(i = 1; i < l.len; ++i) {
		k = i;
		for(j = i + 1; j < l.len; j++) {
			if(l.r[j].key < l.r[k].key)
				k = j;
			if(k != i) {
				redtype temp = l.r[i];
				l.r[i] = l.r[k];
				l.r[k] = temp;
			}
		}
	}
}

 算法分析

d1ed3099b96344bcb7a87c4308efbb0e.png

3c12b5644003436db641e2eb62d4028e.png

2.堆排序

排序原理 

743e14a7042944a68c54a674cfbe0a75.png

b90aa4e6086d452a840cb13d20e3c081.png

7ac4fbd2abb04673a6411daab7812a24.png

4090139f3f6f4a05a57f86945cfea359.png

7636fc3a951647e5871c24c19136b187.png

87fe8f340a434f6095e4f7858a22b99a.png

b7271ab8660b4ebeae4abe6e1560d80b.png

b800769bcefe4631819b8b9572efe1d8.png

bcc48c95db58476b8e0534983cebff19.png

筛选过程代码示例：

void heapadjust(int r[],int s,int m) {
	int rc = r[s];
	for(int j = s * 2; j <= m; j *= 2) {
		if(j < m && r[j] < r[j + 1])
			++j;
		if(rc > r[j])
			break;
		r[s] = r[j];
		s = j;
	}
	r[s] = rc;
}

636b240aa16d4391a5ecfa01cc43d698.png

70207128f9c8458bb1f778dd3ff69836.png

e5ad7bfca8314bd8a98f13b0564aadbe.png

780d3265a92041e9934feed54781d648.png

 42a2e1cd52ce4bd9ac7337f71edf79fb.png

54c12bc7420e475195892a6f59470ae0.png

671b234b104d4970bc514beb03f1e839.png

7fd907d1fbe54490be3c9e2a4f1532fd.png

堆排序算法代码示例：

void heapsort(int r[]) {
	int i;
	int n = sizeof(r)/sizeof(r[0]);
	for(i = n / 2; i >= 1; i--) {
		heapadjust(r,i,n);
	}
	for(i = n; i > 1; i--) {
		swap(r[1],r[i]);
		heapadjust(r,1,i - 1);
	}
}

算法性能分析 

33e63f5337f848e9a46d35f5458eb66d.png

cf4b9b8572164bac940a23b4b4ca39ac.png

5.归并排序 

7660e760839e45ac80bd140be067aa07.png

0dece99e617d4376b7ef6247febeda84.png

bbbf91830c254d7d93ed95a47470c152.png

b4ece3626bc245a2b9e69dbce4f0e323.png

c30640a959c349dda45e30eff2cbe2e0.png

算法分析 

f6332296b9d64ce4866397264638221b.png

1dd0ba25d9db4da3b0820859a33fa1ae.png

6.基数排序 

b0ad518217664f8a9eb910d1857158a1.png

43011b47e221404a972efa8903701bbe.png

0718705fc28e4f82a6c64422d8e0a5ea.png

72302846dc774055bf1c068bc60a278b.png

算法分析 

ccb1fb093e9841e0b8507a83ce6a04f2.png

ebcf09f8ab8e42e6b745610b9b8055e0.png

de13a598f8f64ce28e99c2d2fe4546de.png

7.各种排序方法的综合比较 

aa551f2faad04ef6a7477b2667030af0.png

b4a4db34d1de442cb96ce0a2543e8bd2.png

9805bb05d08f46df9305b2c70df93d62.png

fef8b796742f4d8abf1b6513cffce133.png

0b86f45f30fb41eaa1535e5fe0470be7.png

8.总的代码

#include<bits/stdc++.h>

#define maxsize 20

typedef struct {
	int key;
}redtype;

typedef struct {
	redtype r[maxsize + 1];
	int len;
}sqlist;

void insertsort(sqlist &l) {
	int i,j;
	for(i = 2; i <= l.len; ++i) {
		if(l.r[i].key < l.r[i - 1].key){
			l.r[0] = l.r[i];
			for(j = i - 1; l.r[0].key < l.r[j].key; --j) {
				l.r[j + 1] = l.r[0];
			}
		}	
	}
}

void binsertsort(sqlist &l) {
	for(int i = 2; i <= l.len; ++i) {
		l.r[0] = l.r[i];
		int low = 1;
		int high = i - 1;
		while(low <= high) {
			int mid = (low + high) / 2;
			if(l.r[0].key < l.r[mid].key)
				high = mid - 1;
			else low = mid + 1;
		}
		for(int j = i - 1; j >= high + 1; --j) {
			l.r[high + 1] = l.r[0];
		}
	}
}

void shellinsert(sqlist &l, int dk) {
	int i,j;
	for(i = dk + 1; i <= l.len; ++i) {
		if(l.r[i].key < l.r[i - dk].key) {
			l.r[0] = l.r[i];
			for(j = i - dk; j > 0 && (l.r[0].key < l.r[j].key); j = j - dk) {
				l.r[j + dk] = l.r[i];
			}
			l.r[j + dk] = l.r[0];
		}
	}
}

void shellsort(sqlist &l, int dlta[], int t) {
	for(int k = 0; k < t; ++k) {
		shellinsert(l, dlta[k]);
	}
}

void bubblesort(sqlist &l) {
	int m,n,j;
	redtype x;
	for(m = 1; m <= n - 1; m++) {
		for(j = 1; j <= n - m; j++) {
			if(l.r[j].key > l.r[j + 1].key) {
				x = l.r[j];
				l.r[j] = l.r[j + 1];
				l.r[j + 1] = x;
			}
		}
	}
}

void bubblesort2(sqlist &l) {
	int m,n,j;
	int flag = 1;
	redtype x;
	for(m = 1; m <= n - 1 && flag == 1; m++) {
		flag = 0;
		for(j = 1; j <= n - m; j++) {
			if(l.r[j].key > l.r[j + 1].key) {
				flag = 1;
				x = l.r[j];
				l.r[j] = l.r[j + 1];
				l.r[j + 1] = x;
			}
		}
	}
}

int partition(sqlist &l,int low,int high) {
	l.r[0] = l.r[low];
	int pivotkey = l.r[low].key;
	while(low < high) {
		while(low < high && l.r[high].key >= pivotkey)
			--high;
		l.r[low] = l.r[high];
		while(low < high && l.r[low].key <= pivotkey)
			++low;
		l.r[high] = l.r[low];
	}
	l.r[low] = l.r[0];
	return low;
}

void qsort(sqlist &l,int low,int high) {
	if(low < high) {
		int pivotloc = partition(l,low,high);
		qsort(l,low,pivotloc - 1);
		qsort(l,pivotloc + 1,high);
	}
}

int main() {
	sqlist l;
	qsort(l,1,l.len);
	return 0;
}

void selectsort(sqlist &l) {
	int i,j,k;
	for(i = 1; i < l.len; ++i) {
		k = i;
		for(j = i + 1; j < l.len; j++) {
			if(l.r[j].key < l.r[k].key)
				k = j;
			if(k != i) {
				redtype temp = l.r[i];
				l.r[i] = l.r[k];
				l.r[k] = temp;
			}
		}
	}
}

void heapadjust(int r[],int s,int m) {
	int rc = r[s];
	for(int j = s * 2; j <= m; j *= 2) {
		if(j < m && r[j] < r[j + 1])
			++j;
		if(rc > r[j])
			break;
		r[s] = r[j];
		s = j;
	}
	r[s] = rc;
}

void heapsort(int r[]) {
	int i;
	int n = sizeof(r)/sizeof(r[0]);
	for(i = n / 2; i >= 1; i--) {
		heapadjust(r,i,n);
	}
	for(i = n; i > 1; i--) {
		swap(r[1],r[i]);
		heapadjust(r,1,i - 1);
	}
}

 

柏箱
关注
  • 61
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构——堆排序.h
09-11
数据结构——堆排序 数据结构——堆排序 数据结构——堆排序 数据结构——堆排序 数据结构——堆排序 数据结构——堆排序
数据结构——快速排序.h
09-11
数据结构——快速排序 数据结构——快速排序 数据结构——快速排序 数据结构——快速排序 数据结构——快速排序
数据结构——排序总结
m0_52711790的博客
12-14 3196
一、排序的概念 排序是计算机内经常进行的一种操作，其目的是将一组“无序”的记录序列调整为“有序”的记录序列。（递增或递减） 二、排序的分类 一图以蔽之： 三、交换排序（省略冒泡） 1、概念 快速排序： 又称划分交换排序（partition-exchange sort），简称快排，一种排序算法，最早由东尼·霍尔提出。在平均状况下，排序n个项目要 O(n log2 n)（大O符号）次比较。在最坏状况下则需要 O(n^2)次比较，但这种状况并不常见。事实上，快速排序 (n lo...
数据结构 —— 排序
m0_47653442的博客
11-15 1216
插入排序: 1.直接插入排序： 2.希尔排序 冒泡排序： 快速排序 1.Hoare法 2.挖坑法
数据结构——排序之冒泡排序
Renswc的博客
03-22 4730
冒泡排序（BubbleSort）是一种计算机科学领域的较简单的排序算法。它的基本思想是通过重复遍历待排序的数据集，并依次比较相邻的两个数据项，如果它们的顺序错误则进行交换。这个过程会持续重复直到所有相邻的数据项都已经交换完毕，此时说明该数据集已经排好序。冒泡排序的名称来源于排序过程中，较小的数据项会被逐渐“浮”到数组顶部，这个过程就像碳酸饮料中二氧化碳气泡最终会上浮到顶部的现象一样。因此，这种排序算法因其这一特性而得名。冒泡函数的核心思想。
数据结构——学习笔记——入门必看【建议收藏】
热门推荐
刘鑫磊
02-09 41万+
（2）静态查找表&动态查找表的区别用法【顺序查找-线性查找-折半查找-二分查找-有序表查找-插值查找-斐波那契查找-索引顺序表查找-分块查找】单独使用顺序存储结构（即数组）无法很好地实现树的存储概念，不过如果充分利用顺序存储和链式存储结构的特点，则完全可以实现对数的存储结构的表示。深度为 2，则至多只有 3 个结点：根结点，根结点的左子树，根结点的右子树···指的是这样一个数列：1、1、2、3、5、8、13、21、……（3）四中常见的多路查找树【2-3 树$2-3-4 树$B 树$B+ 树】的区别用法。
数据结构——排序算法（C语言）
m0_72165281的博客
10-08 4339
数据结构——排序算法
数据结构——排序算法总结（八个）
qq_34252068的博客
08-05 6914
内排序：指在排序期间数据对象所有存放在内存的排序。外排序：指在排序期间所有对象太多，不能同一时候存放在内存中，必须依据排序过程的要求，不断在内，外存间移动的排序。
数据结构——排序复习
Canmido的博客
06-14 270
数据结构自己复习整理
数据结构——排序的稳定性
weixin_46038856的博客
11-09 836
稳定性： 数组 arr 中有若干元素，其中元素 A 在元素 B 前边，如果使用某种排序算法之后，能够保持 元素 A 仍然在元素 B 的前边，就说这个算法是稳定的。 常见算法的稳定性以及平均时间复杂度： ...
一张图看懂数据结构——排序
老猫的博客
05-15 973
总览
数据结构——归并排序
06-17
《数据结构》严蔚敏版是计算机科学的经典教材，其中对归并排序有深入的阐述。下面我们将详细探讨归并排序的原理、实现方式以及其在实际应用中的优势。 一、归并排序的基本概念 归并排序的核心思想是将大问题分解为...
数据结构——排序和查找应用词典
12-18
请设计一个简单的英文词典，实现以下功能： 1、生成词典：可以一个一个录入，也可以批量生成，每个英文单词有一个中文意思（至少十个单词，无序）...3、排序：可以根据英文字母顺序进行排序。 4、输出：显示整个词典。
单链表-数据结构
qq_31804097的博客
08-07 213
【代码】单链表、双向带头循环链表-数据结构。
常见8种数据结构
qq_43575301的博客
08-08 2052
应用于需要后进先出访问元素的场景，如函数调用栈、表达式求值等。应用于需要先进先出访问元素的场景，如任务调度、消息队列等。适用于优先队列，堆排序和实现高效的合并K个有序链表问题。应用于需要表示层次结构的场景，比如文件系统、组织结构等。应用于需要表示网络结构的场景，如社交网络、交通网络等。应用于需要快速查找和插入操作的场景，如字典、缓存等。一般应用于需要快速随机访问元素的场景。适用于需要频繁插入和删除元素的场景。
理解栈（Stack）及其在 C++ 中的应用【栈、数据结构】
qq_22841387的博客
08-07 450
栈是一种数据结构，它遵循“后进先出”（LIFO - Last In, First Out）的原则。栈就像是一叠盘子，你只能从最上面拿盘子，也只能在最上面放盘子。栈的这一特性使其在很多场景中非常有用，例如递归、回溯算法和表达式计算等。通过这篇博客，我们详细介绍了栈的基本概念及其在 C++ 中的实现。栈是一种非常有用的数据结构，尤其在处理递归、回溯和表达式计算等问题时。我们还讨论了如何将栈中的字符转换为字符串，以及如何使用栈解决括号匹配问题。
基础算法模板
最新发布
2301_79235379的博客
08-08 521
欢迎订阅专栏，数据结构实验，期末大作业，前端后端，算法都有哦，想我发哪个方面的资源或文章可以私信我，免费的哦。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

柏箱

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

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

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

打赏作者

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

抵扣说明：

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

余额充值