49 排序方法

最新推荐文章于 2023-01-07 15:17:57 发布
最新推荐文章于 2023-01-07 15:17:57 发布
阅读量134 收藏
点赞数
分类专栏： 笔记 文章标签： 算法 c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36643203/article/details/120759603
版权

1 选择法

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

/*-------------------- 排序规则 --------------------

		它的工作原理是每一次从待排序的数据元素中选出
		最小（或最大）的一个元素，存放在序列的起始位
		置，直到全部待排序的数据元素排完。

		稳定性:选择排序是不稳定的排序方法 如:[5,5,3]

-------------------------------------------------*/

//选择排序(升序排列)
void selectionSort(int *array, int len)
{
	int min = 0;	// 指向最小的元素的位置
	// 外层循环
	for (int i = 0; i < len - 1; ++i)
	{
		min = i;
		// 内存循环
		for (int j = i + 1; j < len; ++j)
		{
			// 判断
			if (array[min] > array[j])
			{
				// 保存最小的元素的位置
				min = j;
			}
		}
		// 判断是否需要交换
		if (min != i)
		{
			// 找到了新的最小值
			// 交换
			int tmp = array[min];
			array[min] = array[i];
			array[i] = tmp;
		}
	}
}

#if 0
void main()
{
	int i;
	//定义整型数组
	int array[] = { 12, 5, 33, 6, 10 };
	//计算数组长度
	int len = sizeof(array) / sizeof(int);
	//遍历数组
	printf("待排序数组序列: ");
	for (i = 0; i < len; ++i)
	{
		printf("%d\t", array[i]);
	}
	printf("\n");

	//排序
	selectionSort(array, len);

	//遍历
	printf("选择排序之后的序列:	");
	for (i = 0; i < len; ++i)
	{
		printf("%d\t", array[i]);
	}
	printf("\n");
	system("pause");
}
#endif

2 插入排序

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

/******************* 排序规则 *******************

	每次处理就是将无序数列的第一个元素与有序数列
	的元素从后往前逐个进行比较，找出插入位置，将
	该元素插入到有序数列的合适位置中。

	稳定性:插入排序是稳定的

***********************************************/

//插入排序算法(升序排列)
void insertionSort(int *array, int len)
{
	int tmp = 0;	// 存储基准数
	int index = 0;	// 坑的位置
	// 遍历无序序列
	for (int i = 1; i < len; ++i)
	{
		index = i;
		tmp = array[i];
		// 遍历有序序列(从后往前)
		for (int j = i - 1; j >= 0; --j)
		{
			// 基准数根有序序列中的元素比较
			if (tmp < array[j])
			{
				// 有序序列元素后移
				array[j + 1] = array[j];
				// 坑的位置
				index = j;
			}
			else
			{
				break;
			}
		}
		// 填坑
		array[index] = tmp;
	}
}

#if 0
void main()
{
	int i;
	//定义整型数组
	int array[] = { 12, 5, 33, 6, 10 };
	//计算数组长度
	int len = sizeof(array) / sizeof(int);
	//遍历数组
	printf("待排序数组序列: ");
	for (int i = 0; i < len; ++i)
	{
		printf("%d\t", array[i]);
	}
	printf("\n");

	//排序
	insertionSort(array, len);

	//遍历
	printf("插入排序之后的序列:	");
	for (i = 0; i < len; ++i)
	{
		printf("%d\t", array[i]);
	}
	printf("\n");
	system("pause");
}
#endif

3 冒泡法

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

/********************* 排序规则 *********************

冒泡排序算法的运作如下：（从后往前）
	1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
	2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
	3. 针对所有的元素重复以上的步骤，除了最后一个。
	4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

稳定性:冒泡排序是一种稳定排序算法

***************************************************/

//冒泡排序(升序)
void bubbleSort(int *array, int len)	//O(n²)
{
#if 0
	// 外层
	for (int i= 0; i < len; ++i)
	{
		for (int j = 1; j < len - i; j++)
		{
			// 交换
			if (array[j] < array[j - 1])
			{
				int tmp = array[j];
				array[j] = array[j - 1];
				array[j - 1] = tmp;
			}
		}
	}
#endif
	// 0: 没有排好, 1: 已经排好
	int flag = 0;
	for (int i = len - 1; i > 0 && flag==0; --i)
	{
		flag = 1;	// 默认已经排好
		for (int j = 0; j < i; ++j)
		{
			if (array[j] > array[j + 1])
			{
				int tmp = array[j];
				array[j] = array[j + 1];
				array[j + 1] = tmp;
				flag = 0;	// 没有排好
			}
		}
	}
}

#if 0
void main()
{
	int i;
	//定义整型数组
	int array[] = { 11, 8, 7, 6, 3 };
	//计算数组长度
	int len = sizeof(array) / sizeof(int);
	//遍历数组
	printf("待排序数组序列: ");
	for (i = 0; i < len; ++i)
	{
		printf("%d\t", array[i]);
	}
	printf("\n");

	//排序
	bubbleSort(array, len);

	//遍历
	printf("冒泡排序之后的序列:	");
	for (i = 0; i < len; ++i)
	{
		printf("%d\t", array[i]);
	}
	printf("\n");
	system("pause");
}
#endif

4 希尔排序

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

/**************************** 排序规则 ****************************

	希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；
	随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰
	被分成一组，算法便终止。

	稳定性: 希尔排序是非稳定排序算法。

*****************************************************************/
//希尔排序
void shellSort(int *array, int len)
{
	// 步长
	int gap = len;
	while (gap > 1)
	{
		// 步长递减公式
		gap = gap / 3 + 1;
		// 分组, 对每一组, 进行插入排序
		for (int i = 0; i < gap; ++i)
		{
			int tmp;	// 基准数
			int index;	// 坑的位置
			// 插入排序
			// 无序序列
			for (int j = i + gap; j < len; j += gap)
			{
				tmp = array[j];
				index = j;
				// 有序序列(从后往前遍历)
				for (int k = j - gap; k >= 0; k -= gap)
				{
					if (tmp < array[k])
					{
						// 后移
						array[k + gap] = array[k];
						// 位置
						index = k;
					}
					else
					{
						break;
					}
				}
				// 填坑
				array[index] = tmp;
			}
		}
	}
}

#if 0
void main()
{
	int i;
	//定义整型数组
	int array[] = { 12, 5, 33, 6, 10 };
	//计算数组长度
	int len = sizeof(array) / sizeof(int);
	//遍历数组
	printf("待排序数组序列: ");
	for (int i = 0; i < len; ++i)
	{
		printf("%d\t", array[i]);
	}
	printf("\n");

	//排序
	shellSort(array, len);

	//遍历
	printf("希尔排序之后的序列:	");
	for (i = 0; i < len; ++i)
	{
		printf("%d\t", array[i]);
	}
	printf("\n");
	system("pause");
}
#endif

5 快速排序

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

//快速排序
void quickSort(int s[], int l, int r)
{
	if (l < r)
	{
		int i = l, j = r;
		// 拿出第一个元素, 保存到x中,第一个位置成为一个坑
		int x = s[l];
		while (i < j)
		{
			// 从右向左找小于x的数
			while (i < j && s[j] >= x)
			{
				//左移, 直到遇到小于等于x的数
				j--;
			}
			if (i < j)
			{
				//将右侧找到的小于x的元素放入左侧坑中, 右侧出现一个坑
				//左侧元素索引后移
				s[i++] = s[j];
			}

			// 从左向右找大于等于x的数
			while (i < j && s[i] < x)
			{
				//右移, 直到遇到大于x的数
				i++;
			}
			if (i < j)
			{
				//将左侧找到的元素放入右侧坑中, 左侧出现一个坑
				//右侧元素索引向前移动
				s[j--] = s[i];
			}
		}
		//此时 i=j,将保存在x中的数填入坑中
		s[i] = x;
		quickSort(s, l, i - 1); // 递归调用 
		quickSort(s, i + 1, r);
	}
}

#if 0
void main()
{
	int i;
	//定义整型数组
	int array[] = { 12, 5, 33, 6, 10 };
	//计算数组长度
	int len = sizeof(array) / sizeof(int);
	//遍历数组
	printf("待排序数组序列: ");
	for (i = 0; i < len; ++i)
	{
		printf("%d\t", array[i]);
	}
	printf("\n");

	//排序
	quickSort(array, 0, len-1);

	//遍历
	printf("快速排序之后的序列:	");
	for (i = 0; i < len; ++i)
	{
		printf("%d\t", array[i]);
	}
	printf("\n");
	system("pause");
}
#endif

6 归并排序

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

//快速排序
void quickSort(int s[], int l, int r)
{
	if (l < r)
	{
		int i = l, j = r;
		// 拿出第一个元素, 保存到x中,第一个位置成为一个坑
		int x = s[l];
		while (i < j)
		{
			// 从右向左找小于x的数
			while (i < j && s[j] >= x)
			{
				//左移, 直到遇到小于等于x的数
				j--;
			}
			if (i < j)
			{
				//将右侧找到的小于x的元素放入左侧坑中, 右侧出现一个坑
				//左侧元素索引后移
				s[i++] = s[j];
			}

			// 从左向右找大于等于x的数
			while (i < j && s[i] < x)
			{
				//右移, 直到遇到大于x的数
				i++;
			}
			if (i < j)
			{
				//将左侧找到的元素放入右侧坑中, 左侧出现一个坑
				//右侧元素索引向前移动
				s[j--] = s[i];
			}
		}
		//此时 i=j,将保存在x中的数填入坑中
		s[i] = x;
		quickSort(s, l, i - 1); // 递归调用 
		quickSort(s, i + 1, r);
	}
}

#if 0
void main()
{
	int i;
	//定义整型数组
	int array[] = { 12, 5, 33, 6, 10 };
	//计算数组长度
	int len = sizeof(array) / sizeof(int);
	//遍历数组
	printf("待排序数组序列: ");
	for (i = 0; i < len; ++i)
	{
		printf("%d\t", array[i]);
	}
	printf("\n");

	//排序
	quickSort(array, 0, len-1);

	//遍历
	printf("快速排序之后的序列:	");
	for (i = 0; i < len; ++i)
	{
		printf("%d\t", array[i]);
	}
	printf("\n");
	system("pause");
}
#endif

7 算法比较

在这里插入图片描述

HowDonew
关注
专栏目录
一篇文章搞定Java中常用集合的排序方法
aqin1012的博客
06-07 5750
最近在做算法题的时候，发现排序在大部分题中都不可或缺，今天心血来潮，总结下Java中集合排序常用的方法，基本覆盖了大部分的排序场景（特别是自定义比较器，太好用叻(￣▽￣)/）文中提到的自然顺序排序，对于可比较大小的数据类型，一般按照从小到大的顺序，无法比较大小的，一般指按字典序升序排列。
选择法和插入法排序框架
嵌入式
09-23 155
#include <stdio.h> #include <stdlib.h> /*-------------------- 排序规则 -------------------- 它的工作原理是每一次从待排序的数据元素中选出 最小（或最大）的一个元素，存放在序列的起始位 置，直到全部待排序的数据元素排完。 稳定性:选择排序是不稳定的排序方法 如:[5,5,3] -------------------------------------------------*/
选择法排序
Jijiahao95的博客
10-25 314
/***************************************************** copyright (C), 2014-2015, Lighting Studio. Co.,     Ltd. File name： Author：Jerey_Jobs    Version:0.1    Date: Description： Funcion List:
插入排序与冒泡排序集合框架实现
超威半导体
09-02 487
插入排序与冒泡排序的实现：import java.util.ArrayList;/** @author:micro_hz 2015年9月2日 */ public class Order { /* * 插入排序,升序 */ public static ArrayList<Integer> insertSortAsc(ArrayList<Integer> array
插入排序、冒泡排序、选择排序、希尔排序、堆排序、快速排序、归并排序
最新发布
qq_56324572的博客
01-07 591
对一个区间的元素进行排序，在这个区间中任选一个元素（一般挑区间最边上的元素--最右边的， pivot ），遍历整个待排序区间，将每个元素都和 pivot 作比较（=），同时把 pivot 放到合适的位置，要求所有（= pivot ）的元素都在 pivot 右边。无序区间少了一个元素，有序区间多了一个元素。[无序区间] [有序区间] 中，将无序区间维护成一个大堆（从小到大排序，需要大堆），利用大堆从无序区间中找到最大值，交换。
排序的常见的三种方法 冒泡法 选择法 插入法
cheng_14的博客
05-23 266
冒泡法 int tmp; for (int i = 0; i < arr.length-1; i++) { for (int j = 0; j < arr.length-1-i; j++) { if (arr[j]>arr[j+1]) { tmp=arr[j]; arr[j]=arr[j+1]; arr[j+1]=tmp; } } } 选择法 选择排序就是从第一趟开始，用第一个元素和剩下中的每一个元素比较， 如果比第一
JavaScript自定义数组排序方法
12-11
本文实例讲述了JavaScript自定义数组排序方法。分享给大家供大家参考。具体分析如下： Array中有自带的排序功能，这个使用起来比较方便，我们有一点必须清楚，就是排序的依据，如果sort不传入参数的话，那就是按照...
java调用排序方法有哪些_四种排序方法用java实现
weixin_42362491的博客
02-13 1124
用三种方法实现几个数的排序：冒泡排序，选择排序，调用Java里的库函数1、冒泡排序：顾名思义，就是将小的数一步一步往上冒，大的数一个个往下沉，下面是自己写的对冒泡排序的理解，字丑将就看一下吧。2、选择排序：以从小到大为例，定义一个变量min_inter，用于记录最小值的下标，找到最小的数放在第0位，第二小放在第1位，后面依次。3、直接调用：Arrays.sort(num3)；需要导入import...
JS数组排序方法实例分析
01-19
本文实例讲述了JS数组排序方法。分享给大家供大家参考，具体如下： 方法一.冒泡排序 思路：依次比较数组中的第一个元素和第二个元素，如果第一个元素大于第二个元素，则交换位置，所以需要两个函数：交换位置函数和...
PHP实现基数排序的方法详解
01-20
本文实例讲述了PHP实现基数排序的方法。分享给大家供大家参考，具体如下： 基数排序是根据关键字中各位的值，通过对排序的N个元素进行若干趟“分配”与“收集”来实现排序的。 不妨通过一个具体的实例来展示一下，...
c实现数据结构中选择插入法
dabing113的博客
12-17 270
#include <stdio.h> void print(int k[],int n); void xuanzecharu(int k[],int n); int main(){ int K[]= {49,38,97,76,65,13,27,50}; xuanzecharu(K,8); print(K,8); } //选择插入法 void xuanzecha...
算法与数据结构系列 ( 三 ) - 选择排序法 - Select Sort
weixin_43814458的博客
05-05 235
前言 首先我们玩的是比较经典的选择排序 选择排序也是我们本系列的第一个O(n^2)算法 很多人认为最优的算法是O(n log n)级别的算法 这样就衍生出了一个问题 为什么要学习O(n^2)级别的算法？ 基础： O(n^2)相对而言比较基础，由简入难。很多时候我们做项目，或者是做其他业务的时候。我们可能找不到最优的解决办法，但是我们肯定会一种最简单的办法。我们先将功能...
冒泡法、选择法、插入法排序详解
西小庄村高伟 的博客
06-17 645
文章目录冒泡、选择、插入法排序详解冒泡法排序算法详解算法代码算法详细排序演示选择法排序算法详解算法代码算法详细排序演示插入法排序算法详解算法代码算法详细排序演示总结 冒泡、选择、插入法排序详解 冒泡法排序 冒泡法排序，见名思义，就是像吐泡泡一样，一个个泡泡按照应有的顺序吐到水面上，直至排序完成。 算法详解 对数组中的元素从前到后进行两两比较交换(0和1，1和2，2和3，…n-1和n)，每次完成这样的一种操作，根据具体的条件，最大值或最小值已被挪至最后元素，根据n-1次循环完成对数组排序。 算法代码 //冒泡
三种排序方法：选择排序法、冒泡排序法、插入排序法
zhangruotong的博客
03-21 3113
三种排序方法：选择、冒泡、插入排序法简单介绍概括
选择排序和插入排序的区别
Cookie1997的小屋
03-08 3069
很多人在学排序算法时，都接触到选择排序法和插入排序法，然而很多人对这两个排序法，分别是怎样的，又有什么细微的区别，却不了解。选择排序原理：主要在选择上，每一次从无序队列中选择出最小值，然后将其放置在有序队列的末尾，然后在无序队列中将其删除。插入排序原理：默认第一个元素为有序，后面的逐个向有序中插入，特点就是不断的移动数据，一直到排出序列。...
C语言中冒泡法、选择法、插入法三种常见排序算法分析
04-19 8868
一、冒泡法（起泡法）  算法要求：用起泡法对10个整数按升序排序。     算法分析：如果有n个数，则要进行n-1趟比较。在第1趟比较中要进行n-1次相邻元素的两两比较，在第j趟比较中要进行n-j次两两比较。比较的顺序从前往后，经过一趟比较后，将最值沉底（换到最后一个元素位置），最大值沉底为升序，最小值沉底为降序。     算法源代码： # include  main() {   i
插入法、选择法、冒泡法（C++实现）
stevanxiao的博客
09-01 1469
#include #include using namespace std; //插入法排序 void InsertSort(int arr[],int num) { for (int i=1;i<num;i++) //需要插入num-1次 { int temp = arr[i];//待插入的元素 //在有序区域查找插入的位置 int j = i-1; //用于标志插入的
经典排序算法_我的总结
weixin_44772874的博客
07-30 249
经典排序算法总结 比较类排序： 通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。 非比较类排序： 不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。 算法复杂度： 稳定： 如果a原本在b前面，而a=b，排序之后a仍然在b的前面。 不稳定： 如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b 的后面。 时间复杂度： 对排序数据的总的操作次数。反映当n变化时，操作次数呈现什
快速排序原理与内部排序方法解析
排序方法有很多种，根据不同的工作原理可以分为以下几类： - 插入排序：直接插入排序是将新元素插入到已排序的序列中的适当位置；希尔排序是插入排序的改进版，通过间隔序列的插入减少比较次数；折半插入排序则是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值