【笔记】链表（C语言）（指针）

于 2023-12-18 19:42:40 发布
阅读量443 收藏 9
点赞数 6
文章标签： 笔记 链表 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45504304/article/details/135068405
版权

话不多说先上代码
code

这是一个链表的基本操作，主要功能有链表的添加、删除某个节点、添加某个节点。

#include<stdio.h>  // 引入标准输入输出库  
#include<stdlib.h> // 引入标准库，用于内存分配等操作  
  
// 定义一个结构体，表示链表的节点  
struct node{  
    int data;  // 节点中存储的数据  
    struct node* next;  // 指向下一个节点的指针  
};  
  
// 创建一个新的节点  
struct node* createnode(int data){  
    struct node* newnode = (struct node*)malloc(sizeof(struct node));  // 使用malloc分配内存  
    newnode->data = data;  // 设置节点的数据  
    newnode->next = NULL;  // 设置节点的指针为NULL  
    return newnode;  // 返回新创建的节点  
}  
  
// 在链表的头部插入一个新节点  
void insertnode(struct node** head,int data){  
    struct node* newnode = createnode(data);  // 创建新节点  
    if(*head == NULL){  // 如果链表为空  
        *head = newnode;  // 将新节点设置为链表的头部  
    } else {  
        struct node* temp = *head;  // 定义一个临时指针，指向链表的头部  
        while(temp->next!=NULL){  // 当临时指针的下一个节点不为空时，继续移动临时指针  
            temp = temp->next;  
        }  
        temp->next = newnode;  // 将临时指针的下一个节点设置为新节点  
    }  
}  
  
// 打印链表的所有节点数据  
void printlist(struct node* head){  
    while(head != NULL){  // 当链表不为空时  
        printf("%d ",head->data);  // 打印当前节点的数据  
        head = head->next;  // 将头指针移动到下一个节点  
    }  
    printf("\n");  // 打印换行符，结束输出  
}  
  
// 释放链表所占用的动态内存  
void freelist(struct node* head){  
    struct node* temp;  
    while(head != NULL){  // 当链表不为空时  
        temp = head;  // 定义一个临时指针，指向链表的头部  
        head = head->next;  // 将头指针移动到下一个节点  
        free(temp);  // 释放临时指针所指向的内存空间  
    }  
}  
  
// 删除指定值的节点  
void deletanode(struct node* head,int insertv){  
    struct node* current = head;  // 定义一个指针，指向链表的头部  
    struct node* prev = NULL;  // 定义一个指针，用于保存上一个节点的地址  
    while(current->data!=insertv&&current!=NULL){  // 当当前节点的数据不等于要删除的值且当前节点不为空时  
        prev = current;  // 保存当前节点的地址到prev指针中  
        current = current->next;  // 将指针移动到下一个节点  
    }  
     if (current != NULL) {  // 如果找到了要删除的节点  
        if (prev == NULL) {  // 如果要删除的是头节点  
            head = current->next;  // 将头指针移动到下一个节点，即删除节点后的头节点  
        } else {  
            prev->next = current->next;  // 将prev指针所指向的节点的下一个节点设置为要删除节点的下一个节点，即删除该节点  
        }  
        free(current);  // 释放要删除节点的内存空间  
    }  
}  
// 插入节点的函数  
void insertnode2(struct node* head, int data1, int data2) {  
    struct node* current = head;  
    struct node* prev = NULL;  
    struct node* newnode = createnode(data2);  // 创建新节点  
    while (current != NULL && current->data != data1) {  
        prev = current;  
        current = current->next;  
    }  
  
    if (current != NULL) {  
        if (prev == NULL) {  
            head = newnode;  // 如果要插入的是头节点，更新头节点指针  
        } else {  
            prev->next = newnode;  // 插入中间节点，更新前一个节点的指针  
        }  
        newnode->next = current;  // 新节点的指针指向当前节点，完成插入操作  
    } else {  
        printf("Node not found.\n");  // 如果找不到指定节点，则输出错误信息  
    }  
}  
  
// 主函数  
int main()  
{  
    struct node* head = NULL;  // 初始化链表头节点为空  
    int n, r, f = 1, insertv, newnodev;  
    printf("请输入你要创建的节点长度:\n");  
    scanf("%d",&n);  // 读取用户输入的节点数量  
    for(int i = 0; i < n; i++){  
        int data;  
        printf("请输入第%d个节点的数据\n",i+1);  
        scanf("%d",&data);  // 读取用户输入的节点数据  
        insertnode(&head,data);  // 插入新节点到链表头部  
    }  
    printf("链表数据为:\n");  
    printlist(head);  // 打印链表数据  
    while(f){  
        printf("是否有其他操作(1删除节点/2添加节点/输入其他结束)\n");  
        scanf("%d",&r);  // 读取用户选择的操作类型  
        if(r == 1){  // 如果选择删除节点  
            printf("请输入要删除的节点值\n");  
            scanf("%d", &insertv);  // 读取用户输入的待删除节点的值  
            deletanode(head,insertv);  // 删除指定节点  
            printlist(head);  // 打印链表数据，确认节点已被删除  
        }  
        else if(r == 2){  // 如果选择添加节点  
            printf("请输入要添加在那个节点以后(节点的值以后)和添加节点的值\n");  
            scanf("%d%d",&insertv,&newnodev);  // 读取用户输入的待插入位置和新的节点值  
            insertnode2(head,insertv,newnodev);  // 在指定位置插入新节点  
            printlist(head);  // 打印链表数据，确认新节点已插入  
        }  
        else {  // 如果选择结束操作或输入其他数字，则结束循环  
            break;  
        }  
    }  
    freelist(head);  // 释放链表内存空间  
    return 0;  // 程序结束并返回0，表示成功执行  
}

操作结果与演示

请输入你要创建的节点长度:
5
请输入第1个节点的数据
1
请输入第2个节点的数据
2
请输入第3个节点的数据
3
请输入第4个节点的数据
4
请输入第5个节点的数据
5
链表数据为:
1 2 3 4 5
是否有其他操作(1删除节点/2添加节点/输入其他结束)
1
请输入要删除的节点值
3
1 2 4 5
是否有其他操作(1删除节点/2添加节点/输入其他结束)
2
请输入要添加在那个节点以后(节点的值以后)和添加节点的值
4 3
1 2 3 4 5
是否有其他操作(1删除节点/2添加节点/输入其他结束)
3

Process returned 0 (0x0)   execution time : 16.983 s
Press any key to continue.

每个函数功能的解释与实现

结构体

struct node{//定义结构体
    int data;//存结构点的值
    struct node* next;//指针方便指向下一个节点
};

head节点、设置下一个节点节点

create/创造 data/数据

// 定义一个创建节点的函数，接受要存储的数据  
struct node* createnode(int data){  
    // 分配动态内存以存储节点结构体  
    struct node* newnode = (struct node*)malloc(sizeof(struct node));     
    // 将传入的data存储到新节点的data成员中  
    newnode->data = data;  
    // 将新节点的next指针初始化为NULL  
    newnode->next = NULL;  
    // 返回新节点的地址  
    return newnode;  
}

在最后一位增加一个节点

insert/插入、嵌入 这个函数用于创建一个新的链表节点，并为该节点分配动态内存。新节点的数据成员被设置为传入的data参数，而next指针被初始化为NULL。最后，函数返回新节点的地址，以便在其他函数中使用。

// 定义一个插入节点的函数，接受链表头指针的地址和要插入的数据  
void insertnode(struct node** head, int data){  
    // 创建一个新节点，并将数据放入节点  
    struct node* newnode = createnode(data);  
    // 如果链表为空，即头节点为NULL  
    if(*head == NULL){  
        // 将新节点的地址赋给头指针，即设置头节点  
        *head = newnode;  
    } else {  
        // 定义一个临时指针，指向链表的头节点  
        struct node* temp = *head;  
        // 遍历链表，直到找到最后一个节点（即next指针为NULL的节点）  
        while(temp->next!=NULL){  
            // 将临时指针移动到下一个节点  
            temp = temp->next;  
        }  
        // 将最后一个节点的next指针指向新节点，完成插入操作  
        temp->next = newnode;  
    }  
}

输出

这个函数通过遍历链表，逐个打印每个节点的数据。当遍历到链表的末尾（即头节点为NULL）时，循环结束。最后，打印一个换行符，使输出结果更整齐。

// 定义一个打印链表的函数，接受链表的头节点  
void printlist(struct node* head){  
    // 当头节点不为NULL时，继续循环  
    while(head != NULL){  
        // 打印当前节点的数据  
        printf("%d ",head->data);  
        // 将头节点更新为下一个节点  
        head = head->next;  
    }  
    // 打印换行符，使输出更整齐  
    printf("\n");  
}

释放内存

这个函数通过遍历链表，逐个释放每个节点所占用的动态内存。在释放当前节点内存之前，需要先将头节点更新为下一个节点，以免在释放内存后访问已经无效的内存区域。最后，当遍历到链表的末尾时，循环结束。

// 定义一个释放链表的函数，接受链表的头节点  
void freelist(struct node* head){  
    // 定义一个临时指针，用于遍历链表  
    struct node* temp;  
    // 当头节点不为NULL时，继续循环  
    while(head != NULL){  
        // 将临时指针指向当前节点  
        temp = head;  
        // 将头节点更新为下一个节点  
        head = head->next;  
        // 释放当前节点所占用的动态内存  
        free(temp);  
    }  
}

删除节点

这个函数通过遍历链表，查找并删除指定数据的节点。如果找到了要删除的节点，它会更新链表中的链接以删除该节点，并释放该节点所占用的动态内存。

// 定义一个删除节点的函数，接受链表的头节点和要删除的数据  
void deletanode(struct node* head, int insertv) {  
    // 定义一个指针，指向链表的头节点  
    struct node* current = head;  
    // 定义一个指针，用于保存上一个节点的地址  
    struct node* prev = NULL;  
    // 遍历链表，查找要删除的节点  
    while(current->data != insertv && current != NULL) {  
        // 如果当前节点不是要删除的节点，则保存当前节点的地址  
        prev = current;  
        // 将指针移动到下一个节点  
        current = current->next;  
    }  
    // 如果找到了要删除的节点  
    if (current != NULL) {  
        // 如果上一个节点是头节点，则将头节点更新为下一个节点  
        if (prev == NULL) {  
            head = current->next;  
        // 否则，将上一个节点的next指针更新为要删除节点的下一个节点  
        } else {  
            prev->next = current->next;  
        }  
        // 释放要删除节点的动态内存  
        free(current);  
    }  
}

插入

这个函数的功能是在链表中查找特定数据的位置，并在该位置插入一个新的节点。如果找到了要插入的位置，它会更新链表中的链接以插入新节点。如果找不到指定节点，则输出错误信息。

// 定义一个插入节点的函数，接受链表的头节点和要插入的数据  
void insertnode2(struct node* head, int data1, int data2) {  
    // 定义一个指针，指向链表的头节点  
    struct node* current = head;  
    // 定义一个指针，用于保存上一个节点的地址  
    struct node* prev = NULL;  
    // 创建一个新节点，并存储数据data2  
    struct node* newnode = createnode(data2);  // 创建新节点  
    // 遍历链表，查找要插入的位置  
    while (current != NULL && current->data != data1) {  
        // 如果当前节点不是要插入的位置，则保存当前节点的地址  
        prev = current;  
        // 将指针移动到下一个节点  
        current = current->next;  
    }  
  
    // 如果找到了要插入的位置  
    if (current != NULL) {  
        // 如果要插入的是头节点，更新头节点指针  
        if (prev == NULL) {  
            head = newnode;  // 如果要插入的是头节点，更新头节点指针  
        // 否则，将上一个节点的next指针更新为要插入节点的next指针  
        } else {  
            prev->next = newnode;  // 插入中间节点，更新前一个节点的指针  
        }  
        // 新节点的next指针指向当前节点，完成插入操作  
        newnode->next = current;  // 新节点的指针指向当前节点，完成插入操作  
    } else {  
        // 如果找不到指定节点，则输出错误信息  
        printf("Node not found.\n");  // 如果找不到指定节点，则输出错误信息  
    }  
}

主函数

这个程序通过定义一个链表结构和一个主函数来执行一系列的操作。它首先要求用户输入要创建的节点数量，然后循环n次来创建这些节点并插入到链表的头部。接下来，它打印链表的所有节点数据。然后它进入一个循环，等待用户选择操作。用户可以选择删除一个节点或添加一个新节点到链表的指定位置。最后，它释放链表所占用的动态内存并结束程序。

int main() // 主函数开始  
{  
    struct node* head = NULL; // 定义一个指向链表头节点的指针，初始化为NULL  
    int n, r, f = 1, insertv, newnodev; // 定义多个变量，包括节点数量n、操作选择r、循环标志f以及两个用于插入和删除节点的值  
    printf("请输入你要创建的节点长度:\n"); // 提示用户输入要创建的节点数量  
    scanf("%d",&n); // 从标准输入读取节点数量  
    for(int i = 0; i < n; i++){ // 循环n次，每次创建一个新节点并输入数据  
        int data;  
        printf("请输入第%d个节点的数据\n",i+1); // 提示用户输入当前节点的数据  
        scanf("%d",&data); // 从标准输入读取节点数据  
        insertnode(&head,data); // 调用insertnode函数，将新节点插入到链表的头部  
    }  
    printf("链表数据为:\n"); // 打印提示信息  
    printlist(head); // 调用printlist函数，打印链表的所有节点数据  
    while(f){ // 当f为1时，进入循环，等待用户选择操作  
        printf("是否有其他操作(1删除节点/2添加节点/输入其他结束)\n"); // 提示用户选择操作  
        scanf("%d",&r); // 从标准输入读取用户的选择  
        if(r == 1){ // 如果用户选择删除节点  
            printf("请输入要删除的节点值\n"); // 提示用户输入要删除的节点的值  
            scanf("%d", &insertv); // 从标准输入读取要删除的节点的值  
            deletanode(head,insertv); // 调用deletanode函数，删除指定值的节点  
            printlist(head); // 打印链表的所有节点数据，以确认删除操作  
        }  
        else if(r == 2){ // 如果用户选择添加节点  
            printf("请输入要添加在那个节点以后(节点的值以后)和添加节点的值\n"); // 提示用户输入要插入的位置和要插入的数据  
            scanf("%d%d",&insertv,&newnodev); // 从标准输入读取位置和数据  
            insertnode2(head,insertv,newnodev); // 调用insertnode2函数，在指定位置插入新节点  
            printlist(head); // 打印链表的所有节点数据，以确认插入操作  
        }  
        else  
            break; // 如果用户选择结束操作，跳出循环  
    }  
    freelist(head); // 调用freelist函数，释放链表所占用的动态内存  
    return 0; // 主函数返回0，表示程序正常结束  
}
佳乐乐乐乐乐乐
关注
  • 6
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
链表简单的输入输出
qq1183242924的博客
09-26 9311
用单向链表实现简单的输入输出，函数可以拿去用。 #include <stdio.h> #include <stdlib.h> /*链表结点结构体*/ struct NODE { int m; //可根据需求修改数据域。 struct NODE *next; } ; /*函数声明*/ struct NODE *creat(); void output(struct NODE *head); int main() { struct NODE *he
链表
hongmeipopo73的博客
01-29 253
#include #include typedef struct node{ int value; struct node *next; }Node; int main(){ int number; Node *head=NULL; do{ scanf("%d",&number); if(number!=-1){//add to linked-list Node *p=(N
链表输入
weixin_45653525的博客
12-16 631
#include <stdio.h> #include <stdlib.h> struct List { int data; struct List *next; } * a; struct List *cin(); void cout(struct List *head); int main() { a = cin(); cout(a); ...
链表的输入与输出
umgsai的专栏
08-10 332
#include"stdio.h" #include"malloc.h" typedefstructNode {chardata; structNode*next; }Node,*Linklist; voidInput(Linklist&amp;p)//输入函数 {Node*r,*s; r=p; charc; intflag=1; whi...
输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。
weixin_40271182的博客
11-29 139
题目描述 输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。 /* 思路： 现将链表反转，再一次打印链表。 */ class Solution { public: vector&lt;int&gt; printListFromTailToHead(ListNode* head) { vector&lt;int&gt; res; List...
MIT c语言指针和内存 课程笔记
03-12
在MIT的"C语言指针和内存"课程中，学习者会深入理解C语言的核心概念，特别是指针和内存管理这两个至关...因此，MIT的"C语言指针和内存"课程笔记是一份宝贵的资源，对于任何想要提升编程技能的开发者来说都极具价值。
C指针介绍实战链表代码笔记
最新发布
01-22
"C指针介绍实战链表代码笔记" 本文将通过一个实战的链表代码笔记，来介绍C指针的概念和应用。 一、指针的基本概念 在C语言中，指针是指向内存中某个位置的变量。指针变量的值是某个内存位置的地址。通过指针，...
《C语言学习笔记》指针1
08-08
【C语言学习笔记】指针1 在C语言中，指针是一个强大的工具，它能够直接操作内存地址，实现高效的数据处理。本文将探讨指针的基本概念、声明和使用，以及涉及的一些运算规则。 首先，我们需要理解指针的含义。在...
C语言链表各种操作
04-30
C语言创建链表、头插法 、尾插法 、任意位置插法 、输出链表 、删除链表中的指定数字 、链表销毁、删除链表中第i个结点，并且用x带出删除的值 、获取链表长度、返回链表中第i个结点 、链表中查找是否结点的数据等于x...
c语言 实用基础 算法 笔记 指针
09-19
总结，这份笔记集合了C语言的基础语法、指针操作和算法实践，特别适合初学者。通过阅读和练习，可以逐步建立起对C语言的理解，并提升编程技能。在学习过程中，结合实例代码和注释，能够更好地加深对知识点的把握，为...
通过用户输入建立链表
05-04
通过用户输入建立链表，用户可输入链表长度和链表元素
输入一个链表，按链表值从尾到头的顺序返回一个ArrayList
qq_29462849的博客
04-18 536
源代码 /** * struct ListNode { * int val; * struct ListNode *next; * ListNode(int x) : * val(x), next(NULL) { * } * }; */ class Solution { public: vector&lt...
链表的动态输入、插入 、与删除
飘--的博客
07-27 1623
1 #include   2 #include   3 #include   4    5 #define len sizeof(struct student)   6    7    8 struct student   9 {  10     int num;  11     float score;  12     struct student *next;  13
c程序设计——链表的输入，输出，插入，删除
MambaWang8的博客
07-18 1656
**c程序设计笔记** 链表实现动态输入，输出，多次插入，多次删除功能 #include<stdio.h> #include <malloc.h> #define L sizeof(struct student) struct student //定义一个结构体 { int num; int score; struct student *next; }; int n; //结点数 struct student *creat() //...
C语言 链表输入输出数组
m0_73633088的博客
12-04 5589
链表与数组的输入输出，（数据结构）
小白级创建简单输入链表
WRplayeR的博客
12-07 418
小白级简单链表 图像简单理解原理
关于链表的循环输入
weixin_44905815的博客
01-17 936
链表在输入时会牵扯到不断地创建新节点，因此需要不断地在堆区申请内存。刚开始在做这个的时候考虑到申请内存就需要给指针起名字，但是如果需要每个节点都要起名字就无法放到循环中去。此问题的解决方法是，不用给每个新开辟的节点（即指针）起名字直接在堆区申请内存并赋值给当前节点的下一节点。如下图所示，是循环输入一个链表代码 while (1) { cin >> temp; if (temp == -1) { break; ...
C语言中数组和链表的输入输出
weixin_43904350的博客
11-28 233
/先在头指针开辟一个存储空间，但是不储存数据。//此时的空间是新开辟的空间，tail->next即是上一个空间p->next。//为指针指向p,可以理解作为一个桥梁，用来储存是一个指向的空间。struct node//先定义一个结构体，里面包含数据与结构体指针。//固定头指针指向的指针，然后保持不变。//初始化头指针指向空指针。//p的指向下一个指针为空指针。//输入想要的数字n个。
C语言指针解析：右左法则深度解析
总结来说，本学习笔记旨在帮助读者掌握如何解读和使用C语言中的复杂指针声明，通过实例和“右左法则”的讲解，提升读者在指针操作和声明解析方面的技能。通过不断练习和应用，读者可以更熟练地驾驭C语言的这一强大...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值