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

链表的相关操作作业:

1】 按值修改

2】按值查找,返回当前节点的地址 (先不考虑重复,如果有重复,返回第一个)

3】 逆置(反转)

4】释放链表

main.c

#include "head.h"

int main(int argc, const char *argv[])
{
    //创建链表,头结点
    linklist_ptr p=create();
    //判断链表是否为空
    empty(p);
    //头插
    insert_head(p,10);
    insert_head(p,11);
    insert_head(p,12);
    //输出
    output(p);
    //尾插
    insert_tail(p,1);
    insert_tail(p,2);
    insert_tail(p,3);
    output(p);
    //任意位置插入
    insert_index(p,2,99);
    output(p);
    //头删
    del_head(p);
    output(p);
    //尾删除                             
    del_tail(p);
    output(p);
    //任意位置删除
    del_index(p,2);
    output(p);
    //按照所给位数修改值
    change_element(p,1,99);
    output(p);
    //按照所给的值查找
    find_element(p,1);

    output(p);
    //反转
    reversal(p);
    output(p);
    return 0;
}

head.h

#include <stdio.h>                                       
#include <stdlib.h>                                      
//定义节点数据的类型                                     
typedef int datatype;                                    
//定义链表结构体                                         
typedef struct node                                      
{                                                        
    union                                                
    {                                                    
        //表示节点的个数                                 
        int len;                                         
        //节点的数据                                     
        datatype data;                                   
    };                                                   
    //指针域                                             
    struct node *next;                                   
}linklist,*linklist_ptr;                                 
                                                         
                                                         
//1.链表的创建                                           
linklist_ptr create();                                   
//2.判断链表是否为空                                     
int  empty(linklist_ptr p);                              
//3.申请节点封装数据                                     
linklist_ptr node_create(datatype e);                    
//4.头插                                                 
int insert_head(linklist_ptr p,datatype e);              
//5.输出                                                 
void output(linklist_ptr p);                             
//6.尾插                                                 
int insert_tail(linklist_ptr p,datatype e);              
//7.任意位置插入                                         
int insert_index(linklist_ptr p,int index,datatype e);   
//8.头删                                                 
int del_head(linklist_ptr p);                            
//9.尾删除                                               
int del_tail(linklist_ptr p);                            
//10.任意位置删除                                        
int del_index(linklist_ptr p,int index);                 
//11.按照所给的值修改                                    
int change_element(linklist_ptr p,int index,datatype e); 
//12.按照所给的值查找                                    
linklist_ptr find_element(linklist_ptr p,datatype e);    
//13.反转                                                
int  reversal(linklist_ptr p);                           
#endif                                                   

fun.c

    {                                                                         
        q=q->next;                                                            
    }                                                                         
    q->next=p1;                                                               
    p->len++;                                                                 
    return 1;                                                                 
}                                                                             
                                                                              
                                                                              
//7.任意位置插入                                                              
int insert_index(linklist_ptr p,int index,datatype e)                         
{                                                                             
    if(NULL==p || index<1 || index>p->len+1)                                  
    {                                                                         
        printf("尾插失败\n");                                                 
        return -1;                                                            
    }                                                                         
    //申请节点                                                                
    linklist_ptr p1=node_create(e);                                           
    linklist_ptr q=p;                                                         
    for(int i=0;i<index;i++)                                                  
    {                                                                         
        q=q->next;                                                            
    }                                                                         
    p1->next=q->next;                                                         
    q->next=p1;                                                               
    p->len++;                                                                 
    return 1;                                                                 
}                                                                             
                                                                              
                                                                              
//8.头删                                                                      
int del_head(linklist_ptr p)                                                  
{                                                                             
    if(NULL==p || empty(p))                                                   
    {                                                                         
        printf("头删失败\n");                                                 
    }                                                                         
    //定义一个指针指向头指针指向的节点                                        
    linklist_ptr p1=p->next;                                                  
    p->next=p1->next;                                                         
    free(p1);                                                                 
    p1=NULL;                                                                  
                                                                              
    p->len--;                                                                 
    return 1;                                                                 
                                                                              
}                                                                             
                                                                              
                                                                              
//9.尾删除                                                                    
int del_tail(linklist_ptr p)                                                  
{                                                                             
    if(NULL==p || empty(p))                                                   
    {                                                                         
        printf("尾删失败\n");                                                 
        return 0;                                                             
    }                                                                         
    //定义一个指针指向头结点并让其循环到最后一个节点的前一个节点              
    linklist_ptr p1=p;                                                        
    for(int i=0;i<p->len-1;i++)                                               
    {                                                                         
        p1=p1->next;                                                          
    }                                                                         
    //指向需要删除最后一个节点                                                
    linklist_ptr p2=p1->next;                                                 
    p1->next=p1->next;                                                        
    //释放                                                                    
    free(p2);                                                                 
    p2=NULL;                                                                  
    p->len--;                                                                 
    return 1;                                                                 
}                                                                             
                                                                              
//10.任意位置删除                                                             
int del_index(linklist_ptr p,int index)                                       
{                                                                             
    if(NULL==p || empty(p) || index>p->len ||index<0)                         
    {                                                                         
        printf("任意位置删除失败\n");                                         
        return 0;                                                             
    }                                                                         
    //定义一个指针指向头结点用于循环到所需要                                  
    //的位置的上一个节点                                                      
    linklist_ptr p1=p;                                                        
    for(int i=0;i<index-1;i++)                                                
    {                                                                         
        p1=p1->next;                                                          
    }                                                                         
    //定义一个指针指向需要被删除的节点                                        
    linklist_ptr p2=p1->next;                                                 
    p1->next=p2->next;                                                        
    //释放                                                                    
    free(p2);                                                                 
    p2=NULL;                                                                  
    p->len--;                                                                 
    return 1;                                                                 
}                                                                             
                                                                              
                                                                              
//11.按照所给的值修改                                                         
int change_element(linklist_ptr p,int index,datatype e)                       
{                                                                             
    if(NULL==p || empty(p) || index>p->len || index<0)                        
    {                                                                         
        printf("任意位置修改失败\n");                                         
        return 0;                                                             
    }                                                                         
    //定义一个指针找到所需要的修改的节点                                      
    linklist_ptr p1=p;                                                        
    for(int i=0;i<index;i++)                                                  
    {                                                                         
        p1=p1->next;                                                          
    }                                                                         
    //修改其中的值                                                            
    p1->data=e;                                                               
                                                                              
}                                                                             
                                                                              
                                                                              
//12.按照所给的值查找                                                         
linklist_ptr find_element(linklist_ptr p,datatype e)                          
{                                                                             
    if(NULL==p || empty(p))                                                   
    {                                                                         
        printf("查找值失败\n");                                               
        return NULL;                                                          
    }                                                                         
    //记录相同的次数                                                          
    int flag=0;                                                               
    //循环查找                                                                
    linklist_ptr p1=p;                                                        
    for(int i=0;i<p->len;i++)                                                 
    {                                                                         
        p1=p1->next;                                                          
        if(p1->data==e)                                                       
        {                                                                     
            printf("第%d个元素的值相等\n",i+1);                               
            flag++;                                                           
        }                                                                     
        if(flag==1)                                                           
        {                                                                     
            return p1;                                                        
        }                                                                     
                                                                              
    }                                                                         
         if(flag==0)                                                          
        {                                                                     
            printf("未查找到相应的值\n");                                     
        }                                                                     
    return p;                                                                 
}                                                                             
                                                                              
                                                                              
//13.反转                                                                     
int  reversal(linklist_ptr p)                                                 
{                                                                             
    if(NULL == p || empty(p))                                                 
    {                                                                         
        printf("反转失败\n");                                                 
        return 0;                                                             
    }                                                                         
                                                                              
    linklist_ptr p1 = p->next; // 保存第1个节点的地址                         
    p->next = NULL; // 断开原头结点的连接(使其成为反转后的链表的尾节点)     
    linklist_ptr p2;                                                          
    while(p1->next!=NULL)                                                     
    {                                                                         
        p2 = p1; // 将当前节点保存到p2,以便将其插入到头部                    
        p1 = p1->next; // 移动到下一个节点                                    
        p2->next = p->next; // 将p2插入到p之前(使p2成为新的头结点)          
        p->next = p2; // 更新p为新插入的节点(更新头结点)                    
    }                                                                         
                                                                              
    return 1; // 返回反转后链表的新头结点                                     
}                                                                             

 

 

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

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

品牌文化五大维度,构建品牌竞争力的秘诀!

品牌文化对于企业的发展和成功至关重要。 品牌文化不仅是企业和消费者之间的纽带&#xff0c;也是企业内部员工的凝聚力。 在当今竞争激烈的市场环境中&#xff0c;建立一个有活力和影响力的品牌文化是每个企业都需要认真思考和实践的事情。 品牌文化的五大维度包括价值观、…

VMware vSAN替换存储解决方案如何选择?

What is vSAN &#xff1f; 是一款软件定义的企业存储解决方案&#xff0c;支持超融合基础架构系统。vSAN与VMware vSphere 完全集成在一起&#xff0c;作为ESXi Hypervisor内的分布式软件层&#xff0c;通过整合、池化ESXi各个主机上的存储资源&#xff0c;为vSphere虚拟化平…

医疗器械网络安全| 常见安全漏洞与防护措施

医疗器械网络安全顾问​https://link.zhihu.com/?targethttps%3A//www.wanyun.cn/Support%3Fshare%3D24315_ea8a0e47-b38d-4cd6-8ed1-9e7711a8ad5e 一、常见安全漏洞 医疗器械软件在现代医疗体系中扮演着至关重要的角色&#xff0c;然而&#xff0c;随着技术的不断发展&…

(2)滑动窗口算法练习:无重复字符的最长子串

无重复字符的最长子串 题目链接&#xff1a;3. 无重复字符的最长子串 - 力扣&#xff08;LeetCode&#xff09; 给定一个字符串 s &#xff0c;请你找出其中不含有重复字符的最长子串的长度。 输入: s "abcabcbb" 输出: 3 解释: 因为无重复字符的最长子串是"a…

计算机网络知识汇总

目录 前言 概述 1、互联网的组成 2、端系统之间的两种通信方式 1、客户-服务器方式 2、对等连接方式&#xff08;P2P&#xff09; 3、交换技术 4、时延 5、利用率 6、协议 7、计算机网络体系结构 8、ISP 物理层 链路层 网络层 传输层 应用层 前言 最近准备找工作…

Linux 网络--TCP协议收包流程(NAPI机制)

Linux 网络--TCP协议收包流程&#xff08;NAPI机制&#xff09; 平台环境简介&#xff1a;宿主机: ubuntu18.04Linux内核源码版本: Linux-4.15网卡驱动: Intel e1000 &#xff08;ubuntu 虚拟机默认网卡驱动&#xff09;协议&#xff1a;TCP协议&#xff0c;本文分析收包过程 本…

Python编程学习笔记(3)--- 操作列表

1、遍历列表 遍历列表可以采用for循环的方法&#xff0c;需要对列表中的每一个元素都执行相同的操作。 具体事实如下&#xff1a; name ["ada","cdb","dbc","bad","jinb"] for Name in name:print(Name)运行结果&#x…

html H5 dialog弹窗学习,实现弹窗显示内容 替代confirm、alert

html H5 dialog弹窗学习,实现弹窗内容 替代confirm 框架使用的mui,使用mui.confirm() 弹窗内容过多时,弹窗被撑的到屏幕外去了,使用H5 dialog 标签自定义一个固定大小的弹窗,内容过多时可下拉显示 效果展示 隐私政策内容很多,可以下拉显示 代码 myDialog.css dialog{p…

tomcat 项目迁移,无法将项目作为服务service启动

背景 测试服务器需要迁移到正式服务器上&#xff0c;为了方便省事&#xff0c;将测试服务器上的一些文件直接复制到正式服务器 问题 使用startup启动项目之后&#xff0c;可以直接使用使用tomcat9w启动&#xff0c;或者作为服务service启动的时候&#xff0c;显示无法访问到资源…

STM32实战篇:按键控制LED

按键控制LED 功能要求 有两个按键&#xff0c;分别控制两个LED灯。当按键按下后&#xff0c;灯的亮暗状态改变。实物如下图所示&#xff1a; 由图可知&#xff0c;按键一端直接接地&#xff0c;故另一端所对应IO引脚的输入模式应该为上拉输入模式。 实现代码 #include "…

昇思25天学习打卡营第1天|小试牛刀

这里写自昇思25天学习打卡营第1天|小试牛刀定义目录标题 昇思25天学习打卡营第1天学习了初学入门之基本介绍。了解了昇思MindSpore和华为昇腾AI全栈。训练营中的教程丰富&#xff0c;有初学入门、应用实践和量子计算等。学习打卡营是很好的提升自己的机会。 昇腾计算&#xff…

电脑清理c盘内存空间怎么清理免费 怎么清理c盘的垃圾文件又不删除有用文件

在计算机使用过程中&#xff0c;随着时间的推移&#xff0c;C盘空间可能会被各种临时文件、缓存和无用的注册表项占用。这不仅会导致C盘空间不足&#xff0c;还可能影响计算机的性能。那么怎么样清理C盘内存空间&#xff0c;怎么样清理C盘的垃圾避开系统文件呢&#xff1f; 一…

JVM原理(二三):JVM虚拟机线程安全的实现方法

1. 互斥同步 互斥同步(MutualExclusion&Synchronization)是一种最常见也是最主要的并发正确性保障手段。同步是指在多个线程并发访问共享数据时&#xff0c;保证共享数据在同一个时刻只被一条(或者是一些&#xff0c;当使用信号量的时候)线程使用。而互斥是实现同步的一种…

Msfvenom制作自己的专属Shell

Msfvenom制作自己的专属Shell 如何通过Msfvenom来生成用户自己的专属Shell?有时候我们上传Shell到目标主机后&#xff0c;不仅我们自己可以连接&#xff0c;其他用户也可以连接&#xff0c;有时候会导致我们丢失该Shell&#xff0c;甚至该shell被用户发现并查杀。 实验环境 …

数据仓库哈哈

数据仓库 基本概念数据库&#xff08;database&#xff09;和数据仓库&#xff08;Data Warehouse&#xff09;的异同 整体架构分层架构方法论ER模型&#xff08;建模理论&#xff09;维度模型 何为分层第一层&#xff1a;数据源&#xff08;ODS ER模型&#xff09;设计要点日志…

C++进阶:继承和多态

文章目录 ❤️继承&#x1fa77;继承与友元&#x1f9e1;继承和静态成员&#x1f49b;菱形继承及菱形虚拟继承&#x1f49a;继承和组合 ❤️多态&#x1fa77;什么是多态&#xff1f;&#x1f9e1;多态的定义以及实现&#x1f49b;虚函数&#x1f49a;虚函数的重写&#x1f499…

图论·Day01

P3371 P4779 P3371 【模板】单源最短路径&#xff08;弱化版&#xff09; 注意的点&#xff1a; 边有重复&#xff0c;选择最小边&#xff01;对于SPFA算法容易出现重大BUG&#xff0c;没有负权值的边时不要使用&#xff01;&#xff01;&#xff01; 70分代码 朴素板dijsk…

打卡第7天-----哈希表

继续坚持✊,我现在看到leetcode上的题不再没有思路了,真的是思路决定出路,在做题之前一定要把思路梳理清楚。 一、四数相加 leetcode题目编号:第454题.四数相加II 题目描述: 给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ,使得 A[i] + B[j…

蚁群算法(Ant Colony Optimization,ACO)讲解+代码实现

1.蚁群算法来源 蚁群算法&#xff08;Ant Colony Optimization&#xff0c;简称ACO&#xff09;是一种模拟自然界中蚂蚁寻找食物路径行为的优化算法&#xff0c;主要用于解决组合优化问题。它的灵感来源于意大利学者Marco Dorigo在1992年提出的蚂蚁系统模型。 蚁群算法的灵感来…

应急响应——勒索病毒

先上搜索引擎上搜 也可以用360来杀 但是都无法解密 可以解密的&#xff1a; linux