数据结构--单向链表实现功能

最新推荐文章于 2024-09-13 19:36:07 发布
最新推荐文章于 2024-09-13 19:36:07 发布
阅读量112 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57037805/article/details/126264740
版权

一、单向链表概念

1.既然顺序存储中的数据因为挤在一起而导致需要成片移动，那很容易想到的解决方案是将数据离散地存储在不同内存块中，然后在用来指针将它们串起来。这种朴素的思路所形成的链式线性表，就是所谓的链表。
2.顺序表和链表在内存在的基本样态如下图所示：

 二、链表的分类

根据链表中各个节点之间使用指针的个数，以及首尾节点是否相连，可以将链表细分为如下种类：
1.单向链表
2.单向循环链表
3.双向链表
4.双向循环链表

--> 我们这里介绍的就是第一种 <--

三、单向链表功能

1.定义一个结构体

typedef struct node
{
    //存放的数据
    int data;
    //存放下一个节点的指针
    struct node *next;    
}node;   // node == struct node

2.初始化结构体，生成一个新的节点

node *initList(void)
{
    //在堆空间开辟内存
    node *new = malloc(sizeof(node));
    if(new == NULL)
    {
        printf("malloc fail\n");
        return NULL;
    }
    //开辟的空间数据初始化为0
    new->data = 0;
    new->next = NULL;

    return new;
}

3.头插添加数据

void inset_1(node *head,  node *new)
{
    new->next = head->next;
    head->next = new;
}

4.尾插添加数据

void inset_2(node *head,  node *new)
{
    node *p=NULL;
    for (p = head; p ->next; p=p->next);
    p->next=new;
    new->next=NULL;
}

5.打印数据

void  display(node *head)
{
    int i = 0;
    node *p = NULL;
    for(p = head->next; p != NULL ; p = p->next)
    {
        printf("%d\t", p->data);
    }
    printf("\n");
}

6.查找数据

node *find_data(node  *head, int data)
{
    node *p = NULL;
    for(p = head->next; p != NULL ; p = p->next)
    {
        //判断节点的数据是否等于 查看的数据，如果是，返回节点
        if(p->data == data)
        {
            return p;
        }

    }

    return NULL;
}

7.节点删除 

int  del_node(node *head, int data)
{
    node *del = NULL;
    node *p = NULL;
    del = find_data(head, data);
    if(del == NULL)
    {
        printf("链表当中没有此数据节点\n");
        return -1;
    }
    //遍历查看del 前缀节点
    for(p = head; p != NULL; p = p->next)
    {
        if(p->next == del)
        {
            break;
        }
    }

    //将点解下来
    p->next = del->next;
    del->next = NULL;

    free(del);

    return 0;
}

8.移动数据头插

int move_node(node *head,int data_1,int data_2)
{
    node *p_1 = NULL;
    node *p_2 = NULL;    
    node *q_1 = NULL;
    p_1 = find_data(head, data_1);
    p_2 = find_data(head, data_2);
    if ((p_1 == NULL) || (p_2 == NULL))
    {
        printf("你输入的数据有不存在的现象\n");
        return -1;
    }

    //遍历查看del 前缀节点
    for(q_1 = head; q_1 != NULL; q_1 = q_1->next)
    {
        if(q_1->next == p_1)
        {
            break;
        }
    }
    q_1->next=p_1->next;
    p_1->next=NULL;

    p_1->next=p_2->next;
    p_2->next=p_1;
    return 0;
}

9.单向链表的销毁

void destroy(node *head)
{
    node *p=head->next;
    while(p!=NULL)
    {
        node *pp=p;
        p=p->next;
        free(pp);
    }
    head->next=NULL;
    printf("已经成功摧毁\n");
}

完整代码

#include <stdio.h>
#include <stdlib.h>

typedef struct node
{
    //存放的数据
    int data;
    //存放下一个节点的指针
    struct node *next;    
}node;   // node == struct node
 
//函数声明
node *initList(void);
void inset_1(node *head,  node *new);
void inset_2(node *head,  node *new);
void  display(node *head);
node *find_data(node  *head, int data);
int  del_node(node *head, int data);
int move_node(node *head,int data_1,int data_2);
void destroy(node *head);

int main(void)
{
    //定义局部变量
    char ch;
    int data,data1, ret;
    node *head, *new, *find;

    //生产一个单向链表结构体
    head = initList(); 

    while(1)
    {
        printf("====================请输入你要操作功能====================\n");
        printf("\t\t\ta:头插插入\n");
        printf("\t\t\tb:尾插插入\n");
        printf("\t\t\tc:查找数据\n");
        printf("\t\t\td:删除数据\n");
        printf("\t\t\te:移动数据\n");
        printf("\t\t\tf:摧毁数据\n");
        printf("\t\t\tp:显示数据\n");
    
        //等待获取用户输入
        ch = getchar();

        switch (ch)
        {
            //头插添加数据
            case 'a':
                new = initList();
                printf("请输入要插入的数据:");
                scanf("%d", &new->data);
                inset_1(head,  new);
                break;
            //尾插添加数据
            case 'b':
                new = initList();
                printf("请输入要插入的数据:");
                scanf("%d", &new->data);
                inset_2(head,  new);
                break;
            //查找数据
            case 'c':
                printf("请输入要查找的数据:");
                scanf("%d", &data);
                find = find_data(head, data);
                if(find == NULL)
                {
                    printf("链表当中没有此数据节点\n");
                }
                else
                {
                    printf("链表当中有此数据节点\n它的节点地址：%p\n", find);
                }
                break;
            //节点删除 
            case 'd':
                printf("请输入要删除的数据:");
                scanf("%d", &data);
                ret = del_node(head, data);
                if(ret == 0)
                {
                    printf("节点删除完成\n");
                }

                break;
            //移动数据头插
            case 'e':
                printf("移动到那个数据前面:");
                scanf("%d", &data);
                printf("请输入要移动的数据:");
                scanf("%d", &data1);
                ret = move_node(head, data, data1);
                if(ret == 0)
                {
                    printf("节点移动完成\n");
                }
                break;
            //单向链表的销毁
            case 'f':
                destroy(head);
                break;
            //打印数据
            case 'p':
                display(head);
                break;
            default:
                printf("输入格式错误，请重新输入！\n");
                break;
        }

        while (getchar() != '\n');
    }  

    return 0;
}


//初始化结构体，生成新的一个节点
node *initList(void)
{
    //在堆空间开辟内存
    node *new = malloc(sizeof(node));
    if(new == NULL)
    {
        printf("malloc fail\n");
        return NULL;
    }
    //开辟的空间数据初始化为0
    new->data = 0;
    new->next = NULL;

    return new;
}  

//头插添加数据
void inset_1(node *head,  node *new)
{
    new->next = head->next;
    head->next = new;
}

//尾插添加数据
void inset_2(node *head,  node *new)
{
    node *p=NULL;
    for (p = head; p ->next; p=p->next);
    p->next=new;
    new->next=NULL;
}

//打印数据
void  display(node *head)
{
    int i = 0;
    node *p = NULL;
    for(p = head->next; p != NULL ; p = p->next)
    {
        printf("%d\t", p->data);
    }
    printf("\n");
}

//查找数据，数据存在返回数据所在的节点地址
node *find_data(node  *head, int data)
{
    node *p = NULL;
    for(p = head->next; p != NULL ; p = p->next)
    {
        //判断节点的数据是否等于 查看的数据，如果是，返回节点
        if(p->data == data)
        {
            return p;
        }

    }

    return NULL;
}

//节点删除 
int  del_node(node *head, int data)
{
    node *del = NULL;
    node *p = NULL;
    del = find_data(head, data);
    if(del == NULL)
    {
        printf("链表当中没有此数据节点\n");
        return -1;
    }
    //遍历查看del 前缀节点
    for(p = head; p != NULL; p = p->next)
    {
        if(p->next == del)
        {
            break;
        }
    }

    //将点解下来
    p->next = del->next;
    del->next = NULL;

    free(del);

    return 0;
}

//移动数据头插
int move_node(node *head,int data_1,int data_2)
{
    node *p_1 = NULL;
    node *p_2 = NULL;    
    node *q_1 = NULL;
    p_1 = find_data(head, data_1);
    p_2 = find_data(head, data_2);
    if ((p_1 == NULL) || (p_2 == NULL))
    {
        printf("你输入的数据有不存在的现象\n");
        return -1;
    }

    //遍历查看del 前缀节点
    for(q_1 = head; q_1 != NULL; q_1 = q_1->next)
    {
        if(q_1->next == p_1)
        {
            break;
        }
    }
    q_1->next=p_1->next;
    p_1->next=NULL;

    p_1->next=p_2->next;
    p_2->next=p_1;
    return 0;
}

//单向链表的销毁
void destroy(node *head)
{
    node *p=head->next;
    while(p!=NULL)
    {
        node *pp=p;
        p=p->next;
        free(pp);
    }
    head->next=NULL;
    printf("已经成功摧毁\n");
}

走进嵌入式
关注
专栏目录
数据结构--单链表及实现
kaximoudu的博客
04-02 182
单链表 链表节点包括数据域和指针域（指针域保存下一个节点的地址） 单链表是由头指针唯一确定，因此单链表可以用头指针的名字来命名（LinkList *L //L既是头指针，又是链表名字） 链式存储结构的术语 节点：数据元素的存储映像，由数据域和指针域两部分组成 链表：N个节点由指针链组成的链表 头指针：是指向链表中第一个节点的指针 首元节点：是指链表中存储第一个数据元素的节点 头节点：是在链...
数据结构：单链表的实现
HKD_WCY的博客
03-26 343
#include<iostream> #include<string> #include<iomanip> #include<fstream> using namespace std; #define OK 1 #define ERROR 0 #define OVERFLOW -2 typedef int Status; //Status 是函数返...
单向链表基本功能实现
Jackson__Yi的博客
08-29 277
package demo7; interface ILink<E>{ //设置泛型避免安全隐患 public void add(E e); //增加数据 public int size(); //获取数据个数 public boolean isEmpty(); //判断是否为空集合 public Object[] toArray(); //将集合元素...
单向链表结构的实现以及基本功能
qq_50504109的博客
09-14 365
1、心里话与大家分享 在代码中所有的注释都是在我第一次自己做的时候，没做对产生了错误之后找到了错误的原因而注释，我相信大家并不是每一句代码都不明白，而是往往和我一样，在某一个地方很疑惑，或者不解，因此，我认为没有必要每一句都注释。我是用耿国华的C语言学习的，我相信我的一些问题也许是大家的一些问题，因此，我很高兴和大家一起分享我的学习心得，让我们一起进步，畅游在算法与数据结构之美中，冲冲冲。 2、单向链表结构的实现以及基本功能 /** * 在本节我们来学习线性单链表 */ #include&
单链表基本功能的实现（C语言）
Enthusiastic_boy的博客
11-27 1076
不带头节点的单链表的增、删、改、查，涉及到二级指针。
【C语言】单链表的基本功能实现
RedMaple
07-24 527
单链表的基本功能实现（基于C语言） 声明(技术有限，仅限参考，可直接通过GCC编译使用，大神勿喷) 也真诚希望各位可以提些真实有用的意见 基本功能 新建链表 初始化 遍历 计算长度 删除单个结点 插入新结点 修改结点内容 查看单个结点 清空链表 销毁链表 代码区 #include <time.h> #include <stdio.h> #include <std...
单向链表实现（C语言）
li
06-11 1626
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) +指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。 ...
数据结构-单向链表教程.zip
08-24
本系列教程深入剖析链表数据结构，从基础概念到高级操作，全面覆盖。首先介绍链表的提出背景，随后通过单链表的ADT（抽象数据类型）模型，阐释其理论基础。接着，通过实际代码演示单链表及结点的定义，以及如何实现...
数据结构与算法--用单向链表实现栈（C++实现）
DeeperBlue的博客
04-05 9625
栈是基本的数据结构。其特点是添加和删除（访问）数据都在线性表的一端（头端）。数据访问遵循先进后出（FILO）的原则。栈一般用数组或者链表来实现。数组需要静态分配数据空间，占用空间比较大。链表则根据实际需要动态分配数据空间，占用空间相对小一些。本文用单向链表实现栈。程序用C++实现。
数据结构3--深入了解单向链表的实现
cainiaochufa2021的博客
03-17 938
文章目录链表1.从顺序表到链表1.1用指针来实现链表中空间的联系1.2创建一个节点1.3头指针、第一个节点和最后一个节点头指针的创建2.管理链表中的元素2.1访问链表中的各个元素2.1.1打印链表2.1.2在链表中查找数据2.1.3改变链表中某一个节点的值2.2创建新的节点2.3在链表中添加节点2.3.1在链表的末尾添加节点2.3.2在链表的头部添加节点2.3.3在链表的指定位置添加节点在指定位置的前面添加节点在链表的指定位置后面添加节点2.4删除链表中的节点2.4.1删除链表最后一个节点2.4.2删除链表
链表的基本功能实现
编程小霸王的Blog
12-12 717
前言  ：  链表的实现，查询，插入，删除，这些简单的操作。在平时的学习中，经常会遇见，故以单链表为例做个总结。链表的优缺点，以及适用情况在前面的一篇文中(http://blog.csdn.net/c18219227162/article/details/50274243)就提到过，就不作介绍了。 一、链表的定义 单链表存储结构 typedef struct LNode {
单向循环链表的实现以及基本功能
qq_50504109的博客
09-15 238
1、单向循环链表的实现以及基本功能 /** * 由于单向循环链表和单向链表基本一样，因此大部分代码我直接复制粘贴单向链表的代码 * 我们只需要把 p->next = NULL或者p = NULL 这两个条件改为 p->next = LL或者p = L 就可以啦 * */ #include<stdio.h> #include <mm_malloc.h> #define MAXSIZE 15 // 常量的定义不需要分号也不需要等号 MAXSI
【数据结构】线段树复杂应用
最新发布
2302_80811345的博客
09-13 696
随着星际网络的进一步建设和规模的增大，一个新的问题出现在网络工程师面前——地址空间不够用了！原来，星际网络采用了传统的 IPv6 协议，虽然有2128级别的可用地址数量，但面对广袤无垠的宇宙和爆炸式增长的网络用户数，如此庞大的地址空间也面临了用尽的那一天。新的通信协议的研发工作交给了著名的网络科技圣地——西西艾弗星。最终，经过2333年的不懈努力，西西艾弗星的工程师们设计出了一种新的协议——“西西艾弗IP协议”，又称 IPxxaf。在 IPxxaf 协议中，一个地址由n位二进制位组成，其中。
数据结构：线性表的顺序存储
weixin_74300052的博客
09-08 590
Hello,大家好，我是小珑也要变强（也是小珑），我是易编程·终身成长社群的一名“创始团队·嘉宾”和“内容共创官”,现在我来为大家介绍一下有关物联网-嵌入式方面的内容。线性表的顺序存储结构我们也叫做顺序表，它指的是用一段地址连续的存储单元依次存储线性表中的数据元素。如下图：通过上图，结合之前的C语言学习，我们基本明白，线性表的本质就是我们对于数组的操作。
数据结构---非线性--树
2301_80434764的博客
09-13 484
本文将详细介绍树及其变体在计算机科学中的应用及实现。首先，将概述树的基本概念、结构及其实际应用，包括树的表示方法及在各种应用场景中的重要性。接着，深入探讨二叉树的基本概念、特殊类型及其性质，并比较顺序存储和链式存储这两种主要存储结构。 在探讨二叉树的顺序结构及实现时，重点讲解堆的概念与结构，涵盖堆的向上和向下调整算法、建堆的时间复杂度以及堆的插入和删除操作，并讨论堆在排序和Top-K问题中的应用。最后，讨论二叉树的链式结构实现，包括各种遍历方式（如前序、中序、后序和层序遍历）和常见接口。
数据结构-图
ya888g
09-13 294
邻接表（Adjacency List）：使用链表或数组列表表示图，其中每个顶点都有一个与之关联的链表或数组列表，存储与其相邻的顶点。广度优先搜索（Breadth-First Search, BFS）：从某个顶点出发，逐层访问其相邻顶点，直到所有可达顶点都被访问过。最小生成树问题：在一个连通图中找到一棵包含所有顶点的树，使得树的所有边的权值之和最小，如Kruskal算法、Prim算法等。权重（Weight）：与边相关联的数值，表示边的某种属性，如距离、成本等。顶点（Vertex）：图中的节点，通常表示为V。
数据结构----单向链表
03-27
单向链表是一种常见的数据结构，它由一系列节点组成，每个节点包含两部分：数据和指向下一...单向链表常用于需要频繁插入和删除操作的场景，比如实现栈、队列等数据结构，也可以用于实现其他高级数据结构，如图、树等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值