排序算法总结

最新推荐文章于 2024-03-27 13:25:20 发布
最新推荐文章于 2024-03-27 13:25:20 发布
阅读量258 收藏
点赞数
分类专栏： 算法 文章标签： 排序算法 算法代码 伪代码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Up_junior/article/details/93486589
版权

1.插入排序算法（附伪代码和C源码）

  • 插入排序原理：从第i=2位开始到数组长度|A|截至。将当前i的值key取出来，从i开始从后往前[1, i-1]寻找小于（大于）key的下标且下标不为0，找的同时如果不满足寻找条件，将经历的数整体往后移动，直到不满足条件为止。由于从第二个数开始后保证当前数之前的序列是有序的，最终i=|A|时可满足整个序列有序！
  • 伪代码
INSERTION-SORT(A)
for i=2 to |A|
	key = A[i]
	j = i - 1
	while j>=0 and A[j] > key
		A[j+1] = A[j]
		j = j - 1
	end
	A[j+1] = key
end
  • 算法执行过程图
    InsertSort
  • 动态过程图

出处（请多支持原创，我只是简单搬运）：https://www.zhihu.com/search?type=content&q=堆排序
在这里插入图片描述

  • 插入排序
#include <stdio.h>
int arr[5] = { 10, 4, 2 ,6 ,1 };
const int arrrlens = 5;
void PrintArray(int* arr)
{
	for (int ii = 0; ii < arrrlens; ii++)
		printf("%d ", arr[ii]);
	printf("\n");
}
// InsertSort SourceCode
void InsertSort(int *arr)
{
	for (int ii = 1; ii < arrrlens; ii++)
	{
		int key = arr[ii];
		int jj = ii - 1;
		while (jj >= 0 && arr[jj] > key)
		{
			arr[jj+1] = arr[jj];
			jj = jj - 1;
		}
		arr[jj+1] = key;
	}
}
int main()
{	
	PrintArray(arr);
	InsertSort(arr);
	PrintArray(arr);
}

2.归并排序算法（附C源码）

  • 这篇博客对于归并排序原理讲的特别好，我就不赘述了。

https://www.cnblogs.com/chengxiao/p/6194356.html

  • 动态过程图

出处（请多支持原创，我只是简单搬运）：https://www.zhihu.com/search?type=content&q=堆排序
在这里插入图片描述

#include <stdio.h>
const int arrrlens = 8;
int arr[arrrlens] = { 8, 7, 6 ,5 ,4 ,3 ,2 ,1 };
int ans[arrrlens] = { 0 };
void PrintArray(int* arr)
{
	printf("Merge Sort\n");
	for (int ii = 0; ii < arrrlens; ii++)
		printf("%d ", arr[ii]);
	printf("\n");
}
void Merge(int* arr, int left, int mid, int right)
{
	int p = left;
	int q = mid + 1;
	int t = 0;
	/* 这块比较难理解点*/
	while (p <= mid && q <= right)
	{
		if (arr[p] <= arr[q])
			ans[t++] = arr[p++];
		else
			ans[t++] = arr[q++];
	}
	while (p <= mid)
		ans[t++] = arr[p++];
	while (q <= right)
		ans[t++] = arr[q++];
	t = 0;
	while (left <= right)
		arr[left++] = ans[t++];
}
/*Merge-Sort SourceCode*/
void MergeSort(int* arr, int p, int r)
{
	if (p < r) //Termination conditions
	{
		int q = (p + r) / 2;
		MergeSort(arr, p, q);
		MergeSort(arr, q + 1, r);
		Merge(arr, p, q, r);
	}
}
int main()
{
	PrintArray(arr);
	int r = arrrlens - 1;
	int p = 0;
	MergeSort(arr, p, r);
	PrintArray(arr);
	return 0;
}

3.堆排序算法（附C源码）

  • 堆排序
#include <stdio.h>
const int arrrlens = 8;
int arr[arrrlens] = { 4, 6 ,8 ,5 ,9, 1, 10, 22};
int ans[arrrlens] = { 0 };
void PrintArray(int* arr)
{
	printf("Heap Sort\n");
	for (int ii = 0; ii < arrrlens; ii++)
		printf("%d ", arr[ii]);
	printf("\n");
}
void swap(int *a, int *b)
{
	int temp = *b;
	*b = *a;
	*a = temp;
}
void Max_heap(int* arr, int i, int lens)
{
	int left = 2 * i + 1;
	int right = 2 * i + 2;
	if (left <= lens && arr[i] < arr[left])
	{
		swap(&arr[i], &arr[left]);
		Max_heap(arr, left, lens);
	}
	if (right <= lens && arr[i] < arr[right])
	{
		swap(&arr[i], &arr[right]);
		Max_heap(arr, right, lens);
	}
}
void CreateHeap(int* arr)
{
	//自底向上建堆
	for (int j = arrrlens-1; j >= 0; j--)
	{
		int n = j / 2;
		for (int i = n; i >= 0; i--)
			Max_heap(arr, i, j);
		swap(&arr[j], &arr[0]);
	}
}
int main()
{
	PrintArray(arr);
	CreateHeap(arr);
	PrintArray(arr);
	return 0;
}

4.快速排序算法（附C源码）

  • 快速排序
#include <stdio.h>
const int arrrlens = 8;
int arr[arrrlens] = { 8, 4 ,5 ,7 ,1, 3, 6, 2};
int ans[arrrlens] = { 0 };
void PrintArray(int* arr)
{
	printf("Quick Sort\n");
	for (int ii = 0; ii < arrrlens; ii++)
		printf("%d ", arr[ii]);
	printf("\n");
}
void QuickSort(int* arr, int left, int right)
{
	if (left > right)
		return;
	int p = left;
	int q = right;
	int key = arr[left];
	while (p != q)
	{
		for (; q > p && arr[q] >= key;)  
			q--;
		arr[p] = arr[q];
		for (; p < q && arr[p] <= key;)  
			p++;
		arr[q] = arr[p];
	}
	//将基准数key放到位置p,保证o(n)空间复杂度。
	arr[p] = key;
	QuickSort(arr,left, p-1);
	QuickSort(arr, p+1, right);
	return;
}
int main()
{
	PrintArray(arr);
	QuickSort(arr, 0, arrrlens-1);
	PrintArray(arr);
	return 0;
}

5.冒泡排序算法（附C源码）

  • 冒泡排序
  • 动态过程图

出处（请多支持原创，我只是简单搬运）：https://www.zhihu.com/search?type=content&q=堆排序
在这里插入图片描述

#include <stdio.h>
const int arrrlens = 8;
int arr[arrrlens] = { 8, 4 ,5 ,7 ,1, 3, 6, 2};
int ans[arrrlens] = { 0 };
void PrintArray(int* arr)
{
	printf("Quick Sort\n");
	for (int ii = 0; ii < arrrlens; ii++)
		printf("%d ", arr[ii]);
	printf("\n");
}
void swap(int* a, int* b)
{
	int temp = *b;
	*b = *a;
	*a = temp;
}
void BubbleSort(int *arr)
{
	for (int i = 0; i < arrrlens; i++)
	{
		for (int j = 0; j < arrrlens-1-i; j++)
		{
			//由于是j+1和j比较，所以j的范围要-1
			//减去i是因为每次会把子序列的最小值放到后面部分
			//后面部分已经有序，不用再去比较
			if (arr[j] > arr[j + 1])
				swap(&arr[j],&arr[j+1]);
		}
	}
}
int main()
{
	PrintArray(arr);
	BubbleSort(arr);
	PrintArray(arr);
	return 0;
}

6.选择排序算法（附C源码）

  • 选择排序
#include <stdio.h>
const int arrrlens = 8;
int arr[arrrlens] = { 8, 4 ,5 ,7 ,1, 3, 6, 2};
int ans[arrrlens] = { 0 };
void PrintArray(int* arr)
{
	printf("Quick Sort\n");
	for (int ii = 0; ii < arrrlens; ii++)
		printf("%d ", arr[ii]);
	printf("\n");
}
void swap(int* a, int* b)
{
	int temp = *b;
	*b = *a;
	*a = temp;
}
void SelectionSort(int *arr)
{
	for (int i = 0; i < arrrlens; i++)
	{
		int index = i;
		for (int j = i+1; j < arrrlens; j++)
		{
			if (arr[j] < arr[index])
				index = j;
		}
		swap(&arr[i], &arr[index]);
	}
}
int main()
{
	PrintArray(arr);
	SelectionSort(arr);
	PrintArray(arr);
	return 0;
}

7.希尔排序算法（附C源码）

  • 希尔排序
#include <stdio.h>
const int arrrlens = 15;
int arr[arrrlens] = { 99, 5, 69, 33, 56, 13, 22, 55, 77, 48, 12, 88, 2,69,99 };
int ans[arrrlens] = { 0 };
void PrintArray(int* arr)
{
	printf("Shell Sort\n");
	for (int ii = 0; ii < arrrlens; ii++)
		printf("%d ", arr[ii]);
	printf("\n");
}
void ShellSort(int* arr)
{
	
	int gap = arrrlens/2;
	while (gap > 0)
	{
		printf("gap: %d \n", gap);
		gap /= 2;
		for(int j = 0; j < gap; j ++)
		{ 
			for(int i = j + gap; i < arrrlens; i += gap)
			{
				int key = arr[i];
				int k = i - gap;
				while ( k >= j && arr[k] > key)
				{
					arr[k + gap] = arr[k];
					k -= gap;
				}
				arr[k + gap] = key;
			}
		}	
	}
}
int main()
{
	PrintArray(arr);
	ShellSort(arr);
	PrintArray(arr);
	return 0;
}

8.计数排序算法（附C源码）

  • 计数排序
#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
const int arrrlens = 15;
int arr[arrrlens] = { 99, 5, 69, 33, 56, 13, 22, 55, 77, 48, 12, 88, 2, 69, 99 };
int const max_int = 2147483647;
int const min_int = -2147483647;
void PrintArray(int* arr)
{
	printf("Shell Sort\n");
	for (int ii = 0; ii < arrrlens; ii++)
		printf("%d ", arr[ii]);
	printf("\n");
}
void CountingSort(int* arr)
{
	int max = min_int;
	int min = max_int;
	for (int ii = 0; ii < arrrlens; ii++)
	{
		if (max < arr[ii])
			max = arr[ii];
		if (min > arr[ii])
			min = arr[ii];
	}
	const int COUNTINGARR_LENS = max - min+1;
	int* CountingArr = (int*)calloc(COUNTINGARR_LENS, sizeof(int));
	memset(CountingArr, 0, COUNTINGARR_LENS);
	for (int ii = 0; ii < arrrlens; ii++)
		CountingArr[arr[ii]-min] += 1;
	for (int ii = 0; ii < COUNTINGARR_LENS; ii++)
	{
		for(int jj=0; jj < CountingArr[ii]; jj++)
			printf("%d ", min+ii);
	}
}
int main()
{
	PrintArray(arr);
	CountingSort(arr);
	return 0;
}

9.基数排序算法（附C源码）

  • 计数排序
#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include <math.h>
const int arrrlens = 5;
int arr[arrrlens] = { 2314, 5428, 373, 2222, 17 };
int const max_int = 2147483647;
int const min_int = -2147483647;
void PrintArray(int* arr, int n)
{
	printf("Shell Sort\n");
	for (int ii = 0; ii < n; ii++)
		printf("%d ", arr[ii]);
	printf("\n");
}
int MaxData(int* arr)
{
	int max = min_int;
	for (int ii = 0; ii < arrrlens; ii++)
	{
		if (arr[ii] > max)
			max = arr[ii];
	}
	int digit = 0;
	while (max > 0)
	{
		max = max / 10;
		digit++;
	}
	return digit;
}
void RadixSort(int* arr)
{
	int digit = MaxData(arr);
	int base = 1;
	//printf("%d ", digit);
	while (digit--)
	{
		int count[10] = {0};
		int temp[arrrlens] = {0};
		for (int ii = 0; ii < arrrlens; ii++)
		{
			int num =  arr[ii] / base % 10;
			count[num] ++;
		}
		for (int ii = 1; ii < 10; ii++)
			count[ii] = count[ii] + count[ii - 1];
		for (int ii= arrrlens-1; ii >= 0; ii--)
		{
			int num = arr[ii] / base % 10;
			temp[--count[num]] = arr[ii];
		}
		for (int ii = 0; ii < arrrlens; ii++)
			arr[ii] = temp[ii];
		base *= 10;
		PrintArray(arr,arrrlens);
	}
}
int main()
{
	RadixSort(arr);
	return 0;
}
Hello、MrTree
关注
专栏目录
基数排序的思想以及伪代码实现
mbskyhan的专栏
03-14 808
桶排序算法总结 通过分配和收集的方式进行排序 value/(max+1)*n（这是计算每个元素value应该放入哪个桶里） 算出value应该到哪个桶里面，得出的是 桶的下标 O(N)---O(NlgN) //最好的情况是每个元素分到一个桶里为O(N) 最坏情况是所有元素分到一个桶里，对桶里的元素用快速排序 或者是插入排序则是O(NlgN)的复杂度 k=N/M N个元素，M个桶 O(N+C) O(N+NlgN-NlgM)(M等于1的时候就是O(N+lgN)) 基数排序的过程也是通过分配和收集过程实
数据结构和算法——桶排序和基数排序（图示、伪代码、多关键字排序，基数排序代码）
li13437542099的博客
07-26 219
假设有N个学生，他们的成绩是0到100之间的整数（于是有M=101个不同的成绩值）。如何在线性时间内将学生按成绩排序？桶排序的处理方法是：建立M个桶，一开始初始化为空链表；插入成绩值时，找到对应的桶，链接到对应的桶里面。
基数排序
乘风破浪会有时
08-16 849
基数排序的说明基数排序是一种用在卡片排序机上的算法。基数排序先按最低有效位进行稳定的排序，再利用排序子算法的稳定性，逐渐对高位进行稳定的排序，依次类推。基数排序必须保证子排序算法的稳定性，伪代码如下：RADIX-SORT(A, d) for i = 1 to d use a stable sort to sort array A on digit i
排序算法总结(9)--基数排序
liqiutuoyuan的博客
05-23 472
基数排序
【算法】基数排序
weixin_30648963的博客
11-11 178
计数排序 学习基数排序之前首先学习计数排序。 计数排序假设每个元素都是在0到k之间的一个整数。 基数排序的基本思想，对于每个元素x，如果我们知道了小于x的元素的个数，就可以确定输出数组中元素x的位置，那么直接将元素x放到输出数组中。比如有3小于x的元素，那在输出数组中，x肯定位于第4个位置。 计数排序的算法用伪代码描述为： COUNTING-SORT(A,k) // 初始化...
十大经典排序算法总结.docx
08-24
《十大经典排序算法总结》 排序算法是计算机科学的基础，其设计思想和效率对软件的性能有着直接影响。本文主要探讨了十种经典的排序算法，包括它们的设计思路、优缺点以及适用场景，帮助我们理解排序算法的核心。 ...
常见排序算法总结.pdf
03-28
【排序算法总结】 排序算法是计算机科学中处理数据排列的重要工具，主要分为稳定排序和非稳定排序、内排序和外排序两大类。稳定排序保证了相同元素在排序后的相对位置不变，而非稳定排序则不作此保证。内排序是指...
C#排序算法总结
09-18
C#排序算法总结涵盖了交换排序和插入排序两大类排序算法，其中交换排序包括了冒泡排序、选择排序和快速排序，而插入排序则涉及直接插入排序和折半插入排序。下面将详细介绍每种排序算法的实现原理、特点以及在C#中的...
Java实现常见排序算法总结
05-02
【Java实现常见排序算法总结】 排序算法是计算机科学中至关重要的一部分，它涉及到数据处理和算法设计。本文将探讨两种常见的排序算法在Java中的实现：直接插入排序和希尔排序。 1. **直接插入排序（直接插入排序...
排序算法实现代码与伪代码
06-11
本压缩包中包含了各种冒泡算法的代码实现与伪代码实现，附有对排序算法思想的解释，方便读者快速掌握排序算法。
算法三十：基数排序
闲狗的博客
07-04 1450
问题描述 给定 n 个 [0,2^k) 之间的整数，请你将它们升序排序。 由于 n 可能很大，为了避免过大的输入、输出规模，我们会在程序内部生成数据，并要求你输出排序后序列的哈希值。具体方法如下（用c++代码展示）： typedef unsigned int u32; u32 nextInt(u32 x){ x^=x&lt;&lt;13; x^=x&gt;&gt;17; x^=...
排序算法：数据结构中的基数排序算法
新华编程特战队
01-17 2059
它非常适合按数字对整数和按字符对字符串进行排序，它按数字值将元素分配到存储桶中，从最低有效数字到最高有效数字重复排序以获得最终顺序。是一种稳定的排序方法，它使用计数排序作为子例程。，请注意一次，因为它是基数排序的先决条件，如果您想按降序对数组进行排序，请调整计数排序函数以使其排序数组按相反顺序排列。在最好的情况下，当数组已经排序时，我们不需要应用该算法，而是可以在数组的单次遍历中检查数组是否已排序。其中，b 是原始数组中元素的基数，因为在上述情况下我们处理的是十进制数（基数为 10），所以 b = 10。
基数排序代码详解（排序算法）
qinian8的博客
05-28 9082
核心思想是按每一位的大小去排序，因为一位数的范围是0-9，就将每一位的数字提出来然后依次排序。什么都不说了，都在代码中有备注。 代码详解： package com.sort; import java.util.*; /** * @author yn * @description 基数排序 * 目前做的全是正数，如果出现负数，先把所有的负数分为一组（正负数分离）， * 将负号全部去掉，然...
算法导论 — 8.3 基数排序
yangtzhou的专栏
01-14 1056
笔记 基数排序的做法为：对一组输入整数，先按最低位数字排好序，然后按次低位数字排好序，如此迭代，直至最后一步按最高位数字排好序，此时所有输入数据已排好序。基数排序要求对单个数字采用的排序算法是稳定的。 　　以十进制数为例，基数排序算法先按个位数字排序，然后按十位数字排序……直至最后按最高位数字排序。下图给出了一个例子。 　　 　　下面给出基数排序的伪代码。在下面的代码中，我们假设输入数组AAA包含...
基数排序算法
ccc369639963的博客
01-20 1104
基数排序算法 在学会计数排序算法的基础上，本节我们再学习一种排序算法，称为基数排序算法。 基数排序算法适用于对多个整数或者多个字符串进行升序或降序排序，例如： 121, 432, 564, 23, 1, 45, 788 “zhangsan”、“lisi”、“wangwu” 一个整数由多个数字组成，例如 123 由 1、2、3 这 3 个数字组成；一个字符串由多个字符组成，例如 “lisi” 由 “l”、“i”、“s”、“i” 这 4 个字符组成。基数排序算法的实现思路是：对于待排序序列中的各个元素，依次比较
基数排序详解
最新发布
笔者从事电信媒体开发多年，愿意将多年的开发经验分享给同行
03-27 1138
在计算机科学中，排序算法是一种非常基础和重要的算法类型，用于对一系列数据进行有序的排列。在众多排序算法中，基数排序以其独特的工作机制和优秀的性能，得到了广泛的关注和应用。本文将详细介绍基数排序的相关知识，包括其工作原理、稳定性、优化方法以及应用场景等。
基础排序算法总结（插入、选择、冒泡、合并、二分查找、堆排序、快速排序、基数排序、桶排序、计数排序）
Try_Or_Die的专栏
05-12 1399
本文是在学习《算法导论》的基础排序算法过程中，自己写的Java代码，深入掌握思想，并且有能力实现，并且分析其复杂度。本文对于每一个算法，按照算法思想、伪代码、Java实现、复杂度简单分析的方式分析每一个排序。 一 插入排序          1：算法思想          插入排序是对少量元素进行排序的有效算法。扑克牌摸牌时就是典型的插入排序，无论在什么时候，左手中的牌都是排好序的。
十大经典排序算法(动态演示+代码)
weixin_44747933的博客
05-20 2150
以前也零零碎碎发过一些排序算法，但排版都不太好，又重新整理一次，排序算法是数据结构的重要部分，系统地学习很有必要。时间、空间复杂度比较 排序算法平均时间复杂度最差时间复杂度空间复杂度数据...
数据结构详解：排序算法总结与复杂性分析
本资源是一份关于常用排序算法总结的PPT课件，主要涵盖了数据结构中的排序理论和实践。章节9详细介绍了排序的基本概念，包括排序的定义，即通过特定规则重新排列数据，使其满足非递减关系。排序被划分为稳定和不稳定...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值