数据结构/作业/2024/7/7

搭建个场景:
将学生的信息,以顺序表的方式存储(堆区),并且实现封装函数︰1】顺序表的创建,
2】判满、
3】判空、
4】往顺序表里增加学生、5】遍历、
6】任意位置插入学生、7】任意位置删除学生、8】修改、
9】查找(按学生的学号查找)、10】去重、
11】销毁顺序表
 

main.c

#include "head.h"
int main(int argc,const char *argv[])
{//创建学生的顺序表seqlist_ptr p=create_list();//判断顺序表是否为满int p1=full_doubt(p);//判断顺序表是否为空int p2=empty_doubt(p);//顺序表中添加学生数据add(p,6666);add(p,1001);add(p,1002);add(p,1003);add(p,1004);//顺序表中输出学生数据               output(p);//在任意位置插入学生insert(p,3,1111); output(p);//删除任意位置的学生del(p,3);output(p);//更改学生IDchange_index(p,3,6666);output(p);//查找学生IDfind(p,6666);//去重del_same(p);output(p);//释放my_free(p);return 0;
}

fun.c

  1 #include "head.h"                                                                                      2                                                                                                        3                                                                                                        4 //1.创建学生的顺序表                                                                                   5 seqlist_ptr create_list()                                                                              6 {                                                                                                      7     //申请堆区的空间                                                                                   8     seqlist_ptr p=(seqlist_ptr)malloc(sizeof(seqlist));                                                9     if(NULL==p)                                                                                        10     {                                                                                                  11         printf("顺序表创建失败\n");                                                                    12         return NULL;                                                                                   13     }                                                                                                  14                                                                                                        15     p->len=0;//将顺序表中的长度清零                                                                    16     //将数组的长度清零                                                                                 17     memset(p->ID,0,sizeof(p->ID));                                                                     18     printf("创建顺序表成功\n");                                                                        19     return p;                                                                                          20 }                                                                                                      21                                                                                                        22                                                                                                        23 //2.判断顺序表是否为满                                                                                 24 int full_doubt(seqlist_ptr p)                                                                          25 {                                                                                                      26     if(NULL==p)                                                                                        27     {                                                                                                  28         printf("顺序表不合法,无法判断");                                                               29         return -1;                                                                                     30     }                                                                                                  31     else if(p->len==MAX)                                                                               32     {                                                                                                  33         printf("顺序表满\n");                                                                          34         return 1;                                                                                      35     }                                                                                                  36                                                                                                        37     return 0;                                                                                          38 }                                                                                                      39                                                                                                        40                                                                                                        41 //3.判断顺序表是否为空                                                                                 42 int empty_doubt(seqlist_ptr p)                                                                         43 {                                                                                                      44     if(NULL==p)                                                                                        45     {                                                                                                  46         printf("顺序表不合法,无法判断");                                                               47     }                                                                                                  48     else if(p->len==0)                                                                                 49     {                                                                                                  50         printf("顺序表为空\n");                                                                        51         return 1;                                                                                      52     }                                                                                                  53     return 0;                                                                                          54 }                                                                                                      55                                                                                                        56                                                                                                        57 //4.顺序表数据的增加(添加学生的id号)                                                                   58 int add(seqlist_ptr p,datatype a)                                                                      59 {                                                                                                      60     if(NULL==p || full_doubt(p))                                                                       61     {                                                                                                  62         printf("无法增加\n");                                                                          63         return 0;                                                                                      64     }                                                                                                  65     p->ID[p->len]=a;                                                                                   66     p->len++;                                                                                          67     return 1;                                                                                          68 }                                                                                                      69                                                                                                        70                                                                                                        71 //5.顺序表中输出学生数据                                                                               72 int output(seqlist_ptr p)                                                                              73 {                                                                                                      74     if(NULL==p || empty_doubt(p))                                                                      75     {                                                                                                  76         printf("无法输出i\n");                                                                         77         return 0;                                                                                      78     }                                                                                                  79     for(int i=0;i<p->len;i++)                                                                          80     {                                                                                                  81         printf("%d    ",p->ID[i]);                                                                     82     }                                                                                                  83     printf("\n");                                                                                      84     return 1;                                                                                          85 }                                                                                                      86                                                                                                        87                                                                                                        88 //6.在任意位置插入学生数据                                                                             89 int insert(seqlist_ptr p,int index,datatype e)                                                         90 {                                                                                                      91     if(NULL==p || index>=MAX || index<=0 || empty_doubt(p))                                            92     {                                                                                                  93         printf("插入失败\n");                                                                          94         return -1;                                                                                     95     }                                                                                                  96     //此时的index表示数组的下标                                                                        97     index-=1;                                                                                          98     for(int i=0;i<p->len-index;i++)                                                                    99     {   //p->len表示未赋值的那个元素                                                                   
100         p->ID[p->len-i]=p->ID[p->len-1-i];                                                             
101     }                                                                                                  
102     //赋值                                                                                             
103     p->ID[index]=e;                                                                                    
104     //长度+1                                                                                           
105     p->len++;                                                                                          
106     return 1;                                                                                          
107 }                                                                                                      
108                                                                                                        
109                                                                                                        
110 //7.删除任意位置的学生                                                                                 
111 int del(seqlist_ptr p,int index)                                                                       
112 {                                                                                                      
113     if(NULL==p || index>MAX || index<=0 || empty_doubt(p))                                             
114     {                                                                                                  
115         printf("删除失败\n");                                                                          
116         return -1;                                                                                     
117     }                                                                                                  
118     //此时index表示数组的下标                                                                          
119     index-=1;                                                                                          
120     for(int i=index;i<p->len;i++)                                                                      
121     {                                                                                                  
122         p->ID[index]=p->ID[index+1];                                                                   
123     }                                                                                                  
124     p->len--;                                                                                          
125     return 1;                                                                                          
126 }                                                                                                      
127                                                                                                        
128                                                                                                        
129 //8.任意位置更改学生ID                                                                                 
130 int change_index(seqlist_ptr p,int index,datatype e)                                                   
131 {                                                                                                      
132     if(NULL==p || index>MAX || index <=0 || empty_doubt(p))                                            
133     {                                                                                                  
134         printf("更改失败\n");                                                                          
135         return -1;                                                                                     
136     }                                                                                                  
137     index-=1;                                                                                          
138     p->ID[index]=e;                                                                                    
139     return 1;                                                                                          
140 }                                                                                                      
141                                                                                                        
142                                                                                                        
143 //9.查找学生ID                                                                                         
144 int find(seqlist_ptr p,datatype e)                                                                     
145 {                                                                                                      
146     if(NULL==p || empty_doubt(p))                                                                      
147     {                                                                                                  
148         printf("查找失败\n");                                                                          
149         return -1;                                                                                     
150     }                                                                                                  
151     int flag=0;                                                                                        
152     for(int i=0;i<p->len;i++)                                                                          
153     {                                                                                                  
154         if(p->ID[i]==e)                                                                                
155         {                                                                                              
156             flag=1;                                                                                    
157             printf("查找的学生是第%d位学生\n",i+1);                                                    
158             return i;                                                                                  
159         }                                                                                              
160                                                                                                        
161         if(flag=0)                                                                                     
162         {                                                                                              
163             printf("未查找到学生ID\n");                                                                
164             return 0;                                                                                  
165         }                                                                                              
166     }                                                                                                  
167 }                                                                                                      
168                                                                                                        
169                                                                                                        
170 //10.去重                                                                                              
171 int del_same(seqlist_ptr p)                                                                            
172 {                                                                                                      
173     if(NULL==p || empty_doubt(p))                                                                      
174     {                                                                                                  
175         printf("去重失败\n");                                                                          
176         return -1;                                                                                     
177     }                                                                                                  
178     for(int i=0;i<p->len;i++)                                                                          
179     {                                                                                                  
180         for(int j=i+1;j<p->len;j++)                                                                    
181         {                                                                                              
182             if(p->ID[i]==p->ID[j])                                                                     
183             {                                                                                          
184                 del(p,j+1);                                                                            
185                 j--;                                                                                   
186             }                                                                                          
187         }                                                                                              
188     }                                                                                                  
189     return 1;                                                                                          
190 }                                                                                                      
191                                                                                                        
192                                                                                                        
193 //11 释放                                                                                              
194 int my_free(seqlist_ptr p)                                                                             
195 {                                                                                                      
196     if(NULL==p)                                                                                        
197     {                                                                                                  
198         printf("释放失败\n");                                                                          
199         return -1;                                                                                     
200     }                                                                                                  
201     free(p);                                                                                           
202         printf("释放成功\n");                                                                          
203     return 1;                                                                                          
204                                                                                                        
205 }                                                                                                      
~                                                                                                          

head.h

#ifndef __HEAD_H__                                   
#define __HEAD_H__                                   
#include <stdio.h>                                   
#include <stdlib.h>                                  
#include <string.h>                                  
//顺序标容器存储学生个数的最大值                     
#define MAX 30                                       
//宏替换ID的数据类型                                 
typedef int datatype;                                
//创建顺序表用于存储学生的信息                       
typedef struct sequence                              
{                                                    datatype ID[MAX];                                //存储学生的个数                                 int len;                                         
}seqlist,*seqlist_ptr;                               //1.创建学生的顺序表                                 
seqlist_ptr create_list();                           
//2.判断顺序表是否为满                               
int full_doubt(seqlist_ptr p);                       
//3.判断顺序表是否为空                               
int empty_doubt(seqlist_ptr p);                      
//4.顺序表数据的增加(添加学生的id号)                 
int add(seqlist_ptr p,datatype a);                   
//5.顺序表中输出学生数据                             
int output(seqlist_ptr p);                           
//6.在任意位置插入学生数据                           
int insert(seqlist_ptr p,int index,datatype e);      
//7.删除任意位置的学生                               
int del(seqlist_ptr p,int index);                    
//8.任意位置更改学生ID                               
int change_index(seqlist_ptr p,int index,datatype e);
//9.查找学生ID                                       
int find(seqlist_ptr p,datatype e);                  
//10.去重                                            
int del_same(seqlist_ptr p);                         
//11 释放                                            
int my_free(seqlist_ptr p);                          
#endif                                               

 

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/867973.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

网络安全基础-2

知识点 1.网站搭建前置知识 域名&#xff0c;子域名&#xff0c;DNS&#xff0c;HTTP/HTTPS&#xff0c;证书等 注册购买域名&#xff1a;阿里云企航_万网域名_商标注册_资质备案_软件著作权_网站建设-阿里云 2.web应用环境架构类 理解不同WEB应用组成角色功能架构: 开发语…

DHCP的原理及配置

目录 一、了解DHCP服务 1.什么是DHCP 1.1DHCP广播 2.使用DHCP的好处 2.1为什么使用DHCP 3.DHCP的模式与分配方式 3.1分配方式 3.2模式 二、DHCP工作原理 1.四次回话 2.重新登录 3.更新租约 4.扩展 三、安装DHCP服务 四、DHCP局部配置并且测试 五、使用…

7.Android逆向协议-抓取安卓http和https数据包(设备需要root权限)

免责声明&#xff1a;内容仅供学习参考&#xff0c;请合法利用知识&#xff0c;禁止进行违法犯罪活动&#xff01; 内容参考于&#xff1a;微尘网校 上一个内容&#xff1a;6.Android逆向协议-配置FD抓包环境 工具下载&#xff1a; 链接&#xff1a;https://pan.baidu.com/s…

Nestjs基础

一、创建项目 1、创建 安装 Nest CLI&#xff08;只需要安装一次&#xff09; npm i -g nestjs/cli 进入要创建项目的目录&#xff0c;使用 Nest CLI 创建项目 nest new 项目名 运行项目 npm run start 开发环境下运行&#xff0c;自动刷新服务 npm run start:dev 2、…

GuitarPro2024音乐软件#创作神器#音乐梦想

嘿&#xff0c;亲爱的朋友们&#xff01;&#x1f44b;&#x1f44b;&#x1f44b;今天我要给你们安利一款超赞的软件——Guitar Pro。这款软件简直是吉他手的福音啊&#xff01;&#x1f389;&#x1f389;&#x1f389; Guitar Pro免费绿色永久安装包下载&#xff1a;&#…

YOLOv8 | 代码逐行解析(五) | YOLOv8中损失函数计算的详解包含Cls和Bbox计算的解析,小白必看(下)

一、本文介绍 本文给大家带来的是YOLOv8中的损失函数计算的完整解析&#xff0c;内容包括v8DetectionLoss的解析&#xff0c;以及BboxLoss的解析&#xff0c;如果你相对损失函数的计算原理&#xff0c;本文内容绝对会对你有所帮助&#xff0c;全文内容包含1万两千字&#xff0…

(十) Docker compose 本地部署 apollo

文章目录 1、apollo2、数据库准备3、启动后会用到的几个地址4、docker-compose运行 apollo方式一&#xff1a;使用容器 hostName 作为网络媒介方式二&#xff1a;使用端口映射固定 ip 作为网络媒介 6、客户端 1、apollo https://www.apolloconfig.com/#/zh/deployment/quick-s…

使用策略模式加工厂模式实现数据上传时的不同云平台的处理

在处理不同云存储的 SDK 和接口调用时可以使用策略模式加工厂模式实现了灵活的云存储上传处理 策略模式&#xff1a;可以为每个云存储&#xff08;如阿里云、腾讯云等&#xff09;创建一个策略类&#xff0c;实现统一的接口&#xff0c;来封装不同的上传逻辑。工厂模式&#x…

【代码管理的必备工具:Git的基本概念与操作详解】

一、Git 初识 1.提出问题 不知道你工作或学习时&#xff0c;有没有遇到这样的情况&#xff1a;我们在编写各种⽂档时&#xff0c;为了防止⽂档丢失&#xff0c;更改失误&#xff0c;失误后能恢复到原来的版本&#xff0c;不得不复制出⼀个副本&#xff0c;比如&#xff1a; “…

敏感词匹配DFA算法

算法简介与场景介绍 DFA算法&#xff0c;中文全称为确定性有穷自动机。它的基本思想是构建一个有穷自动机&#xff0c;当用户输入文本时&#xff0c;通过自动机的状态转换来快速匹配敏感词。具体特征是&#xff0c;有一个有效状态的集合和一些从一个状态通向另一个状态的边&am…

VuePress 的更多配置

现在&#xff0c;读者应该对 VuePress、主题和插件等有了基本的认识&#xff0c;除了插件&#xff0c;VuePress 自身也有很多有用的配置&#xff0c;这里简单说明下。 ‍ ‍ VuePress 的介绍 在介绍了 VuePress 的基本使用、主题和插件的概念之后&#xff0c;我们再来看看官…

简介空间复杂度

我们承接上一篇博客。我们写了时间复杂度之后&#xff0c;我们就要来介绍一下另一个相关复杂度了。空间复杂度。我觉得大家应该对空间复杂度认识可能比较少一些。我就是这样&#xff0c;我很少看见题目中有明确要求过空间复杂度的。但确实有这个是我们不可忽视的&#xff0c;所…

PXIe-7976【K410T】

起售价 RMB 152,880.00 块RAM(BRAM): 28620 kbit 动态RAM(DRAM): 2 GB FPGA: Kintex-7 410T PXI背板链路: PCI-Express Gen2 x 8 FPGA片: 63550 DSP片: 1540

ChatGPT-4o大语言模型优化、本地私有化部署、从0-1搭建、智能体构建等高级进阶

目录 第一章 ChatGPT-4o使用进阶 第二章 大语言模型原理详解 第三章 大语言模型优化 第四章 开源大语言模型及本地部署 第五章 从0到1搭建第一个大语言模型 第六章 智能体&#xff08;Agent&#xff09;构建 第七章 大语言模型发展趋势 第八章 总结与答疑讨论 更多应用…

昇思25天学习打卡营第12天|FCN图像语义分割

文章目录 昇思MindSpore应用实践基于MindSpore的FCN图像语义分割1、FCN 图像分割简介2、构建 FCN 模型3、数据预处理4、模型训练自定义评价指标 Metrics 5、模型推理结果 Reference 昇思MindSpore应用实践 本系列文章主要用于记录昇思25天学习打卡营的学习心得。 基于MindSpo…

LaTeX教程(014)-LaTeX文档结构(14)

LaTeX教程(014)- LaTeX \LaTeX LATE​X文档结构(14) 2.3.3 multitoc - 将目录设置为多栏 multitoc包的使用方法相当简单&#xff0c;只需要调用这个包&#xff0c;并将要设置为多栏(默认是双栏)的目录指定到包选项中即可。如\usepackage[toc]{multitoc}&#xff0c;设置的就是…

Springboot使用WebSocket发送消息

1. 创建springboot项目&#xff0c;引入spring-boot-starter-websocket依赖 <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-websocket</artifactId></dependency>完整项目依赖 <?xml ver…

Vue 使用 @click 绑定点击事件

https://andi.cn/page/621505.html

Python【打包exe文件两步到位】

Python打包Exe 安装 pyinstaller&#xff08;pip install pyinstaller&#xff09; 执行打包命令&#xff08;pyinstaller demo.py&#xff09; 打完包会生成 dist 文件夹&#xff0c;如下如

基于开源AI数据框架LlamaIndex构建上下文增强型LLA应用

引言 “将你的企业数据转化为可用于实际生产环境的LLM应用程序&#xff0c;”LlamaIndex主页用60号字体这样高亮显示。其副标题是“LlamaIndex是构建LLM应用程序的领先数据框架。”我不太确定它是否是业内领先的数据框架&#xff0c;但我认为它是一个与LangChain和Semantic Ker…