16.排序

最新推荐文章于 2022-06-18 15:27:55 发布
最新推荐文章于 2022-06-18 15:27:55 发布
阅读量489 收藏
点赞数 2
分类专栏： 数据结构 文章标签： 排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hyde100/article/details/52277862
版权

各种排序

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

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define N 9
#define MAXSIZE 9//用于要排序数组个数最大值，可根据需要修改

typedef int Status;

typedef struct
{
	int r[MAXSIZE+1];//用于存储要排序数组，r[0]用作哨兵或临时变量
	int length;//用于记录顺序表的长度
}SqList;

//交换L中数组r的下标为i和j的值
void swap(SqList *L,int i,int j)
{
	int temp=L->r[i];
	L->r[i]=L->r[j];
	L->r[j]=temp;
}

void print(SqList L)
{
	int i;
	for(i=1;i<=N;i++)
	{
		if(i!=N)
			printf("%d，",L.r[i]);
		else
			printf("%d\n",L.r[i]);
	}	
}

//对顺序表L作交换排序（冒泡排序初级版）
void BubbleSort0(SqList *L)
{
	int i,j;
	for(i=1;i<L->length;i++)
	{
		for(j=i+1;j<=L->length;j++)
		{
			if(L->r[i]>L->r[j])
				swap(L,i,j);//交换L->r[i]与L->r[j]的值
		}
	}
}

//对顺序表L作冒泡排序
void BubbleSort(SqList *L)
{
	int i,j;
	for(i=1;i<L->length;i++)
	{
		for(j=L->length-1;j>=i;j--)
		{
			if(L->r[j]>L->r[j+1])
				swap(L,j,j+1);//交换L->r[j]与L->r[j+1]的值
		}
	}
}

//对顺序表对顺序表L对顺序表L作改进冒泡算法
void BubbleSort2(SqList *L)
{
	int i,j;
	Status flag=TRUE;
	for(i=1;i<L->length && flag;i++)//若flag为true说明有过数据交换，否则说明已排好序停止循环
	{
		flag=FALSE;
		for(j=L->length-1;j>=i;j--)
		{
			if(L->r[j]>L->r[j+1])
			{
				swap(L,j,j+1);//交换L->r[j]与L->r[j+1]的值
				flag=TRUE;//如果有数据交换，则flag为true
			}
		}
	}
}

//对顺序表L作简单选择排序
void SelectSort(SqList *L)
{
	int i,j,min;
	for(i=1;i<L->length;i++)
	{
		min=i;//将当前下标定义为最小值下标
		for(j=i+1;j<=L->length;j++)
		{
			if(L->r[min]>L->r[j])//如果有小于当前最小值的关键字
				min=j;
		}
		if(i!=min)//若min不等于i，说明找到最小值，交换
			swap(L,i,min);//交换L->r[i]与L->r[min]的值
	}
}

//对顺序表L作直接插入排序
void InsertSort(SqList *L)
{
	int i,j;
	for(i=2;i<=L->length;i++)
	{
		if(L->r[i]<L->r[i-1])//需将L->r[i]插入有序子表
		{
			L->r[0]=L->r[i];//设置哨兵
			for(j=i-1;L->r[j]>L->r[0];j--)
				L->r[j+1]=L->r[j];//记录后移
			L->r[j+1]=L->r[0];//插入到正确位置
		}
	}
}

//对顺序表L作希尔排序
void ShellSort(SqList *L)
{
	int i,j,k=0;
	int increment=L->length;
	do
	{
		increment=increment/3+1;//增量序列
		for(i=increment+1;i<=L->length;i++)
		{
			if(L->r[i]<L->r[i-increment])//需将L->r[i]插入有序增量子表
			{
				L->r[0]=L->r[i];//暂存在L->r[0]
				for(j=i-increment;j>0&&L->r[0]<L->r[j];j-=increment)
				{
					L->r[j+increment]=L->r[j];//交换数据
				}
				L->r[j+increment]=L->r[0];
			}
		}
		printf("	第%d趟排序结果: ",++k);
		print(*L);
	}while(increment>1);
}

//已知L->r[s..m]中记录的关键字除L->r[s]之外均满足堆的定义，
//本函数调整L->r[s]的关键字,使L->r[s..m]成为一个大顶堆
void HeapAdjust(SqList *L,int s,int m)
{ 
	int temp,j;
	temp=L->r[s];
	for(j=2*s;j<=m;j*=2)//沿关键字较大的孩子结点向下筛选
	{
		if(j<m && L->r[j]<L->r[j+1])
			++j;//j为关键字中较大的记录的下标
		if(temp>=L->r[j])
			break;//rc应插入在位置s上
		L->r[s]=L->r[j];
		s=j;
	}
	L->r[s]=temp;//插入
}

//对顺序表L进行堆排序
void HeapSort(SqList *L)
{
	int i;
	for(i=L->length/2;i>0;i--)//把L中的r构建成一个大根堆
	{
		HeapAdjust(L,i,L->length);
	}

	for(i=L->length;i>1;i--)
	{
		swap(L,1,i);//将堆顶记录和当前未经排序子序列的最后一个记录交换
		HeapAdjust(L,1,i-1);//将L->r[1..i-1]重新调整为大根堆
	}
}

//将有序的SR[i..m]和SR[m+1..n]归并为有序的TR[i..n]
void Merge(int SR[],int TR[],int i,int m,int n)
{
	int j,k,l;
	for(j=m+1,k=i;i<=m && j<=n;k++)	//将SR中记录由小到大地并入TR
	{
		if (SR[i]<SR[j])
			TR[k]=SR[i++];
		else
			TR[k]=SR[j++];
	}
	if(i<=m)
	{
		for(l=0;l<=m-i;l++)
			TR[k+l]=SR[i+l];		//将剩余的SR[i..m]复制到TR
	}
	if(j<=n)
	{
		for(l=0;l<=n-j;l++)
			TR[k+l]=SR[j+l];		//将剩余的SR[j..n]复制到TR
	}
}

//递归法
//将SR[s..t]归并排序为TR1[s..t]
void MSort(int SR[],int TR1[],int s, int t)
{
	int m;
	int TR2[MAXSIZE+1];
	if(s==t)
		TR1[s]=SR[s];
	else
	{
		m=(s+t)/2;				//将SR[s..t]平分为SR[s..m]和SR[m+1..t]
		MSort(SR,TR2,s,m);		//递归地将SR[s..m]归并为有序的TR2[s..m]
		MSort(SR,TR2,m+1,t);	//递归地将SR[m+1..t]归并为有序的TR2[m+1..t]
		Merge(TR2,TR1,s,m,t);	//将TR2[s..m]和TR2[m+1..t]归并到TR1[s..t]
	}
}

//对顺序表L进行归并排序
void MergeSort(SqList *L)
{
	MSort(L->r,L->r,1,L->length);
}

//非递归法
//将SR[]中相邻长度为s的子序列两两归并到TR[]
void MergePass(int SR[],int TR[],int s,int n)
{
	int i=1;
	int j;
	while(i <= n-2*s+1)
	{//两两归并
		Merge(SR,TR,i,i+s-1,i+2*s-1);
		i=i+2*s;        
	}
	if(i<n-s+1) //归并最后两个序列
		Merge(SR,TR,i,i+s-1,n);
	else //若最后只剩下单个子序列
		for(j =i;j <= n;j++)
			TR[j] = SR[j];
}

//对顺序表L作归并非递归排序
void MergeSort2(SqList *L)
{
	int* TR=(int*)malloc(L->length * sizeof(int));//申请额外空间
    int k=1;
	while(k<L->length)
	{
		MergePass(L->r,TR,k,L->length);
		k=2*k;//子序列长度加倍
		MergePass(TR,L->r,k,L->length);
		k=2*k;//子序列长度加倍     
	}
}

//交换顺序表L中子表的记录，使枢轴记录到位，并返回其所在位置
//此时在它之前(后)的记录均不大(小)于它。
int Partition(SqList *L,int low,int high)
{ 
	int pivotkey;

	pivotkey=L->r[low];//用子表的第一个记录作枢轴记录
	while(low<high)//从表的两端交替地向中间扫描
	{ 
		 while(low<high&&L->r[high]>=pivotkey)
			high--;
		 swap(L,low,high);//将比枢轴记录小的记录交换到低端
		 while(low<high&&L->r[low]<=pivotkey)
			low++;
		 swap(L,low,high);//将比枢轴记录大的记录交换到高端
	}
	return low;//返回枢轴所在位置
}

//对顺序表L中的子序列L->r[low..high]作快速排序
void QSort(SqList *L,int low,int high)
{
	int pivot;
	if(low<high)
	{
		pivot=Partition(L,low,high);//将L->r[low..high]一分为二，算出枢轴值pivot
		QSort(L,low,pivot-1);//对低子表递归排序
		QSort(L,pivot+1,high);//对高子表递归排序
	}
}

//对顺序表L作快速排序
void QuickSort(SqList *L)
{
	QSort(L,1,L->length);
}

#define MAX_LENGTH_INSERT_SORT 7 /* 用于快速排序时判断是否选用插入排序阙值 */

/* 快速排序优化算法 */
int Partition2(SqList *L,int low,int high)
{ 
	int pivotkey;

	int m = low + (high - low) / 2; /* 计算数组中间的元素的下标 */  
	if (L->r[low]>L->r[high])			
		swap(L,low,high);	/* 交换左端与右端数据，保证左端较小 */
	if (L->r[m]>L->r[high])
		swap(L,high,m);		/* 交换中间与右端数据，保证中间较小 */
	if (L->r[m]>L->r[low])
		swap(L,m,low);		/* 交换中间与左端数据，保证左端较小 */
	
	pivotkey=L->r[low]; /* 用子表的第一个记录作枢轴记录 */
	L->r[0]=pivotkey;  /* 将枢轴关键字备份到L->r[0] */
	while(low<high) /*  从表的两端交替地向中间扫描 */
	{ 
		 while(low<high&&L->r[high]>=pivotkey)
			high--;
		 L->r[low]=L->r[high];
		 while(low<high&&L->r[low]<=pivotkey)
			low++;
		 L->r[high]=L->r[low];
	}
	L->r[low]=L->r[0];
	return low; /* 返回枢轴所在位置 */
}

void QSort2(SqList *L,int low,int high)
{ 
	int pivot;
	if((high-low)>MAX_LENGTH_INSERT_SORT)
	{
		while(low<high)
		{
			pivot=Partition2(L,low,high); /*  将L->r[low..high]一分为二，算出枢轴值pivot */
			QSort2(L,low,pivot-1);		/*  对低子表递归排序 */
			//QSort2(L,pivot+1,high);		/*  对高子表递归排序 */
			low=pivot+1;	/* 尾递归 */
		}
	}
	else
		InsertSort(L);
}

//对顺序表L作快速排序
void QuickSort2(SqList *L)
{
	QSort2(L,1,L->length);
}

int main()
{
	int i;
	//int d[N]={9,1,5,8,3,7,4,6,2};
	//int d[N]={2,1,3,4,5,6,7,8,9};
	int d[N]={50,10,90,30,70,40,80,60,20};

	SqList L0,L1,L2,L3,L4,L5,L6,L7,L8,L9,L10;
	for(i=1;i<=N;i++)
		L0.r[i]=d[i-1];
	L0.length=N;

	L10=L9=L8=L7=L6=L5=L4=L3=L2=L1=L0;

	printf("排序前:\n");
	print(L0);

	printf("初级冒泡排序:\n");
    BubbleSort0(&L0);
    print(L0);

	printf("冒泡排序:\n");
	BubbleSort(&L1);
	print(L1);

	printf("改进冒泡排序:\n");
	BubbleSort2(&L2);
	print(L2);

	printf("选择排序:\n");
	SelectSort(&L3);
	print(L3);

	printf("直接插入排序:\n");
    InsertSort(&L4);
    print(L4);

	printf("希尔排序:\n");
    ShellSort(&L5);
    print(L5);

	printf("堆排序:\n");
    HeapSort(&L6);
    print(L6);

	printf("归并排序（递归）:\n");
    MergeSort(&L7);
    print(L7);

	printf("归并排序（非递归）:\n");
    MergeSort2(&L8);
    print(L8);

	printf("快速排序:\n");
	QuickSort(&L9);
	print(L9);

	printf("改进快速排序:\n");
	QuickSort2(&L10);
	print(L10);

	return 0;
}


hyde100
关注
专栏目录
十大排序算法
个人站点：javatv.net
08-20 2万+
冒泡排序 从数组头开始，比较相邻的元素。如果第一个比第二个大(小)，就交换它们两个 对每一对相邻元素作同样的工作，从开始第一对到尾部的最后一对，这样在最后的元素应该会是最大(小)的数 重复步骤1~2，重复次数等于数组的长度，直到排序完成 代码实现 对下面数组实现排序：{24, 7, 43, 78, 62, 98, 82, 18, 54, 37, 73, 9} 代码实现 public class BubbleSort { public static final int[] ARRAY = {2
C语言—冒泡排序
xianming_flag的博客
11-30 23万+
C语言排序算法-冒泡排序 从键盘输入的10个整数按从小到大的顺序排序后输出 #include<stdio.h> void main() { int n[10] = { 25,35,68,79,21,13,98,7,16,62 };//定义一个大小为10的数组 int i, j, temp; for (i = 1; i <= 9; i++)//外层循环是比较的轮数，数组内有10个数，那么就应该比较10-1=9轮 { for (j = 0; j <= 9 - i; j++)
Collections.sort排序
迟到的二货
01-21 3797
一，Collections.sort的简单排序 TestCollections.java import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.List; public class TestCollections implements
【算法设计与分析】1.排序算法性能分析
深大cs课程实验及学习笔记，ccfcsp部分真题，华为题库
06-18 1685
1. 选择排序、冒泡排序、合并排序、快速排序、插入排序算法原理 2. 不同排序算法时间效率的经验分析方法，验证理论分析与经验分析的一致性。
[Java教程]16.数组的排序算法
砷碲 - Shendi
06-13 7181
Java教程专栏:https://blog.csdn.net/qq_41806966/category_9929686.html hello,I'm shendi 本节学习如何让 int 类型数组排序 目录 排序 冒泡排序 选择排序 插入排序 睡眠排序 练习 排序 排序是指将一堆元素按照一定的规则进行排列. 例如一堆数字,我们可以由大到小或者由小到大进行排序 之前学过数组,现在我们就来学习一下 int 类型的数字进行排序(由大到小,由小到大) ---不会排序的等价于没..
C# List.Sort排序
Peter的博客
03-08 1万+
C#中，List.Sort() 不仅为我们提供了默认的排序方法，还为我们提供了4种自定义排序的方法，通过默认排序方法，我们无需重写任何Sort()方法的实现代码，就能对单参数类型的List数据进行单一规则的排序，如果通过对这些方法进行改进我们可以轻松做到对多参数、多规则的复杂排序。 默认排序 排序Sort,倒序Reverse //默认是元素第一个字母按升序 list.Sort(); //将List里面元素顺序反转 list.Reverse(); //从第二个元素开始，反转4个元素 //结果list.
java实现10种排序算法
weixin_622464的博客
05-06 7万+
1.冒泡排序(Bubble Sort) import java.util.Arrays; //冒泡排序 public class BubbleSort_01 { public static void main(String[] args) { int a[]={3,44,38,5,47,15,36,26,27,2,46,4,19,50,48}; //记录比较次数 int count=0; //i=0,第一轮比较 for (int i = 0; i < a.length-1; i
经典十大排序算法（含升序降序，基数排序含负数排序）【Java版完整代码】【建议收藏系列】
『愚』的博客
06-24 3万+
经典十大排序算法【Java版完整代码】写在前面的话十大排序算法对比冒泡排序快速排序直接选择排序堆排序归并排序插入排序希尔排序计数排序桶排序基数排序 写在前面的话        虽然已经有很多人总结过这十大排序算法，优秀的文章也不少，但是Java完整版的好像不多，还存在某些文章代码存在错误的情况，同时也为了自己练手，决定把所有的写一遍巩固下，同时也真诚的希望阅读到这篇文章的小伙伴们可以自己去从头敲一遍，不要粘贴复制！希望我的文章对你有所帮助
快速排序（过程图解）
热门推荐
第一楼主的博客
07-02 41万+
假设我们现在对“612 79345 108”这个10个数进行排序。首先在这个序列中随便找一个数作为基准数（不要被这个名词吓到了，就是一个用来参照的数，待会你就知道它用来做啥的了）。为了方便，就让第一个数6作为基准数吧。接下来，需要将这个序列中所有比基准数大的数放在6的右边，比基准数小的数放在6的左边，类似下面这种排列。 312 5469 ...
十大经典排序算法-归并排序算法详解
qq_35344198的博客
06-19 12万+
一、什么是归并排序 1.概念 归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法，归并排序对序列的元素进行逐层折半分组，然后从最小分组开始比较排序，合并成一个大的分组，逐层进行，最终所有的元素都是有序的 2.算法原理 这是一个无序数列：4、5、8、1、7、2、6、3，我们要将它按从小到大排序。按照归并排序的思想，我们要把序列逐层进行拆分 序列逐层拆分如下 然后从下往上逐层合并，首先对第一层序列1（只包含元素4）和序列2（只包含元素5）进行合并 创建一个大序列，序列长度为两个小序列长度
项目示例 1. 矩阵操作 2. 线性回归 3. 斐波那契数列 4. 排序算法 5. 数值积分 1. 矩阵操作 项目描述 创建一个
最新发布
09-14
4. 排序算法 5. 数值积分 1. 矩阵操作 项目描述 创建一个 J 程序，用于实现矩阵的基本操作，如矩阵加法、矩阵乘法、转置等。 实现步骤 j 深色版本 1NB. 定义矩阵加法 2matrix_add=: + 3 4NB. 定义矩阵乘法 5matrix_...
插入排序-16-内连接查询.ev4.rar
06-05
在压缩包内的"插入排序-16-内连接查询.ev4.mp4"文件中，很可能是通过视频教学的形式，结合实例演示了如何运用插入排序算法和内连接查询来解决实际问题，帮助学习者更好地理解和应用这些技术。观看这样的学习资源，...
Vb.netDataTable排序、检索、合并[归纳].pdf
10-20
For i As Int16 = 0 To ReSearchDR.Length - 1 ReSearchDT.ImportRow(ReSearchDR(i)) Next Return ReSearchDT End Function ``` 在上面的代码中，我们使用Select方法来实现查询操作，并将查询结果存储到一个新...
洛谷P4715 【深基16.例1】淘汰赛超短题解
08-04
题解共十四行，应该是全网最短了的吧。 如果有更短的，欢迎在评论区下方发出题解！
01.线性表.顺序存储结构（静态数组）
hyde100的专栏
07-07 1734
最近在重新温习数据结构的知识，根据资料及自己的理解使用C语言编写调试了以下的代码， 以下为第一篇“线性表顺序存储结构”，利用数组实现。 #include #define MAXSIZE 15//符号常量，代表线性表存储空间初始分配量 #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 typedef int ElemTy
03.线性表.顺序存储结构（动态数组）
hyde100的专栏
07-12 1010
以下是用动态数组实现的线性表顺序存储 #include #include #define LIST_INIT_SIZE 5//符号常量，代表线性表存储空间初始分配量 #define LIST_INCREMENT 10//符号常量，代表线性表存储空间的分配增量 #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 type
04.线性表.链式存储结构（双向循环链表）
hyde100的专栏
07-15 734
以下是用双向循环链表实现的线性表 #include #include #include #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 typedef int ElemType;//ElemType这里假设为int，可以根据需要进行更改 typedef int Status;//Status是函数的类型,其值是函数
14.B树
hyde100的专栏
08-04 701
B树
16进制的list排序
09-13
要对一个16进制的列表进行排序，可以按照以下步骤进行操作： 1. 首先，我们需要将列表中的每个元素转换为对应的十进制数值。根据引用的建议，可以使用一个字典来存储每个16进制元素对应的十进制值。可以使用如下代码将列表转换为字典，并按照值进行排序： ``` hex_dict = {i: int(i, 16) for i in hex_list} sorted_dict = dict(sorted(hex_dict.items(), key=lambda item: item
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值