排序

最新推荐文章于 2022-04-12 10:45:47 发布
最新推荐文章于 2022-04-12 10:45:47 发布
阅读量807 收藏 1
点赞数
分类专栏： c++ 文章标签： 算法 struct insert c qt 测试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cddchina/article/details/7660678
版权 
#include<iostream>
#include<string.h>
#include<math.h>
using namespace std;

int EQ(int a,int b)
{ return a==b?1:0;}
int LT(int a,int b)
{ return a<b ?1:0;}
int LQ(int a,int b)
{ return a<=b?1:0;}

#define MAXSIZE 50
typedef struct
{
	int key;  //关键字项
	int other;//其他数据项
}RedType;

typedef struct
{
	RedType r[MAXSIZE+1];//r[0]闲置或者作为哨兵单元
	int length;
}SqList; //顺序表类型

//顺序表的建立
void CreateSqList(SqList &L)
{
	cout<<"请输入顺序表的长度：";
	cin>>L.length;
	int i;
	cout<<"请输入"<<L.length<<"个元素：";
	for(i=1;i<=L.length;i++)
		cin>>L.r[i].key;
}

//简单选择排序
int SelectMinKey(SqList &L,int i)
{ 
	int j,t,min=L.r[i].key;
	t=i;
	for(j=i;j<=L.length;j++)
		if(LT(L.r[j].key,min))
		{
			min=L.r[j].key;
			t=j;
		}
		return t;		
}
void SelectSort(SqList &L)
{
	int i,j,t;
	for(i=1;i<L.length;i++)
	{
		j=SelectMinKey(L,i);//在L.r[i...L.length]中选择key的最小记录
		if(i!=j)//与第i个记录交换
		{t=L.r[i].key ; L.r[i].key=L.r[j].key;  L.r[j].key=t;}
	}
}

//直接插入排序
void InsertSort(SqList &L)
{ 
	int i,j;
	for(i=2;i<=L.length;i++)
		if(	LT(L.r[i].key,L.r[i-1].key) )//需要将L.r[i]插入有序子表
		{
			L.r[0]=L.r[i];   //复制为哨兵
			L.r[i]=L.r[i-1];
			for(j=i-2; LT(L.r[0].key,L.r[j].key );  j--)
				L.r[j+1]=L.r[j];  //记录后移
			L.r[j+1]=L.r[0];      //插入
		}
}

//冒泡排序
void BubbleSort(SqList &L)
{
	int i,j,temp;
	for(i=1;i<L.length;i++)
		for(j=1;j<=L.length-i;j++)
			if(LT(L.r[j+1].key,L.r[j].key))
			{temp=L.r[j].key;  L.r[j].key=L.r[j+1].key;  L.r[j+1].key=temp;  }
}

//输出顺序表
void print(SqList L)
{ 
	int i;
	cout<<"排序输出为:";
	for(i=1;i<=L.length;i++)
		cout<<L.r[i].key<<"  ";
	cout<<endl;
}


//希尔排序
void ShellInsert(SqList &L,int dk) // 对顺序表L做一趟希尔排序。r[0]只是暂存单元，不是哨兵。当j<=0时，插入位置已找到
{ 
	int i,j;
	for(i=dk+1;i<=L.length;i++)
		if(LT(L.r[i].key,L.r[i-dk].key))//将L.r[i]插入有序增量子表
		{
			L.r[0]=L.r[i];                //暂时存在r[0]
			for(j=i-dk;  j>0&<(L.r[0].key,L.r[j].key);  j-=dk)
				L.r[j+dk]=L.r[j];         //记录后移，直接插入位置
			L.r[j+dk]=L.r[0];             //插入
		}
}
void ShellSort(SqList &L)
{
	int k,i,t;
	t=(int)log((double)(L.length-1));
	int dlta[MAXSIZE];
	for(k=0;k<t;k++)
	{
		dlta[k]=1;
		for(i=1;i<=t-k;i++)
			dlta[k]=2*dlta[k];
		dlta[k]+=1;
	}
    dlta[k]=1;
	for(k=0;k<=t;k++)
		ShellInsert(L,dlta[k]);	
}

//快速排序
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)      //长度大于1
	{
		int pivotloc=Partition(L,low,high);
		QSort(L,low,pivotloc-1);
		QSort(L,pivotloc+1,high);
	}
}
void QuickSort(SqList &L)
{
	QSort(L,1,L.length);
}

//堆排
void HeapAdjust (SqList &H,int s,int m)
{
	RedType rc=H.r[s];
	int j;
	for(j=2*s;j<=m;j*=2)
	{
		if(j<m && LT(H.r[j].key,H.r[j+1].key))
			j++;
		if(!LT(rc.key,H.r[j].key)) break;
		H.r[s]=H.r[j];
		s=j;
	}
	H.r[s]=rc;
}
void HeapSort(SqList &H)
{
	int i;RedType temp;
	for(i=H.length/2;i>0;i--)
		HeapAdjust(H,i,H.length);
	for(i=H.length;i>1;i--)
	{
		{temp=H.r[1];  H.r[1]=H.r[i];  H.r[i]=temp;  }
		HeapAdjust(H,1,i-1);
	}
	
	
}


//链式操作----------------------

int ListLength;
typedef struct node
{
	int key;
	struct node *next;
}node,*LinkList;


LinkList CreatNode()
{
	LinkList p;
	p=(LinkList)malloc(sizeof(node));
	p->next=NULL;
	return p;
}
//数据的输入
void CreatList(LinkList &head)
{
	int i,key;
	cout<<"输入链表的长度：";
	cin>>ListLength;
	cout<<"请输入"<<ListLength<<"个元素：";
	LinkList p,q;
	p=head;
	for(i=0;i<ListLength;i++)
	{
		cin>>key;
		q=CreatNode();
		q->key=key;
		p->next=q;
		p=p->next;
	}
}


//链式输出
void printt(LinkList &head)
{ 
	LinkList p;
	p=head->next;
	while(p)
	{
		cout<<p->key<<"  ";
		p=p->next;
	}
	cout<<endl;
}

//简单的选择排序

int SMinKey(LinkList &head,int i)
{
	int count,j,min;
	LinkList p;
	p=head->next;
	
	for(j=1;j<i;j++)
		p=p->next;
	count=i;
	min=p->key;
	while(p)
	{
		if(LT(p->key,min))
		{min=p->key;  count=i;} 
		p=p->next; i++;
	}
    return count;
}
LinkList DeList(LinkList &head,int j)
{
	int k;
	LinkList t,q;
	t=head;
	for(k=1;k<j;k++)
		t=t->next;
	q=t->next;
	t->next=t->next->next;
	return q;
}
void SelectSort2(LinkList &head)
{
	int i,j;
	LinkList p;
	LinkList q;
	p=head;
	for(i=1;i<ListLength;i++)
	{ 
		j=SMinKey(head,i);
		if(i!=j)
		{
			
			q=DeList(head,j);
			q->next=p->next;
			p->next=q;
		}
		p=p->next;
	}
}

//链式直接插入排序

void Insert(LinkList &head,LinkList &q)
{
	LinkList p;
	p=head;
	while(p->next && LT( p->next->key,q->key ))
		p=p->next;
	
	if(!p->next)
	{
		p->next=q;
		q->next=NULL;
	}
	else
	{
		q->next=p->next;
		p->next=q;
	}
}

LinkList DelList(LinkList &head,int i)
{
	int k;
	LinkList t,q;
	t=head;
	for(k=1;k<i;k++)
		t=t->next;
	q=t->next;
	t->next=t->next->next;
	return q;
}
void InsertSort2(LinkList &head)
{
	int i;
	LinkList p;
	LinkList q;
	p=head;
	for(i=1;i<ListLength;i++)
	{ 
		q=DeList(head,i);
		Insert(head,q);
		p=p->next;
	}
}
//	


int main()
{ 
	
	LinkList Head;
	Head=CreatNode();
	
	int c1;
	cout<<"----------------欢迎进入排序界面--------------------"<<endl;
	cout<<"--------------------"<<endl;
	cout<<"|顺序表操作   选0  |"<<endl;
	cout<<"|链表操作     选1  |"<<endl;
	cout<<"|退出         选-1 |"<<endl;
	cout<<"--------------------"<<endl;
	while(cin>>c1)
	{ 
		if(c1==-1) break;
		else if(c1==0)
		{
			SqList L;
            
			int c2;
			cout<<"----------------------"<<endl;
			cout<<"|顺序表建立     选0  |"<<endl;
			cout<<"|顺序表简单排序 选1  |"<<endl;
			cout<<"|顺序表直插排序 选2  |"<<endl;
			cout<<"|顺序表冒泡排序 选3  |"<<endl;
			cout<<"|顺序表希尔排序 选4  |"<<endl;
			cout<<"|顺序表快速排序 选5  |"<<endl;
			cout<<"|顺序表堆排     选6  |"<<endl;
			cout<<"|顺序表输出     选7  |"<<endl;
			cout<<"|退出           选-1 |"<<endl;
			cout<<"----------------------"<<endl;
			while(cin>>c2)
			{
				
				if(c2==-1) break;
				else if(c2==0)
				{
					CreateSqList(L);
					cout<<"顺序表建立操作完毕"<<endl;
				}
				else if(c2==1)
				{
					SelectSort(L);
					cout<<"顺序表简单排序操作完毕"<<endl;
				}
				else if(c2==2)
				{
					InsertSort(L);cout<<"顺序表直插排序操作完毕"<<endl;
				}
				else if(c2==3)
				{
					BubbleSort(L);cout<<"顺序表冒泡排序操作完毕"<<endl;
				}
				else if(c2==4)
				{
					ShellSort(L);cout<<"顺序表希尔排序操作完毕"<<endl;
				}
				else if(c2==5)
				{
					QSort(L,1,L.length);cout<<"顺序表快速排序操作完毕"<<endl;
				}
				else if(c2==6)
				{
					HeapSort(L);cout<<"顺序表堆排操作完毕"<<endl;
					
				}
				else if(c2==7)
				{
					print(L);cout<<"顺序表输出操作完毕"<<endl;
				}
				cout<<"----------------------"<<endl;
				cout<<"|顺序表建立     选0  |"<<endl;
				cout<<"|顺序表简单排序 选1  |"<<endl;
				cout<<"|顺序表直插排序 选2  |"<<endl;
				cout<<"|顺序表冒泡排序 选3  |"<<endl;
				cout<<"|顺序表希尔排序 选4  |"<<endl;
				cout<<"|顺序表快速排序 选5  |"<<endl;
				cout<<"|顺序表堆排     选6  |"<<endl;
				cout<<"|顺序表输出     选7  |"<<endl;
				cout<<"|退出           选-1 |"<<endl;
				cout<<"----------------------"<<endl;
			}
			
			
			
		}
		else if(c1==1)
		{
			cout<<"--------------------"<<endl;
			cout<<"|链表建立     选1  |"<<endl;
			cout<<"|链表简单排序 选2  |"<<endl;
			cout<<"|链式直插排序 选3  |"<<endl;
			cout<<"|链式输出     选4  |"<<endl;
			cout<<"|退出         选-1 |"<<endl;
			cout<<"--------------------"<<endl;
			int c3;
			while(cin>>c3)
			{
				if(c3==-1)break;
				switch(c3)
				{
				case 1:CreatList(Head);cout<<"链表建立操作完毕"<<endl;break;
				case 2:SelectSort2(Head);cout<<"链表简单排序操作完毕"<<endl;break;
				case 3:InsertSort2(Head);cout<<"链式直插排序操作完毕"<<endl;break;
				case 4:printt(Head);cout<<"链式输出操作完毕"<<endl;break;
					
				}
				cout<<"--------------------"<<endl;
				cout<<"|链表建立     选1  |"<<endl;
				cout<<"|链表简单排序 选2  |"<<endl;
				cout<<"|链式直插排序 选3  |"<<endl;
				cout<<"|链式输出     选4  |"<<endl;
				cout<<"|退出         选-1 |"<<endl;
				cout<<"--------------------"<<endl;
			}	
		}
		
		cout<<"--------------------"<<endl;
		cout<<"|顺序表操作   选0  |"<<endl;
		cout<<"|链表操作     选1  |"<<endl;
		cout<<"|退出         选-1 |"<<endl;
		cout<<"--------------------"<<endl;
		
	}	
	cout<<"结束"<<endl;
	return 0;
}

// 9 5 6 8 0 1 7 2 3 4


输入一组关键字序列分别实现下列排序:

（1）实现简单选择排序、直接插入排序和冒泡排序。

（2）实现希尔排序算法。

（3）实现快速排序算法。

（4）实现堆排序算法。

（5）采用链式存储实现简单选择排序、直接插入排序和冒泡排序。

（6）在主函数中设计一个简单的菜单，分别测试上述算法。

 

综合训练：采用几组不同数据测试各个排序算法的性能（比较次数和移动次数）。

 

cddchina
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
7.6.1 内部排序算法的比较
12-05 1247
算法种类 最好情况 平均情况 最差情况 空间复杂度 是否稳定 直接插入排序 O(n) O(n^2) O(n^2) O(1) 是 冒泡排序 O(n) O(n^2) O(n^2) O(1) 是 简单选择排序 O(n^2) O(n^2) O(n^2) O(1) 否 希尔排序       O(1) 否 快速
排序查询
12-14
排序查询按单个字段排序按表达式 / 别名排序按函数排序按多个字段排序 排序查询：SELECT 查询列表 FROM 表 WHERE 筛选条件 ORDER BY 排序列表(ASC/DESC) AEC/DESC = 升序/降序，默认为升序 ORDER BY 支持单个字段、...
#排序算法#【2】直接插入排序、希尔排序
weixin_30929011的博客
05-27 85
直接插入排序法 　　插入排序的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，在从后向前扫描过程中，需要反复把已排序元素逐步向后移动，为最新元素提供插入空间。 　　 核心代码： //直接插入排序法 void InsertSort(int a[],int n){ ...
排序算法之直接插入排序和希尔排序
AndyJ的学习之旅
09-28 223
直接插入排序的基本操作是将一个记录插入到已经排好序的有序表中，从而得到一个新的，记录数增1的有序表，模仿扑克牌的思想。 看代码： def insert_sort(nums): n = len(nums) for i in range(1,n): if nums[i] < nums[i-1]: # 需要将nums[i]插入到有序子表中 temp = nums[i] # 设置哨兵 j = i - 1 w
【算法】排序1：直接插入排序、希尔排序、选择排序、堆排序
weixin_45177279的博客
05-24 1212
排序在许多地方都有应用，常见的排序算法可以分为插入排序、选择排序、交换排序、归并排序四类。 插入排序 插入排序又可以分为两种： ①直接插入排序 ②希尔排序 直接插入排序就是把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列，直接插入排序的时间复杂度为O(N^2) void InsertSort(int*a, int n) { //控制end的位置从2走到n-2 for (int i = 0; i < n - 1;++i) {
【直接插入排序、希尔排序，直接选择排序】（C语言实现）
langk_的博客
04-12 415
直接插入排序、希尔排序，选择排序一.直接插入排序 一.直接插入排序 图形演示： ✈✈✈第一趟排序 ✈✈✈第二趟排序 ✈✈✈第三趟排序 ✈✈✈第四趟排序 代码实现： //直接插入排序 void InserSort(int* a, int size) { for (int i = 0; i < size - 1; ++i) { int end = i; int tmp = a[end + 1]; while (end >= 0) { if (a[en
帆软：排序问题（通过帆软设置或者sql排序）
02-26
在数据分析和报表制作的过程中，排序是一项基础且至关重要的任务。帆软报表作为一款强大的报表工具，提供了多种排序方式，既能通过界面配置实现，也能通过SQL查询语句进行控制。本篇将详细介绍如何在帆软中处理排序...
排序动画一
02-12
选择排序是一种不稳定的排序算法，它的基本思想是在未排序的序列中找到最小（或最大）元素，放到排序序列的起始位置，然后再从剩余未排序的元素中继续寻找最小（或最大）元素，然后放到已排序序列的末尾。...
排序算法（直接插入排序、折半排序、直接选择排序、快速排序与归并排序）
04-04
提供五种排序算法的C++实现方法，输入（待排序元素个数、排序码上界（采用随机生成数组方式）），可选择输出（原始数组、排序后数组、原始数组有序度和无序度、排序过程中数据比较次数与数据移动次数、数组中出现...
关键字排序
06-02
多关键字排序
7.1_内部排序算法排序.CPP
10-29
1、常见排序算法实现（1-6选择几个算法练习） 1）问题描述：输入一组关键字序列分别实现下列排序。 （1）实现简单选择排序、直接插入排序和冒泡排序。 （2）实现希尔排序算法。 （3）实现折半插入排序。 （4）实现快速排序算法。 （5）实现堆排序算法。 （6）合并排序算法。 2) 实现提示： 数据输入后，每选择一种算法，把数据拷贝后再排序，保证原始数据不破坏.
姓名排序工具
07-12
姓名排序工具是一款专为行政事业单位设计的实用程序，旨在解决多个人名按特定规则排序的难题。在日常工作中，人员名单的整理与排列是一项频繁且重要的任务，手工操作不仅耗时，而且容易出现人为错误。这款小工具通过...
C语言几种排序代码
07-07
3. **插入排序**：将数组分为已排序和未排序两部分，每次取未排序部分的第一个元素，插入到已排序部分的合适位置。C语言中，这通常通过一次遍历已排序部分，比较新元素与已排序元素并调整位置来完成。 4. **快速...
希尔排序的算法代码
09-05
希尔排序也是一种插入排序方法,实际上是一种分组插入方法。
【排序算法】直接插入排序、希尔排序、冒泡排序、快速排序、归并排序
学无止境
05-16 1418
直接插入排序 、快速排序随机选择pivot 、插入排序基本思想实现算法分析希尔排序基本思想程序算法分析 注：本文实现升序排序 直接插入排序 基本思想 基本思想：保持左端的数字是有序的，将未进行操作过的右端的数字 value 与左端的进行比较，如果 左端 > value，则进行交换，重复进行比较，直到左端 < value 或者 value 到达最左端，重复相同的操作，直到所有的数字完成排序
排序算法系列1--简单排序（选择，冒泡，直接插入，希尔排序）
weixin_30332241的博客
10-03 753
排序是数据处理中十分常见的操作，现代高级语言都有现成的n种排序算法。但了解它们的代码，对计算机思维有帮助。 简单选择排序 每一趟从待排序的数据元素中选择最小（或最大）的一个元素作为首元素，直到所有元素排完为止，简单选择排序是不稳定排序。 无论数组原始排列如何，比较次数都不变；变的是交换次数。完全有序的情况下无需交换移动元素，最差情况下（把数组倒序改成正序），交换次数最多: n...
C语言实现直接插入排序算法
qq_40994908的博客
12-11 1365
编写函数InsSort(a, n)，完成对数组a[n]的直接插入排序。
各种内部排序算法的测试
雁城布衣
11-15 789
/* 各种内部排序算法的测试 */ #include #include #include //辅助函数 /* 产生size以内的size个随机数放到array中 */ static void random_access(int array[], int size); static void show_array(const int array[], int size); /* 1. 直接
Lecture+3-2+List结构的排序编程1
最新发布
08-04
1. 从有序数列和无序数列{a2,a3，…，an}开始进行排序 2. 处理第i个元素(i=2,3，…，n)时，数列{a1,a2，…，ai-1}是有序的，而数 3

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值