排序问题(数据结构）.

于 2021-12-07 19:28:26 发布
阅读量396 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cnsa183_20/article/details/121776679
版权 
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define LISTINCREAMENT 5
#define LISTINITSIZE 20
#define ERROR 0
#define OK 1
#define N 5 
typedef int ElemType;
typedef struct
{
	ElemType *elem;
	int length;
	int listsize;
}SeqList;
int ListLength(SeqList L);                                      /*顺序表的长度*/
int InitList(SeqList *L);                                     /*顺序表的初始化*/
int InsertElem(SeqList *L,int i,ElemType e);                  /*顺序表的插入算法*/
int DeleteElem(SeqList *L,int i,ElemType e);                  /*顺序表的删除算法*/ 
int LocateElem(SeqList L,ElemType e);                         /*顺序表中数据元素的定位算法*/
int GetElem(SeqList *L,int i,ElemType e);                     /*顺序表中的取元素操作*/
int PriorElem(SeqList L,ElemType e,ElemType *pre_e);          /*顺序表中求元素前驱结点操作*/
int NextElem(SeqList L,ElemType e,ElemType *pre_e);           /*顺序表中求元素后继结点操作*/
void PrintList(SeqList L);                                    /*打印顺序表信息操作*/
void SymmetricDifference(SeqList *La,SeqList Lb);             /*完成集合A=(A-B)U(B-A)运算算法*/
void MergeList(SeqList *Lc,SeqList La,SeqList Lb);				/*两个有序表合并成一个新有序表的算法*/
void InsertSort(SeqList *L);									/*直接插入排序算法*/ 
void BinSort(SeqList *L);										/*折半插入排序算法*/
void ShellSort(SeqList *L);										/*希尔排序算法*/
/*顺序表的初始化*/
int InitList(SeqList *L)
{
	L->elem=(ElemType *)malloc(sizeof(ElemType)*LISTINITSIZE);
	if(!(L->elem))
	return ERROR;
	L->length=0;
	L->listsize=LISTINITSIZE;
	return OK;
 } 
 /*顺序表的插入算法*/ 
 int InsertElem(SeqList *L,int i,ElemType e)
{
	int j,newsize;
	ElemType *newbase;
	if(i<1||i>L->length+1)
	return ERROR;
	if(L->length>=L->listsize)
	{
		newsize=(L->listsize+LISTINCREAMENT)*sizeof(ElemType);
		newbase=(ElemType *)realloc(L->elem,newsize);
		if(!(newbase))
		return ERROR;
		L->elem=newbase;
		L->listsize+=LISTINCREAMENT; 
	}
	for(j=L->length-1;j>=i-1;j--)
	L->elem[j+1]=L->elem[j];
	L->elem[i-1]=e;
	L->length++;
	return OK; 
 } 
 /*顺序表的删除算法*/ 
 int DeleteElem(SeqList *L,int i,ElemType *e)
{
	int j;
	if(i<=0||i>L->length)
	return ERROR;
	*e=L->elem[i-1];
	for(j=i;j<=L->length-1;j++)
	{
		L->elem[j-1]=L->elem[j]; 
	 } 
	 L->length--;
	 return OK;
}
/*顺序表中数据元素的定位算法*/ 
int LocateElem(SeqList L,ElemType e) 
{
	int i;
	for(i=0;i<=L.length-1;i++)
	if(L.elem[i]==e)
	{
		return i+1;
	}
	return ERROR;
}
/*顺序表中的取元素操作*/
int GetElem(SeqList L,int i,ElemType *e) 
{
	if(i<1||i>L.length)
	return ERROR;
	*e=L.elem[i-1];
	return OK;
}
/*顺序表中求元素前驱结点操作*/
int PriorElem(SeqList L,ElemType e,ElemType *pre_e)
{
	int i;
	for(i=L.length-1;i>=1;i--)
	{
		if(e==L.elem[i])
		{
			*pre_e=L.elem[i-1];
			return OK;
		}
	}
	return ERROR;
}
/*顺序表中求元素后继结点操作*/ 
int NextElem(SeqList L,ElemType e,ElemType *next_e)
{
	int i;
	for(i=0;i<L.length-1;i++)
	{
		if(e==L.elem[i])
		{
			*next_e=L.elem[i+1];
			return OK;
		}
	}
	return ERROR;
 } 
 /*打印顺序表信息操作*/
 void PrintList(SeqList L)
 {
 	int i;
 	printf("表的储存空间大小为:%d.\n",L.listsize);
 	printf("表中共有元素%d个,各个元素是:\n",L.length);
 	for(i=1;i<=L.length-1;i++)
 	{
 		printf("%d\t",L.elem[i]);
	 }
	 printf("\n");
 }
 void SymmetricDifference(SeqList *La,SeqList Lb)             /*完成集合A=(A-B)U(B-A)运算算法*/
 {
 	int i,j,pos;
 	ElemType e,x;
 	for(i=1;i<=ListLength(Lb);i++)
 	{
 		GetElem(Lb,i,&e);
 		pos=LocateElem(*La,e);
 		if(pos==0)
 		InsertElem(La,ListLength(*La)+1,e);
 		else
 		DeleteElem(La,pos,&x);
	 }
  } 
  /*求表长度*/
   int ListLength(SeqList L)
   {
   		return L.length; 
   } 
   /*两个有序表合并成一个新有序表的算法*/
  void MergeList(SeqList *Lc,SeqList La,SeqList Lb)
  {
  	int i,j,lena,lenb;
  	ElemType e1,e2;
  	InitList(Lc);
  	lena=ListLength(La);
  	lenb=ListLength(Lb);
  	i=1;j=1;
  	while(i<=lena&&j<=lenb)
  	{
  		GetElem(La,i,&e1);
  		GetElem(Lb,j,&e2);
  		if(e1<e2)
  		{
  			InsertElem(Lc,ListLength(*Lc)+1,e1);
  			i++;
		  }
		else
		{
			InsertElem(Lc,ListLength(*Lc)+1,e2);
			j++;	
		}
	  }
	  while(i<=lena)
	  {
	  	GetElem(La,i,&e1);
	  	i++;
	  	InsertElem(Lc,ListLength(*Lc)+1,e1);
	  }
	  while(j<=lenb)
	  {
	  	GetElem(Lb,j,&e2);
	  	j++;
	  	InsertElem(Lc,ListLength(*Lc)+1,e2);
	  }
   }
   /*直接插入排序算法*/ 
   void InsertSort(SeqList *L)
   {
   		int i,j;
   		for(i=2;i<=L->length;i++)
   		{
   			if(L->elem[i]<L->elem[i-1])
   			{
   				L->elem[0]=L->elem[i];
   				for(j=i-1;L->elem[j]>L->elem[0];j--)
   				L->elem[j+1]=L->elem[j];
   				L->elem[j+1]=L->elem[0];
			   }
		   }
   }
   /*顺序表逆序*/
   int nixu(SeqList *L)
   {
   	int i,j,n;
   	for(i=0;i<L->length/2;i++)
   	{
	   
	   n=L->elem[i];
	   L->elem[i]=L->elem[L->length-i-1];
	   L->elem[L->length-i-1]=n;
	}	
	} 
	/*折半插入排序算法*/
	void BinSort(SeqList *L)
	{
		int i,j,low,high,mid;
		for(i=2;i<=L->length;i++)
		{
			if(L->elem[i]<L->elem[i-1])
			{
				L->elem[0]=L->elem[i];
				low=1;
				high=i-1;
				while(low<=high)
				{
					mid=(low+high)/2;
					if(L->elem[mid]>L->elem[0])
					high=mid-1;
					else
					low=mid+1;
				}
				for(j=i-1;j>=high+1;j--)
					L->elem[j+1]=L->elem[j];
				L->elem[high+1]=L->elem[0];
			}
		}
	 } 
	 /*希尔排序算法*/
	 void ShellSort(SeqList *L)
	 {
	 	int i,j,d;
	 	for(d=L->length/2;d>=1;d=d/2)
	 	{
	 		for(i=d+1;i<=L->length;i++)
	 		if(L->elem[i]<L->elem[i-d])
	 		{
	 			L->elem[0]=L->elem[i];
	 			for(j=i-d;j>0&&L->elem[j]>L->elem[0];j=j-d)
	 				L->elem[j+d]=L->elem[j];
	 			L->elem[j+d]=L->elem[0];
			 }
		 }
	  } 
	  /*冒泡排序算法*/
	  void BubbleSort(SeqList *L)
	  {
	  	int i,j,flag;
	  	flag=0;
	  	for(i=L->length;i>=2&&flag==0;i--)
	  	{
	  		flag=1;
	  		for(j=1;j<=i-1;j++)
	  		if(L->elem[j]>L->elem[j+1])
	  		{
	  			L->elem[0]=L->elem[j];
	  			L->elem[j]=L->elem[j+1];
	  			L->elem[j+1]=L->elem[0];
	  			flag=0;
			  }
		  }
	  }
	  /*快速排序中进行一次划分的算法*/
	  int Partition(SeqList *L,int Left,int right)
	  {
	  	int low,hight;
	  	L->elem[0]=L->elem[Left];
	  	low=Left,hight=right;
	  	while(low<hight)
	  	{
	  		while(low<hight&&L->elem[hight]>=L->elem[0])
	  		hight--;
	  		if(low<hight)
	  		{
	  			L->elem[low]=L->elem[hight];
				  low++; 
			  }
			while(low<hight&&L->elem[low]<=L->elem[0])
			low++;
			if(low<hight)
			{
				L->elem[hight]=L->elem[low];
				hight--;
			}
			L->elem[low]=L->elem[0];
			return low;
		  }
	   } 
	   /*快速排序算法*/
	   void QuickSort(SeqList *L,int low,int high)
	   {
	   		int pos;
	   		if(low<high)
	   		{
	   			pos=Partition(L,low,high);
	   			QuickSort(L,low,pos-1);
	   			QuickSort(L,pos+1,high);
			   }
	   }
	   /*简单选择排序算法*/
	   void SelectSort(SeqList *L)
	   {
	   	int i,j,k;
	   	for(i=1;i<=L->length-1;i++)
	   	{
	   		k=i;
	   		for(j=i+1;j<=L->length;j++)
	   		if(L->elem[j]<L->elem[k])
	   		k=j;
	   		if(k!=i)
	   		{
	   			L->elem[0]=L->elem[i];
	   			L->elem[i]=L->elem[k];
	   			L->elem[k]=L->elem[0];
			   }
		   }
		}
        /*归并排序*/
void Merge(ElemType a[],int low,int high,ElemType b[])
{
	int i, j, k, mid;
	mid=(low+high)/2;
	i=low;j=mid+1;k=low;
	while(i<=mid&&j<=high) {
		if(a[i]>a[j]) {
			b[k++]=a[j++];
		}
		else {
			b[k++]=a[i++];	
		}
	}
	while(i<=mid) {
		b[k++]=a[i++];
	}
	while(j<=high) {
		b[k++]=a[j++];
	}	 
}

插入排序:

#include"SeqList.cpp"
int main(void)
{
	int i,a,b,c;
	ElemType data1[8]={50,11,80,4,10,2,57,5};
	SeqList L1;
	InitList(&L1);
	InsertElem(&L1,1,data1[i-1]);
	for(i=1;i<=8;i++)
	{
		InsertElem(&L1,i+1,data1[i-1]);
	}
	PrintList(L1);
	InsertSort(&L1); 
	PrintList(L1);
 }

 折半插入排序:

#include"SeqList.cpp"
int main(void)
{
	int i,a,b,c;
	ElemType data1[8]={0,10,8,42,100,16,7,55};
	SeqList L1;
	InitList(&L1);
	InsertElem(&L1,1,data1[i-1]);
	for(i=1;i<=8;i++)
	{
		InsertElem(&L1,i+1,data1[i-1]);
	}
	PrintList(L1);
	BinSort(&L1);
	PrintList(L1);
 }

 选择排序:

#include"SeqList.cpp"
int main(void)
{
	int i,a,b,c;
	ElemType data1[10]={25,10,8,4,110,78,7,15,2,3};
	SeqList L1;
	InitList(&L1);
	InsertElem(&L1,1,data1[i-1]);
	for(i=1;i<=10;i++)
	{
		InsertElem(&L1,i+1,data1[i-1]);
	}
	PrintList(L1);
	SelectSort(&L1);
	PrintList(L1);
}

希尔排序:

#include"SeqList.cpp"
int main(void)
{
	int i,a,b,c;
	ElemType data1[8]={0,1,8,4,10,6,7,5};
	SeqList L1;
	InitList(&L1);
	InsertElem(&L1,1,data1[i-1]);
	for(i=1;i<=8;i++)
	{
		InsertElem(&L1,i+1,data1[i-1]);
	}
	PrintList(L1);
	ShellSort(&L1);
	PrintList(L1);
 }

冒泡排序:

#include"SeqList.cpp"
int main(void)
{
	int i,a,b,c;
	ElemType data1[8]={0,1,8,4,10,6,7,5};
	SeqList L1;
	InitList(&L1);
	InsertElem(&L1,1,data1[i-1]);
	for(i=1;i<=8;i++)
	{
		InsertElem(&L1,i+1,data1[i-1]);
	}
	PrintList(L1);
	BubbleSort(&L1);
	PrintList(L1);
 }

归并排序:

#include"SeqList.cpp"
int main()
{
	int i, j, k;
	ElemType data1[8]={0,1,8,4,10,6,7,5};
	SeqList L1;
	InitList(&L1);
	InsertElem(&L1,1,data1[i-1]);
	for(i=1;i<=8;i++)
	{
		InsertElem(&L1,i+1,data1[i-1]);
	}
	PrintList(L1);
	BubbleSort(&L1);
	PrintList(L1);
 }

快速排序:

#include"SeqList.cpp"
int main(void)
{
	int i,a,b,c;
	ElemType data1[8]={0,1,8,4,10,6,7,5};
	SeqList L1;
	InitList(&L1);
	InsertElem(&L1,1,data1[i-1]);
	for(i=1;i<=8;i++)
	{
		InsertElem(&L1,i+1,data1[i-1]);
	}
	PrintList(L1);
	QuickSort(&L1,1,L1.length);
	PrintList(L1);
 }

四维空间中的未知点
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

四维空间中的未知点

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值