数据结构顺序表的学习(7.17)

奕书想睡觉了。

已于 2023-07-18 20:37:34 修改

阅读量50

点赞数

文章标签：数据结构学习

于 2023-07-18 08:51:52 首次发布

本文链接：https://blog.csdn.net/weixin_62318298/article/details/131779088

版权

一、顺序表的操作练习

主函数：

#include "head.h"
int main(int argc, const char *argv[])
{
	//申请空间
	Seqlist *list=create_list();
	//

	int n;
	printf("请输入n的值：");
	scanf("%d",&n);
	datatype e;
	for(int i=0;i<n;i++)
	{
		printf("请输入元素：");
		scanf("%d",&e);
		insert_rear(e,list);  //进行尾插
	}
	//输出
	Output(list);
	//尾部删除
	Delete(list);

	Output(list);
	//按顺序表下标任意查找
	int sub;
	printf("请输入要查找的下标：");
	scanf("%d",&sub);
	e=Serach_sub(sub,list);
	if(e!=-1)
	{
		printf("该下标对应的值为:%d\n",e);
	}

	//按顺序表任意下标修改
	printf("请输入要修改的位置：");
	scanf("%d",&sub);
	printf("请输入要修改的值：");
	scanf("%d",&e);
	Update_sub(list,sub,e);
	Output(list);

	//按顺序任意下标插入
	printf("请输入要插入的下标：");
	scanf("%d",&sub);
	printf("请输入要插入的元素：");
	scanf("%d",&e);
	Inserte_sub(list,sub,e);
	Output(list);

	//按顺序任意下标删除
	printf("请输入要删除的下标：");
	scanf("%d",&sub);
	Delete_sub(list,sub);
	Output(list);

	//顺序表任意元素查找
	datatype key;
	printf("请输入要查找的元素：");
	scanf("%d",&key);
	printf("查找到的元素为：%d\n",Serach_data(key,list));


	//顺序表按任意元素插入
	printf("请输入要插入的元素：");
	scanf("%d",&key);
	printf("请输入被插入的元素：");
	scanf("%d",&e);
	Inserte_data(list,key,e);
	Output(list);

	//顺序表任意元素修改
	printf("请输入要修改的元素：");
	scanf("%d",&key);
	printf("请输入修改后的元素：");
	scanf("%d",&e);
	Update_data(list,key,e);
	Output(list);

	//顺序表任意元素删除
	printf("请输入要删除的元素：");
	scanf("%d",&key);
	Delete_data(key,list);
	Output(list);

	//顺序表去重
	Delete_repeat(list);
	Output(list);

	//顺序表合并
	//创建la
	Seqlist *la=create_list();
	int n;
	printf("请输入n的值：");
	scanf("%d",&n);
	datatype e;
	for(int i=0;i<n;i++)
	{
		printf("请输入la元素：");
		scanf("%d",&e);
		insert_rear(e,la);  //进行尾插
	}
	//创建lb
	Seqlist *lb=create_list();
	printf("请输入n的值：");
	scanf("%d",&n);
	for(int i=0;i<n;i++)
	{
		printf("请输入lb元素：");
		scanf("%d",&e);
		insert_rear(e,lb);  //进行尾插
	}
	//创建lc
	Seqlist *lc=create_list();
	//顺序表合并
	Combine(la,lb,lc);
	Output(lc);

	Seqlist *list=create_list();
	int n;
	printf("请输入n的值：");
	scanf("%d",&n);
	datatype e;
	for(int i=0;i<n;i++)
	{
		printf("请输入元素：");
		scanf("%d",&e);
		insert_rear(e,list);  //进行尾插
	}
	Bubble(list,n);
	Output(list);
	return 0;
}

头文件：

//预处理命令
//全局变量
//函数声明
#ifndef __HEAD_H
#define __HEAD_H
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define MAXSIZE   8
typedef int datatype;
typedef struct
{
	//顺序表长度
	int len;
	//数据元素
	datatype data[MAXSIZE];
}Seqlist;
//申请空间
Seqlist *create_list();
//判断是否为满
int full_list(Seqlist *list);
//进行尾插
int insert_rear(datatype e,Seqlist *list);
//判断是否为空
int empty(Seqlist *list);
//输出
void Output(Seqlist *list);
//尾部删除
int Delete(Seqlist *list);
//按顺序下标任意查找
int Serach_sub(int sub,Seqlist *list);
//按顺序下标任意修改
int Update_sub(Seqlist *list,int sub,datatype e);
//按顺序下标任意插入
int Inserte_sub(Seqlist *list,int sub,datatype e);
//按顺序下标任意删除
int Delete_sub(Seqlist *list,int sub);
//按顺序表任意元素查找
int Serach_data(datatype key,Seqlist *list);
//顺序表按任意元素插入
int Inserte_data(Seqlist *list,datatype key,datatype e);
//顺序表按任意元素修改
int Update_data(Seqlist *list,datatype key,datatype e);
//顺序表按任意元素删除
int Delete_data(datatype key,Seqlist *list);
//顺序表去重
int Delete_repeat(Seqlist *list);
//顺序表合并
void Combine(Seqlist *la,Seqlist *lb,Seqlist *lc);
//顺序表排序
int Bubble(Seqlist *list,int len);
#endif

函数封装：

#include "head.h"
/*
 * function:    申请空间
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Seqlist *create_list()
{
	Seqlist *list=(Seqlist *)malloc(sizeof(Seqlist));
	if(NULL==list)
	{
		return NULL;
	}
	return list;
	list->len=0;  //顺序表长度清零
	memset(list->data,0,sizeof(list->data));
}
/*
 * function:    判断是否为满
 * @param [ in] 
 * @param [out] 
 * @return      满则返回-1，不满则返回0
 */
int full_list(Seqlist *list)
{
	return list->len==MAXSIZE?-1:0;
}
/*
 * function:    进行尾插
 * @param [ in] 
 * @param [out] 
 * @return      成功则返回0,失败则返回-1;
 */
int insert_rear(datatype e,Seqlist *list)
{
	if(NULL==list||full_list(list))
	{
		printf("insert rear error\n");
		return -1;
	}
	list->data[list->len]=e;
	list->len++;
	return 0;
}
/*
 * function:   判断顺序表是否为空 
 * @param [ in] 
 * @param [out] 
 * @return      空返回-1.非空返回0;
 */
int empty(Seqlist *list)
{
	return list->len==0?-1:0;
}
/*
 * function:    输出
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void Output(Seqlist *list)
{
	if(NULL==list || empty(list))
	{
		printf("输出错误\n");
		return;
	}
	for(int i=0;i<list->len;i++)
	{
		printf("%d\t",list->data[i]);
	}
	puts("");
}
/*
 * function:    尾部删除
 * @param [ in] 
 * @param [out] 
 * @return      成功返回0，失败返回-1;
 */
int Delete(Seqlist *list)
{
	if(NULL==list || empty(list))
	{
		printf("删除错误\n");
		return -1;
	}
	printf("要删除的元素为:%d\n",list->data[list->len-1]);
	list->len--;
	return 0;
}
/*
 * function:    按任意下标查找
 * @param [ in] 
 * @param [out] 
 * @return      不存在返回-1，存在返回查找值
 */
int Serach_sub(int sub,Seqlist *list)
{
	if(NULL==list||empty(list)||sub<0||sub>=list->len)
	{	
		return -1;
		printf("查找失败\n");
	}
	return list->data[sub];
}
/*
 * function:    修改
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int Update_sub(Seqlist *list,int sub,datatype e)
{
	if(NULL==list||empty(list)||sub<0||sub>=list->len)
	{
		return -1;
		printf("修改失败\n");
	}
	list->data[sub]=e;
	return 0;
}
/*
 * function:    插入
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int Inserte_sub(Seqlist *list,int sub,datatype e)
{
	if(NULL==list||full_list(list)||sub<0||sub>list->len)
	{
		printf("插入失败\n");
		return -1;
	}
	for(int i=list->len-1;i>=sub;i--)
	{
		list->data[i+1]=list->data[i];
	}
	list->data[sub]=e;
	list->len++;
	return 0;
}
/*
 * function:   删除
 * @param [ in] 
 * @param [out]
 * @return      
 */
int Delete_sub(Seqlist *list,int sub)
{
	if(NULL==list||empty(list)||sub<0||sub>=list->len)
	{
		printf("删除失败\n");
		return -1;
	}
	for(int i=sub;i<=list->len-1;i++)
	{
		list->data[i]=list->data[i+1];
	}
	list->len--;
	return 0;
}
/*
 * function:    顺序表按任意元素查找
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int Serach_data(datatype key,Seqlist *list)
{
	if(NULL==list||empty(list))
	{
		printf("查找失败\n");
		return -1;
	}
	for(int i=0;i<list->len;i++)
	{
		if(key==list->data[i])
			return i;
	}
	return -1;
}
/*
 * function:    顺序表按任意元素插入
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int Inserte_data(Seqlist *list,datatype key,datatype e)
{
	if(NULL==list||full_list(list))
	{
		printf("插入失败\n");
		return -1;
	}
	int sub=Serach_data(key,list);
	Inserte_sub(list,sub,e);
	return 0;
}
/*
 * function:    顺序表按任意元素修改
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int Update_data(Seqlist *list,datatype key,datatype e)
{
	if(NULL==list||empty(list))
	{
		printf("修改失败\n");
		return -1;
	}
	for(int i=0;i<list->len;i++)
	{
		if(key==list->data[i])
		{
			list->data[i]=e;
			return 0;
		}
	}
	return -1;
}
/*
 * function:    顺序表按任意元素删除
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int Delete_data(datatype key,Seqlist *list)
{
	if(NULL==list||empty(list))
	{
		printf("删除失败\n");
		return -1;
	}
	int num=Serach_data(key,list);
	Delete_sub(list,num);
	return 0;
}
/*
 * function:    去重
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int Delete_repeat(Seqlist *list)
{
	if(NULL==list||empty(list))
	{
		printf("去重失败\n");
		return -1;
	}
	for(int i=0;i<list->len-1;i++)
	{
		for(int j=i+1;j<list->len;j++)
		{
			if(list->data[i]==list->data[j])
			{
				Delete_sub(list,j);
				j--;
			}
		}
	}
	return 0;
}
//顺序表合并
void Combine(Seqlist *la,Seqlist *lb,Seqlist *lc)
{
	int i=0,j=0;
	while(i<la->len && j<lb->len)
	{
		if(la->data[i]<=lb->data[j])
			lc->data[lc->len++]=la->data[i++];
		else
			lc->data[lc->len++]=lb->data[j++];	
	}
	while(i<la->len)
	{
		lc->data[lc->len++]=la->data[i++];
	}
	while(j<lb->len)
	{
		lc->data[lc->len++]=lb->data[j++];	
	}
}
/*
 * function:    顺序表排序
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int Bubble(Seqlist *list,int len)
{
	if(NULL==list||empty(list))
	{
		printf("排序失败\n");
		return -1;
	}
	for(int i=1;i<len;i++)
	{
		for(int j=0;j<len-i;j++)
		{
			if(list->data[j]>list->data[j+1])
			{
				int t=list->data[j];list->data[j]=list->data[j+1];
				list->data[j+1]=t;
			}
		}
	}
	return 0;
}

二、Xmind思维导图