数据结构 5.16

最新推荐文章于 2024-08-23 23:10:58 发布
最新推荐文章于 2024-08-23 23:10:58 发布
阅读量74 收藏
点赞数
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56282135/article/details/130714681
版权

   作业：

8，顺序表按照元素插入


   

9，顺序表按照元素查找


10，顺序表按照元素修改


11，顺序表按照元素删除
    

 12，冒泡排序


13，简单选择排序
14，释放空间

 main.c文件

#include"head1.h"
int main(int argc, const char *argv[])
{
	//在堆区创建空间
	seqlist *list=create();
	
	menu();//显示菜单
	int member;//创建菜单编号
	
	while(1)
	{
		printf("请输入您的选择：\n");
		scanf("%d",&member);
		switch(member)
		{
		case 1:
			{
				int n;
				datatype e;
				printf("请输入尾部插入的个数：\n");
				scanf("%d",&n);
				for(int i=0;i<n;i++)
				{
					printf("请输入要插入的数据元素：");
					scanf("%d",&e);
					insert_rear(e,list);
				}
			
			}
			break;
		case 2:
			{
				delete_rear(list);
			}
			break;
		case 3:
			   {
			   	output(list);
			   }
			   break;
		case 4:
			   {
			   		int sub;
					printf("请输入您要查找的下标：");
					scanf("%d",&sub);
				   find_sub(list,sub);
			   }
			   break;
		case 5:
			   {
			   		int sub;
					int e;
					printf("请输入您要修改的下标：");
					scanf("%d",&sub);
					printf("请输入您要修改的数值：");
					scanf("%d",&e);

				   xiugai_sub(list,sub,e);
					
			   }break;
		case 6:
			   {
			   		
			   		int sub;
					int e;
					printf("请输入您要插入的下标：");
					scanf("%d",&sub);
					printf("请输入您要插入的数值：");
					scanf("%d",&e);

				   insert_1sub(list,sub,e);
			   }break;
		case 7:
			   {
			   		
			   		int sub;
					printf("请输入您要删除元素的下标：");
					scanf("%d",&sub);

			        delete_1sub(list,sub);
			   }break;


		case 8:
			   {
				   	int key;
					int e;
			   		printf("请输入你要查找的元素和插入的元素：");
					scanf("%d %d",&key,&e);
					part_insert(list,key,e);
			   }break;

		case 9:
			  {
			  		int key;
					printf("请输入您要查找的元素：");
					scanf("%d",&key);
					int flag=part_find(list,key);
					printf("您所查找的元素:%d下标是：%d\n",key,flag);

			  }break;
		case 10:
			  {
			  		int key;
					int e;
					printf("您好，请输入您要修改的元素和要修改的结果");
					scanf("%d %d",&key,&e);
					part_xiugai(list,key,e);
			  }break;
		case 11:
			  {
			  		int key;
					printf("请输入要删掉的元素\n");
					scanf("%d",&key);
					part_delete(list,key);
			  }break;

		case 12:
			  {
			  	maopao_sort(list);
			  }break;
		case 13:
			  {
			  	xuanze_sort(list);
			  }break;
		case 14:
			  {
			  	list=free_sapce(list);
			  }break;
		default:printf("输入错误，请重新输入您的选择：\n");break;
		case 0:printf("程序结束\n");exit(0);
		}
	}

	return 0;
}

tset.c 文件

#include"head1.h"
void menu()
{
	puts("*******************");
	puts("\t1，表尾部插入");
	puts("\t2，表尾部删除");
	puts("\t3，顺序表遍历");

	puts("\t4，按照下标查找元素");
	puts("\t5，按照下标修改元素");
	puts("\t6，按照下标插入元素");
	puts("\t7，按照下标删除元素");

	puts("\t8，顺序表按照元素插入");
	puts("\t9，顺序表按照元素查找");
	puts("\t10，顺序表按照元素修改");
	puts("\t11，顺序表按照元素删除");
	
	puts("\t12，冒泡排序");
	puts("\t13，简单选择排序");
	puts("\t14，释放空间");

	puts("\t0,退出整个程序");
	puts("*******************");
}

seqlist *create()
{
	seqlist *list=(seqlist *)malloc(sizeof(seqlist));
	if(list==NULL)
		return NULL;
	//申请成功
	list->len=0;
	return list;
}

int insert_rear(int e,seqlist *list)
{
	//判断顺序表是否满
	if(list==NULL||list->len==MAXSIZE)
	{
		return -1;
	}
	//正常插入
	list->data[list->len]=e;
	list->len++;
	return 0;
}

int output(seqlist *list)
{
	//判断顺序表是否空或创建成功
	if(list==NULL||list->len==0)
	{
		puts("顺序表为空");
		return -1;
	}
	//成功
	for(int i=0;i<list->len;i++)
	{
		printf("%d\t",list->data[i]);
	}
	puts("");
}

int delete_rear(seqlist *list)
{
	//判断顺序表是否空或创建成功
	if(list==NULL||list->len==0)
	{
		return -1;
	}
	//可以删除
	list->len--;
	puts("删除成功,已经删除一个数据！");
	return 0;
}

int find_sub(seqlist *list,int sub)
{
	//判断顺序表是否空或创建成功...
	if(list==NULL||list->len==0||sub<0||sub>=list->len)
	{
		return -1;
	}
	//可以按照下标查找元素
	printf("%d\n",list->data[sub]);
	return 0;
}

int xiugai_sub(seqlist *list,int sub,int e)
{
	//判断顺序表是否空或创建成功...
	if(list==NULL||list->len==0||sub<0||sub>=list->len)
	{
		return -1;
	}
	//可以按照下标修改元素
	list->data[sub]=e;
	
	return 0;
}

int insert_1sub(seqlist *list,int sub,int e)
{
	//判断顺序表是否创建成功
	//判断顺序表是否满
	//判断下标是否合理
	if(list==NULL||list->len==MAXSIZE||sub<0||sub>list->len)
	{
		return -1;
		printf("不能插入下标\n");
	}
	//可以按照下标插入元素
	printf("可以插入元素\n");
	for(int i=list->len-1; i>=sub; i--)
	{
		list->data[i+1]=list->data[i];	
	}
	list->data[sub]=e;
	list->len++;
	return 0;
}
int delete_1sub(seqlist *list,int sub)
{
	//判断顺序表是否创建成功
	//判断顺序表是否满
	//判断下标是否合理
	if(list==NULL||empty_seqlist(list)||sub<0||sub>=list->len)
	{
		return -1;
		printf("删除失败\n");
	}
	for(int i=sub+1; i<list->len; i++)
	{
		list->data[i-1]=list->data[i];	
	}
	list->len--;
	printf("删除成功\n");
	return 0;
}

//函数判断空
int empty_seqlist(seqlist *list)
{
	return list->len==0?-1:0;
}

//函数判断满
int full_seqlist(seqlist *list)
{
	return list->len==MAXSIZE?-1:0;
}

//顺序表按照元素插入
int part_insert(seqlist *list,int key,int e)
{
	if(list==NULL||full_seqlist(list))
	{
		return -1;
		printf("插入元素失败\n");
	}
	//可以插入元素
	//查找元素下标
	int sub;//元素下标
	for(int i=0;i<list->len;i++)
	{
		if(list->data[i]==key)
		{
			sub=i;
		}
	}
	//找到元素下标
	for(int i=list->len-1; i>sub; i--)
	{
		list->data[i+1]=list->data[i];	
	}
	list->data[sub+1]=e;
	list->len++;
	printf("插入元素成功\n");
	
}

//顺序表按照元素查找
int part_find(seqlist *list,int key)
{
	
	if(list==NULL||empty_seqlist(list))
	{
		return -1;
		printf("不能查找元素\n");
	}
	//可以查找元素
	//查找元素下标
	int sub;//元素下标
	for(int i=0;i<list->len;i++)
	{
		if(list->data[i]==key)
		{
			sub=i;
			return sub;//返回元素下标
		}
	}
	printf("%d元素不存在\n",key);
	return -1;

}
//顺序表按照元素修改
int part_xiugai(seqlist *list,int key,int e)
{
	int sub=part_find(list,key);
	if(sub==-1)
	{
		printf("不能修改元素\n");
		return -1;
	}
	//可以修改元素
	list->data[sub]=e;
	printf("修改元素成功\n");
	return 0;
}

//顺序表按照元素删除
int part_delete(seqlist *list,int key)
{
	int sub=part_find(list,key);
	if(sub==-1)
	{
		printf("不能执行删除\n");
		return -1;
	}
	//可以删除
	for(int i=sub+1; i<list->len; i++)
	{
		list->data[i-1]=list->data[i];	
	}
	list->len--;
	printf("删除成功\n");
	return 0;

}

//冒泡排序
int maopao_sort(seqlist *list)
{

	int temp,i,j;
	//外层循环控制趟数
	for(int i=1;i<list->len;i++)
	{
		//内层循环控制比较次数
		for(int j=0;j<list->len-i;j++)
		{
			if(list->data[j]>list->data[j+1])
			{
				temp=list->data[j];
				list->data[j]=list->data[j+1];
				list->data[j+1]=temp;
			}
		}
	}
	printf("冒泡排序成功！\n");
	return 0;
}
//简单选择排序
int xuanze_sort(seqlist *list)
{
	int i,j,temp,index;
	for(int i=1;i<list->len;i++)
	{
		index=i-1;
		for(int j=i;j<list->len;j++)
		{
			if(list->data[index]>list->data[j])
				index=j;
		}

		if(index!=i-1)
		{
			temp=list->data[index];
			list->data[index]=list->data[i-1];
			list->data[i-1]=temp;
		}
	}
	printf("选择排序成功\n");
	return 0;
}
//空间释放
seqlist *free_sapce(seqlist *list)
{
	if(list==NULL)
		return NULL;
	//
	free(list);
	list=NULL;
	return NULL;
}

 head.h文件

#ifndef NNN
#define NNN


#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define MAXSIZE 10
typedef int datatype;
typedef struct
{
	datatype data[MAXSIZE];
	int len;
}seqlist;

seqlist *create();
void menu();


int empty_seqlist(seqlist *list);
int full_seqlist(seqlist *list);
int insert_rear(int e,seqlist *list);
int output(seqlist *list);
int delete_rear(seqlist *list);

int find_sub(seqlist *list,int sub);
int xiugai_sub(seqlist *list,int sub,int e);
int insert_1sub(seqlist *list,int sub,int e);
int delete_1sub(seqlist *list,int sub);

int part_insert(seqlist *list,int key,int e);
int part_find(seqlist *list,int key);
int part_xiugai(seqlist *list,int key,int e);
int part_delete(seqlist *list,int key);


//冒泡排序
int maopao_sort(seqlist *list);
//简单选择排序
int xuanze_sort(seqlist *list);
seqlist *free_sapce(seqlist *list);

#endif

 

 

千里之行run
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Activiti 5.16
12-07
- **高级特性实现**：例如条件判断、循环结构、消息事件等高级元素均得到了良好支持，满足复杂逻辑需求。 - **版本控制与历史记录**：每个流程模型都有明确的版本号标识，便于追踪变更历史及回滚至任意历史状态。 #...
ActiveMq5.16.7
05-01
- **下载与解压**: 下载`apache-activemq-5.16.7`压缩包并解压，得到包含bin、conf、data等目录的结构。 - **启动与停止**: 在bin目录下运行启动脚本，如`activemq start`，停止则用`activemq stop`。 - **配置文件*...
activiti-5.16
12-11
6. **数据库持久化**：Activiti 使用关系型数据库存储流程实例和相关数据，支持多种数据库系统，如MySQL、Oracle、SQL Server等。 7. **RESTful API**：提供REST接口，便于与其他系统交互，实现远程控制和监控工作...
Activiti 5.16 用户手册.pdf
11-07
Activiti 5.16是该平台的一个版本，下面对用户手册中提及的知识点进行详细介绍。 1. 系统要求与配置 Activiti 5.16版本要求使用JDK 6或更高版本，适用于Eclipse Indigo和Juno。为了正常运行，用户需要下载Activiti...
数据结构----栈
新手嵌入式学习的博客
08-19 896
数据结构顺序栈和链式栈。
集合及数据结构第三节————包装类和简单认识泛型
2301_79418684的博客
08-19 1110
包装类和简单认识泛型 1. 基本数据类型和对应的包装类 2. 装箱和拆箱 3. 泛型 4. 泛型类的使用 5. 裸类型(Raw Type) （了解） 6. 泛型如何编译的 7. 泛型的上界 8. 泛型方法
重新理解操作系统（linux）、编程语言和算法与数据结构
crawer
08-23 302
怎样理解操作系统（linux）、编程语言和算法与数据结构
【数据结构】线性表的顺序表示（顺序表的定义和基本操作）
zhousanguhe的博客
08-23 274
线性表的顺序表示（顺序表的定义和基本操作：初始化/插入/删除/查找）
数据结构（邓俊辉）学习笔记】优先级队列 06——完全二叉堆：批量建堆
weixin_44399845的博客
08-18 818
完全二叉堆：批量建堆
数据结构（邓俊辉）学习笔记】优先级队列 08——左式堆：结构
weixin_44399845的博客
08-23 705
学习左式堆的结构
《征服数据结构》LRU缓存
数据结构和算法
08-22 188
摘要：1，LRU的介绍2，LRU元素的添加3，LRU元素的读取4，LRU完整代码实现1，LRU的介绍LRU(Least Recently Used)最近最少使用，它是一种缓存淘汰策略。也就是说在缓存容量满的时候，我们需要删除一些元素，删除的原则就是越久没被使用的越容易被删除。举个简单例子，比如你桌子上的书堆满了，需要拿掉一部分，你肯定是优先拿掉那些很久没有看的书，经常看的书肯定会优先留下来。LRU...
集合及数据结构第十节（上）————优先级队列，堆的创建、插入、删除与用堆模拟实现优先级队列
2301_79418684的博客
08-23 491
优先级队列，堆的创建、插入、删除与用堆模拟实现优先级队列 1. 优先级队列的概念 2. 堆的概念 3. 堆的存储方式 4. 堆的创建 5. 变量的作用域和生命周期 6. 用堆模拟实现优先级队列
集合及数据结构第九节————树和二叉树
2301_79418684的博客
08-23 779
树和二叉树 1. 树型结构的概念 2. 树的概念 3. 树的表示形式（了解） 4. 树的应用 5. 二叉树的概念 6. 两种特殊的二叉树 7. 二叉树的性质 8. 二叉树的性质练习 9. 二叉树的存储 10. 二叉树的遍历 11. 二叉树的基本操作 12. 二叉树相关练习题
数据结构(6_3_1)——图的广度优先遍历
m0_65240792的博客
08-23 196
注:以下代码只适合连通图 练习： 代码： 结论：对于无向图，调用BFS函数的次数=连通分量数
C，数据结构，多进程线程，网络编程面试题总结
没有百宝袋的哆啦A梦的博客
08-20 1171
面试题
MySQL索引详解：原理、数据结构与分析和优化
2301_78183352的博客
08-23 259
MySQL索引是提升数据库性能的重要工具。通过深入理解索引的原理、数据结构及其优化策略，我们可以更加合理地设计和使用索引，从而提高数据库查询效率、降低I/O成本。在未来的数据库管理和优化过程中，我们应继续关注索引技术的发展和应用，以应对日益增长的数据处理需求。
数据结构系列-快速排序
in_seattle的博客
08-23 425
我们首先仍是一样的，将初始位置的值定义为key，定义prev和cur，然后在cur指向的值不超过key的前提下，cur走一步，prev走一步，在什么时候二者分开呢？那就是当cur指向的值超过key的时候，然后当cur的值小于key的时候，二者发生交换，并在最后当cur越界的时候，prev和key进行交换。然后让右边先走，找到比key小的数字，然后左边再走，找到比key大的数字，然后两个发生交换，最后两者相遇，相遇位置就是key的位置的数字应该存在的位置。下面，我们具体说一下，前后指针法的实现逻辑。
数据结构（邓俊辉）学习笔记】优先级队列 09——左式堆：合并算法
最新发布
weixin_44399845的博客
08-23 543
学习下左式堆的合并算法
如何在Java中实现一个高效的排序算法。
probably121的博客
08-23 478
归并排序是一种分而治之的算法，它将一个大数组分成两个较小的子数组，然后对每个子数组进行排序，最后将这两个已排序的子数组合并成一个有序数组。归并排序的时间复杂度为O(n log n)，其中n是数组的长度。这是因为归并排序每次将数组分成两半，所以深度为log n，每一层都需要遍历所有元素，因此总的操作次数为n log n。// 复制数据到临时数组 L[] 和 R[]// 分别对左右两半进行递归排序。// 合并临时数组回arr[l..r]// 复制L[]的剩余元素。// 复制R[]的剩余元素。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值