数据结构day 2

最新推荐文章于 2024-07-24 22:34:26 发布

代码不会敲！

最新推荐文章于 2024-07-24 22:34:26 发布

阅读量43

点赞数

文章标签：数据结构

本文链接：https://blog.csdn.net/m0_69894626/article/details/132509242

版权

顺序表的功能代码

#ifndef _SEQLIST_H
#define _SEQLIST_H
#include<myhead.h>
#define MAX 10
typedef int datatype;
typedef struct //数据元素
{
	datatype arr[MAX];//数据对象
	int len;//实际长度
}Seq,*Seqptr;
//顺序表实现增删改查
//创建顺序表
Seqptr Seqlist_create();
//判满
int Seqlist_full(Seqptr P);
//判空
int Seqlist_empty(Seqptr P);
//遍历顺序表
int Seqlist_show(Seqptr P);
//尾插
int insert_tail(Seqptr P,int data );
//头插
int insert_head(Seqptr p,int data);
//尾删
int dele_tail(Seqptr P);
//头删
int dele_head(Seqptr P);
//按值修改
int search_value(Seqptr P,int old_value,int new_value);

//按位置修改
int search_pos(Seqptr P,int pos,int new_value);
//按值查找位置
int find_value(Seqptr P,int value);
//按位置查找值
int find_pos(Seqptr P,int pos);
//任意位置删除
int dele_pos(Seqptr P,int pos);
//顺序表去重
int Seqlist_unique(Seqptr P);
//顺序表的冒泡排序
int Seqlist_Bubble_sort(Seqptr P);
//顺序表的选排序
int Seqlist_Select_sort(Seqptr P);
//顺序表的反转
int Seqlist_rollback_sort(Seqptr P);

//顺序表的释放
int Seqlist_free(Seqptr P);







#endif

#include<myhead.h>
#include"seqlist.h"
//创建顺序表
Seqptr Seqlist_create()
{
	//堆区申请空间
	Seqptr P=(Seqptr)malloc(sizeof(Seq));
	if(P==NULL)
	{
		return NULL;
	}
	//说明申请空间成功
	memset(P->arr,0,sizeof(P->arr));
	P->len=0;
	return P;
}
//顺序表判满
int Seqlist_full(Seqptr P)
{
	if(P==NULL)
	{
		printf("所给链表不合法\n");
		return -1;
	}
	return 	P->len==MAX?1:0;

}
//顺序表判空
int Seqlist_empty(Seqptr P)
{

	if(P==NULL)
	{
		printf("表不合法\n");
		return -1;
	}
	return P->len==0?1:0;
}
//遍历顺序表
int Seqlist_show(Seqptr P)
{
	if(P==NULL)
	{
		printf("所给顺序表不合法\n");
		return -1;
	}
	//开始遍历
	int i;
	for(i=0;i<=P->len-1;i++)
	{
		printf("%d\t",P->arr[i]);
	}
	printf("遍历成功\n");
	return 0;
}
//尾插
int insert_tail(Seqptr P,int data)
{
	if(P==NULL||Seqlist_full(P))
	{
		printf("所给链表不合法\n");
		return -1;
	}
	//开始插入
	P->arr[P->len]=data;
	P->len++;
	printf("尾插成功\n");
	return 0;
}
//头插
int insert_head(Seqptr P,int data)
{
	if(P==NULL||Seqlist_full(P))
	{
		printf("所给链表不合法\n");
		return -1;
	}
	//开始头插
	int i;//循环后移挪位置
	for(i=P->len-1;i>=0;i--)
	{
		P->arr[i+1]=P->arr[i];

	}
	//把数据装到第一个下标的位置
	P->arr[0]=data;
	P->len++;
	printf("头插成功\n");
	return 0;
}
//尾删
int dele_tail(Seqptr P)
{
	if(P==NULL||Seqlist_empty(P))
	{
		printf("所给顺序表不合法\n");
		return -1;
	}
	P->arr[P->len-1]=0;
	P->len--;
	printf("尾删成功\n");
	return 0;
}
//头删
int dele_head(Seqptr P)
{
	if(P==NULL||Seqlist_empty(P))
	{
		printf("所给链表不合法\n");
		return -1;
	}
	//循环前移覆盖
	int i;
	for(i=0;i<=P->len-1;i++)
	{
		P->arr[i]=P->arr[i+1];

	}
	P->arr[P->len-1]=0;
	P->len--;
	printf("头删成功\n");
	return 0;
}
//按值修改
int search_value(Seqptr P,int old_value,int new_value)
{
	if(P==NULL||Seqlist_empty(P))
	{
		printf("所给顺序表不合法\n");
		return -1;
	}
	//循环遍历顺序表找到相同的值
	int i;
	for(i=0;i<P->len-1;i++)
	{
		if(P->arr[i]==old_value)
		{
			P->arr[i]=new_value;
		}
	}
	printf("修改成功\n");
	return 0;
}
//按位置修改
int search_pos(Seqptr P,int pos,int new_value)
{
	if(P==NULL||Seqlist_empty(P)||pos>P->len||pos<1)
	{
		printf("所给链表不合法\n");
		return -1;
	}
	P->arr[pos-1]=new_value;
	printf("修改成功\n");
	return 0;
}
//按值查找
int find_value(Seqptr P,int value)
{
	if(P==NULL||Seqlist_empty(P))
	{
		printf("所给顺序表不合法\n");
		return -1;
	}
	//循环遍历顺序表找到相同的值返回下标
//	int index=0;
	int i;
	for(i=0;i<P->len-1;i++)
	{
		if(P->arr[i]==value)
		{
			//index=i;
			printf("查找成功\n");
			printf("该下标为%d\n",i);
			return i;
		
		}
		else
		{
			printf("查找失败\n");
			return 0;
		}
		} 
	
}
//按位置查找
int find_pos(Seqptr P,int pos)
{
	if(P==NULL||Seqlist_empty(P)||pos<1||pos>P->len)
	{
		printf("所给顺序表不合法\n");
		return -1;
	}
	int i,ret1;
	for(i=0;i<P->len;i++)
	{
		if(i==pos)
		{
			ret1=P->arr[i];

		}

	}
	printf("查找成功\n");
	return ret1;
}
//任意位置删除
int dele_pos(Seqptr P,int pos)
{
	if(P==NULL||Seqlist_empty(P)||pos<0||pos>P->len-1)
	{
		printf("所给顺序表不合法\n");
		return -1;
	}
	//任意位置删除1.循环前移覆盖
	for(int i=pos+1;i<=P->len-1;i++)
	{
		P->arr[i-1]=P->arr[i];

	}
	P->arr[P->len-1]=0;
	P->len--;
	printf("删除成功\n");
	return 0;
}
//顺序表去重
int Seqlist_unique(Seqptr P)
{
	if(P==NULL||Seqlist_empty(P)||P->len==1)
	{
		printf("所给顺序表不合法\n");
		return -1;
	}
	for(int i=0;i<P->len-1;i++)//循环遍历整个顺序表
	{
		for(int j=i+1;j<P->len;j++)
		{
			if(P->arr[j]==P->arr[i])
			{
				dele_pos(P,j);
				j--;//因为上次删除数据　前移了可能会漏掉原本j位置上的数据

			}
		}
	}
	printf("去重成功\n");
	return 0;
}
//顺序表的冒泡排序
int Seqlist_Bubble_sort(Seqptr P)
{
	if(P==NULL||Seqlist_empty(P))
	{
		printf("所给顺序表不合法\n");
		return -1;
	}
	//开始冒泡排序
	int temp;
	for(int i=1;i<P->len;i++)
	{
		for(int j=0;j<P->len-i;j++)
		{
			
			if(P->arr[j+1]>P->arr[j])
			{
				temp=P->arr[j];
				P->arr[j]=P->arr[j+1];
				P->arr[j+1]=temp;
			}
		}


	}
	printf("冒泡排序成功\n");


	
	return 0;

}
//顺序表的选排序
int Seqlist_Select_sort(Seqptr P)
{
	if(P==NULL||Seqlist_empty(P))
	{
		printf("所给顺序表不合法\n");
		return -1;
	}
	//开始选择排序
	int i,j,temp,index;
	for(int i=1;i<P->len;i++)
	{
		//每次让假定的最小值是待排序中的第一个数
		//保证每一次进入内层循环时，index是新的值
		index=i-1;
		//内层循环找剩余序列的最小值
		for(j=i-1;j<P->len;j++)
		{
			//选择排序找下标
			if(P->arr[index]>P->arr[j])
			{
				//更新最小值的下标
				index =j;
			}
		}
		//找到最小值，跟第一个元素交换
		if(index!=i-1)
		{
			//三杯水
			temp=P->arr[index];
			P->arr[index]=P->arr[i-1];
			P->arr[i-1]=temp;
		}
	}
	printf("选择排序成功\n");
	return 0;
}
//顺序表的反转
int Seqlist_rollback_sort(Seqptr P)
{

	if(P==NULL||Seqlist_empty(P))
	{
		printf("所给顺序表不合法\n");
		return -1;
	}
	int i,j ,temp;
	//下标之间的关系
	//j指向尾部，i指向头
	for(i=0,j=P->len-1;j>i;i++,j--)
	{
		temp=P->arr[i];
		P->arr[i]=P->arr[j];
		P->arr[j]=temp;
	}
}



//顺序表的释放
int Seqlist_free(Seqptr P)
{
	if(P==NULL)
	{
		printf("所给顺序表不合法\n");
		return -1;
	}
	free(P);
	P=NULL;
	printf("释放成功\n");
	return 0;
}

#include"seqlist.h"
	int main(int argc, const char *argv[])
{
	

	//创建函数的调用
	Seqptr P=Seqlist_create();
	
	
	printf("创建成功\n");	
	//调用尾插函数
	insert_tail(P,100);
	insert_tail(P,199);
	insert_tail(P,90);
    Seqlist_show(P);






	//调用头插函数
	insert_head(P,89);
	//调用遍历函数
	Seqlist_show(P);

	//调用头删
	dele_head(P);
	Seqlist_show(P);
	//调用尾删
	dele_tail(P);
	Seqlist_show(P);

	//调用按值修改函数
	search_value(P,100,88);
	Seqlist_show(P);
	
	insert_tail(P,100);
	insert_tail(P,199);
	insert_tail(P,90);
	Seqlist_show(P);



	//调用按位置修改函数pos表示位置
	search_pos(P,2,30);
	search_pos(P,4,188);
	printf("**********************修改成功后***************\n");
	Seqlist_show(P);


	//调用按值查找下标
	find_value(P,60);
	//int ret1=find_value(P,60);
//	printf("该值的下标为%d\n",ret1);

	//调用按位置查找的值	
	insert_tail(P,3);
	insert_tail(P,100);
	insert_tail(P,199);
	insert_tail(P,90);
//	printf("%d\n",P->len);
	int ret=find_pos(P,5);
	printf("该下标的值为%d\n",ret);

	//任意位置删除
	dele_pos(P,1);
	printf("*******************删除成功后************\n");
	Seqlist_show(P);
	//顺序表去重
	Seqlist_unique(P);
	printf("************去重成功后*********************\n");
	Seqlist_show(P);
	//调用冒泡排序函数
	Seqlist_Bubble_sort(P);
	printf("******************冒泡排序后********************\n");
	Seqlist_show(P);

	insert_tail(P,100);
	insert_tail(P,199);
	insert_tail(P,90);
	printf("选择排序前\n");
	Seqlist_show(P);


	//调用选择排序函数
	 Seqlist_Select_sort(P);
	 printf("******************选择排序后*********************\n");
	 Seqlist_show(P);

	 //调用翻转函数

	Seqlist_rollback_sort(P);
	printf("*******************翻转后***************************\n");
	Seqlist_show(P);

	//释放顺序表
    	
	Seqlist_free(P);
	P=NULL;
	

	return 0;
}