八种排序方式：冒泡、选择、插入、希尔、快速、归并、堆、桶。

讲什么讷

于 2021-04-11 23:15:07 发布

阅读量123

点赞数

本文链接：https://blog.csdn.net/luobuxiade/article/details/115609297

版权

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

/**
 * O(N^2) : 冒泡、选择、插入、希尔 O(N^1.5)
 * O(NlogN) : 快速、归并、堆
 * O(N * M) : 桶
 *
 * 时间复杂度
 * 交换次数。稳定性。
 *
 */

#define N 100000
int arr[N] = {};

void bubble_sort(int* arr, int len)
{
	for(int i = 0; i < len - 1; ++i){
		for(int j = 0; j < len - i - 1; ++j){
			if(arr[j] > arr[j + 1]){
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
}

void select_sort(int* arr, int len)
{
	for(int i = 0; i < len - 1; ++i){
		int min = i;
		for(int j = i + 1; j < len; ++j){
			if(arr[min] > arr[j]) min = j;
		}

		if(i != min){
			int temp = arr[i];
			arr[i] = arr[min];
			arr[min] = temp;
		}
	}
}

void insert_sort(int* arr, int len)
{
	for(int i = 1; i < len; ++i){
		int val = arr[i], j = i - 1;
		for(; j >= 0; --j){
			if(val < arr[j]) arr[j + 1] = arr[j];
			else break;
		}

		arr[j + 1] = val;
	}
}

void shell_sort(int* arr, int len)
{
	int sep = len / 2;

	while(sep > 0){
		for(int i = sep; i < len; i += 1){
			int val = arr[i], j = i - sep;
			for(; j >= 0; j -= sep){
				if(val < arr[j]) arr[j + sep] = arr[j];
				else break;
			}

			arr[j + sep] = val;
		}

		sep /= 2;
	}
}

void quick_sort_private(int* arr, int left, int right)
{
	if(left >= right) return;

	int l = left, r = right, key = arr[right];
	while(l < r){
		while(l < r && key >= arr[l]) ++l;
		arr[r] = arr[l];
		
		while(l < r && key <= arr[r]) --r;
		arr[l] = arr[r];
	}

	//l == r
	arr[l] = key;

	//左边排
	quick_sort_private(arr, left, l - 1);
	//右边排
	quick_sort_private(arr, r + 1, right);
}

void quick_sort(int* arr, int len)
{
	quick_sort_private(arr, 0, len - 1);
}

void merge_sort_private(int* arr, int left, int right)
{
	if(left >= right) return;

	//1. 拆分
	int l = left, r = right;
	int m = (l + r) / 2;

	//2. 排序
	merge_sort_private(arr, l, m);
	merge_sort_private(arr, m + 1, r);

	//3. 归并
	int i = l, j = m + 1, temp[right - left + 1], idx = 0;
	while(i <= m && j <= right){
		if(arr[i] <= arr[j]){
			temp[idx++] = arr[i++];
		}else{
			temp[idx++] = arr[j++];
		}
	}

	for(; i <= m; ++i) temp[idx++] = arr[i];
	for(; j <= right; ++j) temp[idx++] = arr[j];

	for(i = 0; i < idx; ++i) arr[left + i] = temp[i];
}

void merge_sort(int* arr, int len)
{
	merge_sort_private(arr, 0, len - 1);
}

void count_sort(int* arr, int len)
{
	//1. 准备桶
	int max = arr[0], min = arr[0];
	for(int i = 1; i < len; ++i){
		if(max < arr[i]) max = arr[i];
		if(min > arr[i]) min = arr[i];
	}

	int* bucket = (int*)malloc(sizeof(int) * (max - min + 1));
	memset(bucket, 0, sizeof(int) * (max - min + 1));

	//2. 计数
	for(int i = 0; i < len; ++i){
		bucket[arr[i] - min]++;
	}

	int idx = 0;
	for(int i = 0; i < (max - min + 1); ++i){
		for(int j = 0; j < bucket[i]; ++j){
			arr[idx++] = i + min;
		}
	}

	free(bucket);
}

//1. 下榻
void adjust_heap(int* arr, int len, int idx)
{
	int left = idx * 2 + 1, right = idx * 2 + 2;
	int max = idx;
	if(left < len) max = (arr[max] > arr[left] ? max : left);
	if(right < len) max = (arr[max] > arr[right] ? max : right);

	if(max != idx){
		int temp = arr[max];
		arr[max] = arr[idx];
		arr[idx] = temp;

		adjust_heap(arr, len, max);
	}
}

void heap_sort(int* arr, int len)
{
	//1. 调整大堆顶
	for(int i = len / 2; i >= 0; --i) adjust_heap(arr, len, i);

	//2. 排序
	while(len > 0){
		int temp = arr[0];
		arr[0] = arr[len - 1];
		arr[len - 1] = temp;

		--len;
		adjust_heap(arr, len, 0);
	}
}

void init(void)
{
	for(int i = 0; i < N; ++i) arr[i] = rand() % 10000;
}

void print(void)
{
	for(int i = 0; i < N; ++i) printf("%d\n", arr[i]);
}

int test_sort(int* arr, int len, void (*sort)(int*, int))
{
	clock_t s = clock();//计时
	sort(arr, len);
	clock_t e = clock();//计时

	return (e - s) * 1000 / CLOCKS_PER_SEC;
}

int main(void)
{
	srand(time(0));
	//排序

	//init();
	//printf("冒泡排序: %dms\n", test_sort(arr, N, bubble_sort));
	//init();
	//printf("选择排序: %dms\n", test_sort(arr, N, select_sort));
	//init();
	//printf("插入排序: %dms\n", test_sort(arr, N, insert_sort));
	//init();
	//printf("希尔排序: %dms\n", test_sort(arr, N, shell_sort));
	init();
	printf("快速排序: %dms\n", test_sort(arr, N, quick_sort));
	//init();
	//printf("归并排序: %dms\n", test_sort(arr, N, merge_sort));
	//init();
	//printf("计数排序: %dms\n", test_sort(arr, N, count_sort));
	init();
	printf("堆排序: %dms\n", test_sort(arr, N, heap_sort));
	//print();

	return 0;
}

欢迎使用Markdown编辑器

你好！这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。

新的改变

我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客：

全新的界面设计 ，将会带来全新的写作体验；
在创作中心设置你喜爱的代码高亮样式，Markdown 将代码片显示选择的高亮样式 进行展示；
增加了 图片拖拽 功能，你可以将本地的图片直接拖拽到编辑区域直接展示；
全新的 KaTeX数学公式 语法；
增加了支持甘特图的mermaid语法¹ 功能；
增加了 多屏幕编辑 Markdown文章功能；
增加了 焦点写作模式、预览模式、简洁写作模式、左右区域同步滚轮设置 等功能，功能按钮位于编辑区域与预览区域中间；
增加了 检查列表 功能。

功能快捷键

撤销：Ctrl/Command + Z
重做：Ctrl/Command + Y
加粗：Ctrl/Command + B
斜体：Ctrl/Command + I
标题：Ctrl/Command + Shift + H
无序列表：Ctrl/Command + Shift + U
有序列表：Ctrl/Command + Shift + O
检查列表：Ctrl/Command + Shift + C
插入代码：Ctrl/Command + Shift + K
插入链接：Ctrl/Command + Shift + L
插入图片：Ctrl/Command + Shift + G
查找：Ctrl/Command + F
替换：Ctrl/Command + G

合理的创建标题，有助于目录的生成

直接输入1次#，并按下space后，将生成1级标题。
输入2次#，并按下space后，将生成2级标题。
以此类推，我们支持6级标题。有助于使用TOC语法后生成一个完美的目录。

如何改变文本的样式

强调文本 强调文本

加粗文本 加粗文本

标记文本

~~删除文本~~

引用文本

H₂O is是液体。

2¹⁰ 运算结果是 1024.

插入链接与图片

链接: link.

图片: Alt

带尺寸的图片:

居中的图片: Alt

居中并且带尺寸的图片:

当然，我们为了让用户更加便捷，我们增加了图片拖拽功能。

如何插入一段漂亮的代码片

去博客设置页面，选择一款你喜欢的代码片高亮样式，下面展示同样高亮的 代码片.

// An highlighted block
var foo = 'bar';

生成一个适合你的列表

项目
- 项目
  - 项目

项目1
项目2
项目3

计划任务
完成任务

创建一个表格

一个简单的表格是这么创建的：

项目	Value
电脑	$1600
手机	$12
导管	$1

设定内容居中、居左、居右

使用:---------:居中
使用:----------居左
使用----------:居右

第一列	第二列	第三列
第一列文本居中	第二列文本居右	第三列文本居左

SmartyPants

SmartyPants将ASCII标点字符转换为“智能”印刷标点HTML实体。例如：

TYPE	ASCII	HTML
Single backticks	`'Isn't this fun?'`	‘Isn’t this fun?’
Quotes	`"Isn't this fun?"`	“Isn’t this fun?”
Dashes	`-- is en-dash, --- is em-dash`	– is en-dash, — is em-dash