创建N个单向链表对它进行摧毁和清空操作

最新推荐文章于 2022-06-08 11:29:44 发布
最新推荐文章于 2022-06-08 11:29:44 发布
阅读量720 收藏 2
点赞数 3
CC 4.0 BY-SA版权
分类专栏： c语言学习总结 常用小技巧总结篇 文章标签： 链表 指针
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/fml1997/article/details/76990738
本文详细介绍了链表摧毁和清空的区别。摧毁链表会释放包括头节点在内的所有节点，使链表不可用；而清空链表仅释放除头节点外的所有节点，链表仍可继续使用。通过实例和代码演示了两者的效果，并分享了vi编辑器的小技巧。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

摧毁和清空的含义及区别

摧毁

是先销毁了链表的头，然后接着一个一个的把后面的销毁了，这样这个链表就不能再使用了，即把包括头的所有节点全部释放。

清空

是先保留了链表的头，然后把头后面的所有的都销毁，最后把头里指向下一个的指针设为空，这样就相当与清空了，但这个链表还在，还可以继续使用；即保留了头，后面的全部释放。

区别：

清空是链表的头还在，可以继续插入节点；销毁就是链表没了，整个链表(包括头)的空间都被释放了，不能进行任何操作了。

摧毁链表实例

int destroy(struct node *head)
{
    struct node *p; //定义结构体指针
    if(head==NULL)//如果链表不存在则返回0
    {   
        return 0;
    }   
    while(head != 0)//如果存在则进行摧毁，直到head为空，所有节点被销毁
    {   
        p = head->next;//把head指向的下一个节点被P保存
        free(head);//释放掉head指向的节点
        head = p;//把P保存的节点被head保存
    }   

};

清空链表实例

int clear(struct node *head)
{    
    struct node *p;//定义结构体指针
    struct node *q; 
    if(head == 0)
    {   
        return 0;
    }   
    p = head->next;//把头节点的下一个节点被p保存
    while(p != 0)//当p存在时，进行清空操作
    {   
        q = p->next;//使q保存p指向的下一个节点
        free(p);//释放掉P里的内容
        p = q;//让p保存q指向的节点
    }   
    head->next = NULL;//当上面循环完成时，已经只有一个头结点存在，使head-         >next=NULL,表示链表结束
 };

下面是完整代码示例

发现一个vi编辑器的小技巧，:set nonumber可以删除代码前的序号


/*********************************************************************************
 *      Copyright:  (C) 2017 fanmaolin<fanmaolinn@gmail.com>
 *                  All rights reserved.
 *
 *       Filename:  make4.c
 *    Description:  This file 
 *                 
 *        Version:  1.0.0(08/05/2017)
 *         Author:  fanmaolin <fanmaolinn@gmail.com>
 *      ChangeLog:  1, Release initial version on "08/05/2017 07:24:41 AM"
 *                 
 ********************************************************************************/

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

#define LEN sizeof(struct node)
struct node
{
    int data;//存储数据
    struct node *next;//指向下一个节点
};

int n;//统计是第几个节点

struct node *creat()
{
    struct node *head;//头指针，指向第一个节点
    struct node *p1 = NULL;//p1保存创建的新节点的地址
    struct node *p2 = NULL;//p2保存原链表最后一个节点的地址

    n = 0;
    p1 = (struct node *)malloc(LEN);//新建一个节点
    p2 = p1;
    if(p1==NULL)//创建节点失败
    {
        printf("creat fail\n");
        return 0;
    }
    else
    {
        head = NULL;//头指针为空
        printf("please input %d node\n",n+1);
        scanf("%d",&(p1->data));//输入数据
    }
    while((p1->data)!=0)    //循环进行的条件
    {
        n = n + 1;//计算创建的节点数
        if(n==1)
        {
            head = p1;//head保存头结点的位置
            p2->next = NULL;//因为前面p1 = p2,而且现在只有一个节点，把next设置为空
        }

        else
        {

            p2->next = p1;//当不是第一个节点时，p2的next指向p1新创建的节点
        }

        p2 = p1;//p2保存p1的指向的节点，为p1创建新的节点做准备

        p1 = (struct node *)malloc(LEN);//p1创建新的节点
        printf("Please input %d node\n", n+1);
        scanf("%d", &(p1->data));//向新的节点输入数据
    }

    p2->next = NULL;//最后一个节点指向为空

    free(p1);//释放结束时p1申请的内存空间
    p1 = NULL;//避免p1成为野指针
    return head;//返回头指针
};


void print(struct node *head)
{
    struct node *p;
    p = head;

    printf("head is %o\n", head);
    do
    {
        printf("p is %o ,data is  %d, pnext is %o\n", p, p->data, p->next);//打印节点的地址，数据，下一个节点的地址
        p = p->next;//p指向下一个节点

    }while(p != NULL);
};

int destroy(struct node *head)
{
    struct node *p;//定义结构体指针
    if(head==NULL)//如果链表不存在则返回0
    {
        return 0;
    }
    while(head != 0)//如果存在则进行摧毁，直到head为空，所有节点被销毁
    {
        p = head->next;//把head指向的下一个节点被P保存
        free(head);//释放掉head指向的节点
        head = p;//把P保存的节点被head保存
    }

 make4.c                                                                                                                            
};
int clear(struct node *head)
{
    struct node *p;//定义结构体指针
    struct node *q;
    if(head == 0)
    {
        return 0;
    }
    p = head->next;//把头节点的下一个节点被p保存
    while(p != 0)//当p存在时，进行清空操作
    {
        q = p->next;//使q保存p指向的下一个节点
        free(p);//释放掉P里的内容
        p = q;//让p保存q指向的节点
    }
    head->next = NULL;//当上面循环完成时，已经只有一个头结点存在，使head->next=NULL,表示链表结束
 };

int main(void)
{
    struct node *head;
    head = creat();//创建链表
    print(head);//打印链表信息
    destroy(head);摧毁链表
    //clear(head);//清空链表
    print(head);检查摧毁或清空的效果

}

摧毁结果


[fanmaolin@Centeros lianbiao]$ gcc make4.c     
[fanmaolin@Centeros lianbiao]$ ./a.out         
please input 1 node
1
Please input 2 node
2
Please input 3 node
3
Please input 4 node
4
Please input 5 node
5
Please input 6 node
0
head is 155540020
p is 155540020 ,data is  1, pnext is 155540060
p is 155540060 ,data is  2, pnext is 155540120
p is 155540120 ,data is  3, pnext is 155540160
p is 155540160 ,data is  4, pnext is 155540220
p is 155540220 ,data is  5, pnext is 0
head is 155540020
p is 155540020 ,data is  28754080, pnext is 155540060
p is 155540060 ,data is  28753920, pnext is 155540120
p is 155540120 ,data is  28753952, pnext is 155540160
p is 155540160 ,data is  28753984, pnext is 155540220
p is 155540220 ,data is  28754016, pnext is 0

可以清楚的看到，摧毁链表后数据已经变为垃圾数据，链表不能使用

清空效果


[fanmaolin@Centeros lianbiao]$ gcc make4.c     
[fanmaolin@Centeros lianbiao]$ ./a.out     
please input 1 node
1
Please input 2 node
2
Please input 3 node
3
Please input 4 node
4
Please input 5 node
5
Please input 6 node
0
head is 33470020
p is 33470020 ,data is  1, pnext is 33470060
p is 33470060 ,data is  2, pnext is 33470120
p is 33470120 ,data is  3, pnext is 33470160
p is 33470160 ,data is  4, pnext is 33470220
p is 33470220 ,data is  5, pnext is 0
head is 33470020
p is 33470020 ,data is  1, pnext is 0

可以看到清空链表后，仅仅只有表头存在，依然可以进行插入等操作。

总结：

关于摧毁链表后依然可以根据头指针找到后面链表的地址

首先，我们虽然free()掉了，但是在没有其他人使用那块地址时，指针依然指向那块地址。假设你是新生时学校给你分配了宿舍，你一直记得，等你毕业离开时宿舍依旧存在，你也记得宿舍，但是你现在不能住了。

发现一个vi编辑器的小技巧，:set nonumber可以删除代码前的序号，U撤回之前的操作

参考链接：http://blog.youkuaiyun.com/bzhxuexi/article/details/41721429

C：数据结构：单向链表
becky_lyl的博客
05-12 89
单向链表即表的方向为一个，即从头结点处开始，尾结点结束，尾结点的指针域指向NULL，标志着链表的结束。链表的操作有 头插法、尾插法、遍历链表、查询结点、删除结点、指定位置添加结点、移动结点。
单向循环链表的基本操作
MOON5555的博客
10-23 537
单向循环链表的基本操作 1、头文件（clist.h） #pragma once //循环链表 typedef struct CNode { int data; struct CNode *next; }CNode,*CList; //循环链表初始化 void InitList(CList plist); //头插 bool Insert_head(CList plist,
链表删除的
12-26
给定一串数字，用链表结构进行存储。然后给定针对该链表的若干删除操作，要求将执行删除操作后的结果输出。 第一行：输入一个整数n，表示这串数字有n个（n大于等于1)。 第二行：输入这n个整数。 第三行：输入一个整数m，表示需要执行m次删除操作。（m≤n） 后面m行：每行输入一个整数a ，表示要删除当前链表中的第a个数字。（假设链表中第一个节点的编号为1）。 执行了m次删除操作中，输出剩下的n-m个数字。每个数字用空格空开。
使用后插法创建一个有n个结点的单向链表
一棹春风一叶舟，一纶茧缕一轻钩
03-09 3044
typedef struct Node { int data; struct Node * next; } NODE; void linklist_create_with_taiI_insert(int* data,unsigned short n) { NODE* pHead = (Node*)malloc(sizeof(Node)); NO...
创建一个有n个结点的非空单向链表
weixin_53457186的博客
06-08 1723
# include <stdio.h> # include <stdlib.h> //定义结构体 typedef struct node{ int data; //数据域 struct node * next; //指针域 }ElemSN; //将 struct node重命名为 ElemSN //建链表 ElemSN * CreateLink(int a[],int n) { ElemSN *h,*p,*t; //h为头指针 h=NULL; //头指针指向.
删除单向链表倒数第n个节点
for62的博客
09-04 666
// 删除倒数第n个节点 public void del(int n, ListNode node) { int length = 0; // 记录链表长度 ListNode head = node; // 保存头节点 while (node != null) { length++; node = node.next; // 移动指针 } ListNode resNode; // 从前往后找 int left = len
删除单向链表里倒数第n个节点
beibaoke910的专栏
03-25 2342
题目：写一个函数，完成删除单向链表里倒数第n个节点的功能，并返回这个被删除的节点指针（第一个节点为表头，不考虑删除它。） struct SNode { int value; SNode *next; }; SNode rdel(SNode *head, int n); 1.假设题目改成leetcode上原题： 给定一个链表，删除链表中倒数第n个节点，返回链表的头节点。 ...
C_线性表(ADT)-单向循环链表的表示和实现
Cynical丶Gary_博客
08-05 1678
循环链表是另一种形式的链式存贮结构。它的特点是表中最后一个结点的指针域指向头结点，整个链表形成一个环。表中最后一个结点的指针域指向头结点，整个链表形成一个环。嗯下面就网上找的一张单链的循环链表 单项链表定义： typedef struct LNode{ ElemType data; struct LNode *next; }LNode,*LinkList; 单向循环链表基本操作
c语言链表的尾指针,C语言单链表实现方法详解
weixin_33252145的博客
05-19 2924
本文实例讲述了C语言单链表实现方法。分享给大家供大家参考，具体如下：slist.h#ifndef __SLIST_H__#define __SLIST_H__#include#include#includetypedef int ElemType;typedef struct Node { //定义单链表中的结点信息ElemType data; //结点的数据域struct Node *next;...
数据结构之循环链表操作3-（合并，拆分，插入，删除，建立等)
wwq2015的专栏
09-10 542
单向循环链表的基本操作与单向链表有很多相似的,差别在于链表结束的判断条件，最后一个结点不再是指向NULL,而是指向头结点，将头尾连起来 代码如下关键在于判断链表终止的条件尾元素->头结点 #include #include using namespace std; template struct Node{ //结点 T data; Node *next; }; templat
Leetcode刷题java之19. 删除链表的倒数第N个节点
逆水行舟，不进则退
02-04 367
执行结果： 通过 显示详情 执行用时 :1 ms, 在所有 Java 提交中击败了64.16% 的用户 内存消耗 :35 MB, 在所有 Java 提交中击败了19.08%的用户 题目： 给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。 示例： 给定一个链表: 1->2->3->4->5, 和 n = 2. 当删除了倒数第二个节点后，链表...
链表的销毁
ZJ_Chen686的博客
12-02 1218
#include #include typedef int ElemType; struct Node; typedef struct Node *PtrToNode; typedef PtrToNode List; typedef PtrToNode Position; struct Node {     ElemType data;     Position 
创建一个结点个数为n的链表，删除指定的元素
wwwww_bw的博客
11-24 2191
#include #include typedef struct node {     int date;     struct node *next; }NODE; NODE *create() {     int a;     int n;     NODE *head;     NODE *p;     NODE *q;     head = (NODE*)m
LeetCode算法题：删除链表的倒数第N个节点
Viadimir的博客
05-14 438
题目描述如下： 给定一个链表，删除链表的倒数第n个节点，并且返回链表的头结点。 示例： 给定一个链表: 1->2->3->4->5, 和 n = 2. 当删除了倒数第二个节点后，链表变为 1->2->3->5. 说明： 给定的n保证是有效的。 这道题暴力法的思路很简单，即遍历两遍链表，第一遍统计出链表的节点数（设为L...
删除链表的倒数第N个节点
qq_45774645的博客
05-24 1110
删除链表的倒数第N个节点 给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。 输入：head = [1,2,3,4,5], n = 2 输出：[1,2,3,5] 示例 2： 输入：head = [1], n = 1 输出：[] 示例 3： 输入：head = [1,2], n = 1 输出：[1] 方法一两次遍历： 本题要求删除倒数第n个节点，那么最容易想到的就是先遍历一遍，求出链表的长度length，然后再遍历一遍，找到第length-n-1个节点，这样就可以把倒数第n个节点
LeetCode 19: 删除链表的倒数第N个节点 C++实现
142857_T的博客
05-30 272
思路 两次遍历算法：第一次遍历得到链表长度len，第二次遍历到（len - n）后删除下一节点（要删除的节点位于len - n + 1） 一次遍历算法：双指针，保持恒定间距（此处设置为n）同时移动 代码实现 //两次遍历 class Solution { public: ListNode* removeNthFromEnd(ListNode* head, int n) { ...
单向链表删除并清空操作 注意
猪哥的专栏
12-27 2310
在之前的文章《深入理解Linux内核之链表 list.h 功能实现原理、接口说明及示例代码》中详细的分析了链表的各种操作，我们经常使用的操作是“初始化”、“ 添加节点”、“遍历”、“删除”，对于链表节点的删除，使用的相对少，而且由于 删除操作的 宏函数 定义的复杂，容易混淆，本文基于此，对 链表的删除清空做下备忘录。 以单向链表结构 为例，用到的宏函数有2个，分别为： /* * I...
python实现给定一个单链表删除指定节点
Together_CZ的博客
08-23 8207
题目： 初始化定义一个单链表，删除指定节点，输出链表 下面是具体的实现： #!usr/bin/env python #encoding:utf-8 ''' __Author__:沂水寒城 功能：给定一个单链表删除指定节点 ''' class Node(object): ''' 节点类 ''' def __init__(self,data):
怎么销毁单链表
weixin_52634719的博客
09-19 7083
什么叫空的单链表？就是我有一个头结点，他的指针域为空，后面什么元素也没有，他就是一个空表，但头结点已经有了 Linklist这种类型是是指向两个成员的结点的指针* L一开始没有，分配好空间后才有值，获得的值仍然通过L来获得，所以L用引用型变量。 第一步先从内存中找到这么一块空间 两种办法 1直接new一个结点，这个new的结果是指向这个结点的指针，所以把这个新结点的地址直接赋值给L 2也可以用C语法，这块空间有多大呢？用malloc分配出来，然...
C语言中如何避免内存泄漏？
最新发布
03-24
在C语言中，**内存泄漏**是指程序运行过程中未能正确释放已分配的堆内存，导致这部分内存在整个程序生命周期都无法再被使用。为了有效避免这种情况的发生，可以采取以下几个策略： ### 1. 明确每一个`malloc/calloc/realloc`都有对应的`free` - 如果你在某处调用了诸如`malloc()`、`calloc()`或`realloc()`这样的动态内存分配函数，就必须保证随后有相应的`free()`去释放掉这块内存。 #### 示例： ```c int *ptr = (int *)malloc(sizeof(int)); if(ptr != NULL){ *ptr = 42; free(ptr); ptr = NULL; /* 将指针置为NULL以防悬空 */ } ``` ### 2. 防止重复释放(`double-free`)错误 - 在释放完一块内存后应立即将相应指针设置成`NULL`, 这样可以防止再次误用这个已经被释放过的地址空间。 #### 正确示例： ```c char *str = (char *)malloc(50 * sizeof(char)); // ... use str ... free(str); str = NULL; // Set to NULL after freeing if(str){ // This condition will not execute because 'str' is now NULL. printf("%s\n", str); } ``` ### 3. 函数返回前清理所有动态内存 - 当编写那些创建并返回复杂数据结构（比如链表节点、树形结点等）的辅助功能时，请确保这些内部组件也得到了适当的初始化和最终摧毁步骤。 #### 错误案例分析： 假设我们构建了一个简单单向链接列表添加元素的功能却忘了提供删除节点方法就会造成潜在的风险: ```c typedef struct Node{ int data; struct Node* next; }*NodePtr; NodePtr add_node(NodePtr head,int value){ NodePtr newnode=(NodePtr)malloc(sizeof(struct Node)); if(!newnode)return NULL; newnode->data=value; newnode->next=head; return newnode; } /* No corresponding function for releasing nodes */ ``` 在这里面虽然每次都会生成新的节点但是没有任何机制能够安全地遍历整个链条然后逐一清空它们所占据的位置所以很容易引起泄露情况出现. 正确的做法应该是另外设计一套完整包含头尾管理同时考虑边界条件下的通用销毁过程: ```c void destroy_list(NodePtr *head_ref){ while(*head_ref!=NULL){ NodePtr temp=*head_ref; *head_ref=(*head_ref)->next; free(temp); } } ``` 通过上述方式即可以在适当的时候完全卸载先前构造的所有内容而不会再残留下来无法访问的部分.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值