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

news2024/9/20 18:33:21

链表的相关操作作业:

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.coloradmin.cn/o/1911737.html

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

相关文章

6.Python学习:异常和日志

1.异常的抓取 1.1异常的概念 使用异常前&#xff1a; print(1/0)使用异常后&#xff1a;错误提示更加友好&#xff0c;不影响程序继续往下运行 try:print(10/0) except ZeroDivisionError:print("0不能作为分母")1.2异常的抓取 第一种&#xff1a;如果提前知道可…

微软清华提出全新预训练范式,指令预训练让8B模型实力暴涨!实力碾压70B模型

现在的大模型训练通常会包括两个阶段&#xff1a; 一是无监督的预训练&#xff0c;即通过因果语言建模预测下一个token生成的概率。该方法无需标注数据&#xff0c;这意味着可以利用大规模的数据学习到语言的通用特征和模式。 二是指令微调&#xff0c;即通过自然语言指令构建…

核密度估计KDE和概率密度函数PDF(深入浅出)

目录 1. 和密度估计&#xff08;KDE&#xff09;核密度估计的基本原理核密度估计的公式核密度估计的应用Python中的KDE实现示例代码 结果解释解释结果 总结 2. 概率密度函数&#xff08;PDF&#xff09;概率密度函数&#xff08;PDF&#xff09;是怎么工作的&#xff1a;用图画…

数据类型及数据块认知

西门子STEP7编程语言 梯形图(LAD) 功能块图(FBD) 语句表(STL) 其中梯形图和功能块图可以相互转换 CPU常用数据区 信号输入区 I 信号输出区 Q 程序中表现形式&#xff0c;IX.X/QX.X;IWX/QWX-访问的是CPU输出输入过程映像区 另一种形式IWX:P/QWX:P-访问的是信号端口地址&#xf…

idea推送到gitee 401错误

在idea上推送时遇到这样的问题&#xff0c;解决方法如下&#xff1a; 在https://的后面加上 用户名:密码 然后再提交就ok啦&#xff01;

285个地级市出口产品质量及技术复杂度(2011-2021年)

出口产品质量与技术复杂度&#xff1a;衡量国家竞争力的关键指标 出口产品质量是衡量国内企业生产的产品在国际市场上竞争力的重要标准。它不仅要求产品符合国际标准和目标市场的法律法规&#xff0c;而且需要保证产品质量的稳定性和可靠性。而出口技术复杂度则进一步体现了一…

Python神经模型评估微分方程图算法

&#x1f3af;要点 &#x1f3af;神经网络映射关联图 | &#x1f3af;执行时间分析 | &#x1f3af;神经网络结构降维 | &#x1f3af;量化图结构边作用 | &#x1f3af;数学评估算法实现 &#x1f36a;语言内容分比 &#x1f347;Python随机梯度下降算法 随机梯度下降是梯度…

nodejs安装配置详解

一、下载Node.js安装包 官网下载链接[点击跳转] 建议下载LTS版本&#xff08;本教程不适用于苹果电脑&#xff09; 二 、安装Node.js 2.1 下载好安装包后双击打开安装包&#xff0c;然后点击Next 2.2 勾选同意许可后点击Next 2.3 点击Change选择好安装路径后点击Next&#x…

使用微pe装系统

本文仅作为记录&#xff0c;不作为教程。 今天心血来潮想下点游戏玩玩&#xff0c;一看之前分的200gc盘已经红了&#xff0c;再加上大学之后这个笔记本已经用得很少了&#xff0c;于是打算重装电脑。 参考: 微PE辅助安装_哔哩哔哩_bilibil… 1.下载微pe和win10系统到U盘 我这…

18.按键消抖模块设计(使用状态机,独热码编码)

&#xff08;1&#xff09;设计意义&#xff1a;按键消抖主要针对的时机械弹性开关&#xff0c;当机械触点断开、闭合时&#xff0c;由于机械触点的弹性作用&#xff0c;一个按键开关在闭合时不会马上稳定地接通&#xff0c;在断开时也不会一下子就断开。因而在闭合以及断开的瞬…

Java PKI Programmer‘s Guide

一、PKI程序员指南概述 PKI Programmer’s Guide Overview Java认证路径API由一系列类和接口组成&#xff0c;用于创建、构建和验证认证路径。这些路径也被称作认证链。实现可以通过基于提供者的接口插入。 这个API基于密码服务提供者架构&#xff0c;这在《Java密码架构参考指…

Windows C++ vs2022环境中下载、安装和使用osmesa

第一步&#xff1a;安装 MinGW-w64 请参考这篇文章进行安装&#xff1a; 在Windows中安装MinGW-w64最新版本 第二步&#xff1a;安装DirectX SDK 请参考这篇文章进行安装&#xff1a; 下载安装Microsoft DirectX SDK(June 2010) 第三步&#xff1a;安装Windows SDK 请参考这篇…

数据仓库哈哈

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

WSL2编译使用6.6版本内核

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 前言一、有什么变化二、下载6.6内核三、开始编译1.安装环境2.开始编译 四、使用1.杀死虚拟机2.防止内核文件3.修改配置文件 总结 前言 最近出了一件不大不小的事&a…

C++基础知识:数组,数组是什么,数组的特点是什么?一维数组的三种定义方式,以及代码案例

1.数组的定义&#xff1a; 数组&#xff0c;就是一个集合&#xff0c;里面存放了相同类型的数据元素 2.数组的特点&#xff1a; 特点1:数组中的每个数据元素都是相同的数据类型 特点2:数组是由连续的内存位置组成的 3. 一维数组定义方式 维数组定义的三种方式: 1.数据类型 …

【atcoder】习题——位元枚举

题意&#xff1a;求i&M的popcount的和&#xff0c;i属于0……N 主要思路还是变加为乘。 举个例子N22&#xff0c;即10110 假设M的第3位是1&#xff0c;分析N中&#xff1a; 00110 00111 00100 00101 发现其实等价于 0010 0011 0000 0001 也就是左边第4位和第5…

AE-关键帧

目录 关键帧操作步骤&#xff08;以位置变化为例&#xff09; 1.确定动画起点 2.设置起点的位置属性 3.为起点打上关键帧 4.确定动画终点 5.设置终点的位置属性 改变动画速度 1.选中所有关键帧 2.拖拽 时间反向关键帧 1.选中要反向的关键帧 2.使用时间反向关键帧 …

二叉树超详细解析

二叉树 目录 二叉树一级目录二级目录三级目录 1.树的介绍1.1树的定义1.2树的基本术语1.3相关性质 2.二叉树介绍2.1定义2.2 性质 3.二叉树的种类3.1 满二叉树3.2完全二叉树3.3 二叉查找树特点&#xff1a;二叉查找树的节点包含的基本信息&#xff1a; 3.4 平衡二叉树 4.二叉树的…

imx6ull/linux应用编程学习(15) 移植MQTT客户端库

1. 准备开发环境 确保你的Ubuntu系统已经安装了必要的工具和依赖项。打开终端并运行以下命令&#xff1a; sudo apt update sudo apt install build-essential cmake git2. 获取MQTT库 git clone https://github.com/eclipse/paho.mqtt.c.git cd paho.mqtt.c3. 编译MQTT库 mk…

【前端速通系列|第二篇】Vue3前置知识

文章目录 1.前言2.包管理工具npm2.1下载node.js2.2配置 npm 镜像源2.3 npm 常用命令 3.Vite构建工具4.Vue3组件化5.Vue3运行原理 1.前言 本系列文章旨在帮助大家快速上手前端开发。 2.包管理工具npm npm 是 node.js中进行 包管理 的工具. 类似于Java中的Maven。 2.1下载nod…