C语言 释放链表内存 带表头结点的链表 循环链表（2018.12.9）

最新推荐文章于 2023-10-14 23:21:37 发布
最新推荐文章于 2023-10-14 23:21:37 发布
阅读量1.9k 收藏 12
点赞数 1
分类专栏： c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Rayyyyyyy/article/details/84932504
版权

释放链表内存

void release_link(Link * head)
{
    Link p;
    p = *head;
    if(p == NULL)
    {
        printf("link is empty!\n");
    }
    else
    {
        while(*head != NULL)
        {
            *head = (*head)->next;
            free(p);
            p = *head;
        }
    }
}

使链表反序【重要】


void link_reverse(Link * head)
{
    Link p1,p2,p3;
    p1 = p2 = p3= *head;

    if(p1 == NULL)
    {
        printf("Link is empty!\n");
    }
    else if(p1->next == NULL)
    {
        printf("Link is only one.\n");
    }
    else 
    {
        p2 = p1->next;
        if(p2->next == NULL)
        {
            p2->next = p1;
            p1->next = NULL;
            *head = p2;
        }
        else
        {
            p3 = p2->next;
            while(p3->next != NULL)
            {
                p2->next = p1;
                p1 = p2;
                p2 = p3;
                p3 = p3->next;
            }
            p2->next = p1;
            p3->next = p2;
            (*head)->next = NULL;
            *head = p3;
        }
    }

}

带表头结点的链表
创建+头插+尾插+中间插入+删除+反序

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

#define MAL_ERR 0
#define MAL_OK 1

struct node  
{
    int num; 
    struct node * next;
};

typedef struct node Node;
typedef struct node * Link;


int malloc_ok(Link new_node)  //判断空间是否创建成功
{
    if(new_node == NULL)
    {
        return MAL_ERR;
    }
    else
    {
        return MAL_OK;
    }
}

void create_node(Link * new_node, int i)  //创建空间
{
    (*new_node) = (Link)malloc(sizeof(Node));

    while(malloc_ok(*new_node) == MAL_ERR)
    {
        (*new_node) = (Link)malloc(sizeof(Node));
    }
    (*new_node)->num = i;
}

void create_link(Link *  head)  //创建带表头结点的链表
{
    create_node(head,0);
    (*head)->next = NULL;
}
void insert_node_head(Link head,Link new_node)  //头插
{
    new_node->next = head->next;
    head->next = new_node;
}

void insert_node_tail(Link head,Link new_node)   //尾插
{
    Link p;
    p = head;
    while(p->next != NULL)
    {
        p = p->next;
    }
    p->next = new_node;
    new_node->next = NULL;
    
}

void insert_node_mid(Link head,Link new_node,int num_loc)  //中间插入
{
    Link p,q;
    q = head;
    p = head->next;

    if(p == NULL)
    {
        head->next = new_node;
        new_node->next = NULL;
    }
    else
    {
        while(p->num != num_loc && p->next != NULL)
        {
            q = p;
            p = p->next;
        }
    }
    if(p->next == NULL && p->num != num_loc)
    {
        p->next = new_node;
        new_node->next = NULL;
    }
    else
    {
        q->next = new_node;
        new_node->next = p;
    }
}

void display(Link head)   //打印链表
{
    Link p;
    p = head;

    if(p == NULL)
    {
        printf("no fine Link\n");
    }

    if(p->next == NULL)
    {
        printf("Link is empty!\n");
    }
    else
    {
        while(p->next != NULL)
        {
            p = p->next;
            printf("num = %d\n",p->num);
        }
    }
}

void node_del(Link head,int num_val)  //删除一个数
{
    Link p,q;
    q = head;
    p = head->next;

    if(p == NULL)
    {
        printf("链表为空！\n");
    }
    else
    {
        while(p->num != num_val && p->next != NULL)
        {
            q = p;
            p = p->next;
        }
        if(p->next == NULL && p->num != num_val)
        {
            printf("没有找到数。\n");
        }
        else
        {
            q->next = p->next;
            free(p);
        }
    }
}

void link_reverse(Link head)  //反转链表
{
    Link p1,p2,p3,q;
    p1 = p2 = p3 = head->next;

    if(p1 == NULL)
    {
        printf("Link is empty!\n");
        return;
    }
    else if(p1->next == NULL)
    {
        return;
    }
    else
    {
        p2 = p1->next;
        if(p2->next == NULL)
        {
            p2->next = p1;
            p1->next = NULL;
            head->next = p2;
        }
        else
        {
            p3 = p2->next;
            while(p3->next != NULL)
            {
                p2->next = p1;
                p1 = p2;
                p2 = p3;
                p3 = p3->next;
            }
            p2->next = p1;
            p3->next = p2;
            q = head->next;
            q->next = NULL;
            head->next = p3;
        }
    }

}


int main()
{
    Link head = NULL;
    Link new_node = NULL;
    int i;
    int num_val,num_loc;
    
    
    create_link(&head);

    for(i = 0; i < 10; i++)
    {
        create_node(&new_node,i);
        insert_node_head(head,new_node);
    }
    
    display(head);

    printf("请输入要插入的位置。\n");
    scanf("%d",&num_loc);
    printf("请输入要插入的数。\n");
    scanf("%d",&num_val);

    create_node(&new_node,num_val);

    insert_node_mid(head,new_node,num_loc);
    display(head);

    printf("请输入要删除的数。\n");
    scanf("%d",&num_val);
    node_del(head,num_val);
    display(head);
   
    printf("*********\n");
    link_reverse(head);
    display(head);

    return 0;
}

循环链表
创建+头插+尾插+中间插入+删除+反序+释放内存

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

#define MAL_OK 1
#define MAL_ERR 0

struct node
{
    int num;
    struct node * next;
};

typedef struct node Node;
typedef struct node * Link;

int malloc_ok(Link new_node)  //判断空间是否创建成功
{
    if(new_node == NULL)
    {
        return MAL_ERR;
    }
    else
    {
        return MAL_OK;
    }
}

void create_node(Link * new_node, int i)  //创建空间
{
    (*new_node) = (Link)malloc(sizeof(Node));
    while(malloc_ok(*new_node) == MAL_ERR)
    {
        (*new_node) = (Link)malloc(sizeof(Node));
    }
    (*new_node)->num = i;
}

void create_link(Link * head)  //创建带表头结点的链表
{
    create_node(head,0);
    (*head)->next = *head;
}

void insert_node_head(Link head,Link new_node)  //头插
{
    new_node->next = head->next;
    head->next = new_node;
}

void insert_node_tail(Link head,Link new_node)  //尾插
{
    Link p;
    p = head;
    while(p->next != head)
    {
        p = p->next;
    }
    p->next = new_node;
    new_node->next = head;
}

void insert_node_mid(Link head,Link new_node,int num_loc)  //中间插入
{
    Link p,q;
    q = head;
    p = head->next;

    if(p == head)
    {
        head->next = new_node;
        new_node->next = head;
    }
    else
    {
        while(p->num != num_loc && p->next != head)
        {
            q = p;
            p = p->next;
        }
        if(p->next == head && p->num != num_loc)
        {
            p->next = new_node;
            new_node->next = head;
        }
        else
        {
            q->next = new_node;
            new_node->next = p;
        }
    }
    
}


void display(Link head)
{
    Link p;
    p = head;

    if(p == NULL)
    {
        printf("no Link.\n");
    }
    else if(p->next == head)
    {
        printf("Link is empty.\n");
        
    }
    else
    {
        while(p->next != head)
        {
            p = p->next;
            printf("num = %d\n",p->num);
        }
    }
}

void node_del(Link head,int num_val)  //删除一个数
{
    Link p,q;
    q = head;
    p = head->next;

    if(p == head)
    {
        printf("链表为空。\n");
    }
    else
    {
        while(p->num != num_val && p->next != head)
        {
            q = p;
            p = p->next;
        }
        if(p->next == head && p->num != num_val)
        {
            printf("没有找到数。\n");
        }
        else
        {
            q->next = p->next;
            free(p);
        }
    }
}

void release_link(Link * head)  //释放内存以免内存泄漏
{
    Link p;
    p = (*head)->next;
    if(p == *head)
    {
        printf("link is empty.\n");
        free(p);
        *head = NULL;
    }
    else
    {
        while(p != *head)
        {
            (*head)->next = p->next;
            free(p);
            p = (*head)->next;
        }
        free(*head);
        *head = NULL;
    }
}

void link_recerse(Link head)  //反转链表
{
    Link p1,p2,p3,q;
    p1 = p2 = p3 = head->next;

    if(p1 == head)
    {
        printf("Link is empty.\n");
        return;
    }
    else if(p1->next == NULL)
    {
        return;
    }
    else if(p1->next == head)
    {
        return;
    }
    else
    {
        p2 = p1->next;
        if(p2->next == NULL)
        {
            p2->next = p1;
            p1->next = head;
            head->next = p2;
        }
        else
        {
            p3 = p2->next;
            while(p3->next != head)
            {
                p2->next = p1;
                p1 = p2;
                p2 = p3;
                p3 = p3->next;
            }
            p2->next = p1;
            p3->next = p2;
            q = head->next;
            q->next = head;
            head->next = p3;
        }
    }
}

int main()
{
    Link head = NULL;
    Link new_node = NULL;
    int i;
    int num_val,num_loc;
    create_link(&head);

    for(i = 0; i < 10; i++)
    {
        create_node(&new_node,i);
        insert_node_tail(head,new_node);
    }
    
    display(head);

    printf("请输入要插入的位置。\n");
    scanf("%d",&num_loc);
    printf("请输入要插入的数。\n");
    scanf("%d",&num_val);
    create_node(&new_node,num_val);
    insert_node_mid(head,new_node,num_loc);
    display(head);

    printf("请输入要删除的数字。\n");
    scanf("%d",&num_val);
    node_del(head,num_val);
    display(head);

    

    release_link(&head);
    display(head);

    return 0;
}
Rayyyyyyy
关注
  • 1
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c语言释放链表的方式,C语言（4）--创建无序链表、释放链表
weixin_29467909的博客
05-21 3584
1.建立一个如图所示的简单链表，它由三个学生数据的结点组成 代码：#include #include #include struct student{int num;//学号char name[20];//姓名double score;//成绩struct student *next;//下一个结点地址};int main(){struct student *a,*b,*c,*head=NULL;...
单链表（C语言，带头节点，增删查改）
weixin_63042414的博客
10-08 439
链表是数据结构中比较重要的一种结构，起初我在学习的时候也糊涂了好久，后来呢，一直独自写了好几遍才渐渐有了感觉。我的经验是必须要深入到内存中去学习，或者说是深刻理解一个链表从创建到销毁的过程中内存的变化。单链表有两种，一种是头结点有数据的，一种是头结点不含数据的，其实两者没有什么大差别，本文演示的是头结点不含数据的单链表。节点在内存中就是我们开辟出的一小块空间，它由两小块组成，一部分是数据域，一部分是指针域。
《循环链表详解》
qq_61813575的博客
10-14 184
循环链表是一种特殊的链表，与普通链表相比，最后一个节点的指针域不为空，而是指向链表的头节点，形成一个闭环。在插入和删除节点时，只需要注意更新头节点的前驱节点指针域和尾节点的指针域即可。由于循环链表的头节点的前驱节点是尾节点，因此在任意位置插入或删除节点时，操作起来更加方便，不需要特殊处理边界节点。从循环链表中删除节点需要找到要删除的节点，并更新前一个节点的next指针，使其指向要删除节点的下一个节点。printf("\-----------顺序表演示程序----------\n");
C语言链表（创建、遍历、释放、查找、删除、插入一个节点、排序，逆序）
宗谷的博客
03-29 5820
本文介绍C语言链表，通过自学还有参考《大话数据结构》，希望给大家更好的理解什么是C语言链表
单向链表之释放（C语言实现）
peng_fp的博客
03-19 1万+
链表的创建查看 同遍历链表类似，区别在于p_mov每指向某个节点后都将该节点释放 1、释放前要先保存下一个节点，释放后备份恢复给p_mov,否则释放了当前节点，下一个节点的地址就将失去； 2、依次将所有节点释放后，最后返回NULL（标示释放完毕）。 结构体节点： typedef struct student { int num; //学号 i
c 语言怎么释放链表节点,C：如何释放链表中的节点？
weixin_30316931的博客
05-23 2110
我如何释放在另一个函数中分配的节点？struct node {int data;struct node* next;};struct node* buildList(){struct node* head = NULL;struct node* second = NULL;struct node* third = NULL;head = malloc(sizeof(struct node));se...
按递增次序输出带头节点单链表的数据元素并释放其空间
vivi_and_qiao的博客
09-19 3617
#include "stdafx.h" #include&lt;stdio.h&gt; #include&lt;malloc.h&gt; #include&lt;stdlib.h&gt; typedef int type; typedef struct lnode //定义链表结点的数据结构 { int data; struct lnode *next; }Lnode; ty...
c语言-c语言编程基础之leetcode题解第19题删除链表的倒数第N个结点.zip
最新发布
04-19
在C语言中，链表是一种非常重要的数据结构，它由一系列节点组成，每个节点包含数据以及指向下一个节点的指针。本主题将深入探讨如何利用C语言解决LeetCode中的第19题——删除链表的倒数第N个节点。这道题目要求我们...
链表的C语言实现之删除结点.rar_c语言前驱节点
09-23
链表是一种基础且重要的数据结构，它在计算机科学中被广泛应用，特别是在内存管理、文件系统、数据库等场景。本文将详细讲解如何在C语言中实现链表并删除一个节点，特别是利用前驱节点来完成这一操作。 首先，我们...
C语言之单向链表详解及实例代码
12-31
列表是由结点构成，由head指针指向第一个成为表头的结点而终止于最后一个指向nuLL的指针； 2，例子要求： 根据示例代码中的例子，完成单向链表(single linked list)中的以字符串为数据的链表的插入、删除以及查找，...
C语言实现的双链表功能完整示例
08-27
双链表的摧毁操作主要通过destroy函数来实现，该函数主要用于摧毁链表并释放链表占用的内存空间。 本文主要介绍了C语言实现的双链表功能，包括链表的定义、初始化、添加、删除、排序、逆置、查找、长度计算、清除和...
C语言双向链表.pdf
10-06
首先，**循环链表**是单链表的一种变体，其特征在于最后一个结点的指针指向链表的第一个结点或表头结点，形成一个闭合的环。在处理循环链表时，有以下几个关键点： 1. 创建循环链表时，需要确保最后一个结点的指针...
C语言 单链表的创建、遍历、释放
m0_74803157的博客
01-06 3199
【代码】C语言 单链表的创建、遍历、释放。
数据结构-链表技巧04
rr18758236029的博客
10-21 268
数据结构-链表技巧04 技巧一：理解指针或引用的含义 将某个变量赋值给指针，实际上就是将这个变量的地址赋值给指针，或者反过来说，指针中存储了这个变量的内存地址，指向了这个变量，通过指针就能找到这个变量。 插入结点时，一定要注意操作的顺序 删除链表结点时，也一定要记得手动释放内存空间 针对链表的插入、删除操作，需要对插入第一个结点和删除最后一个结点的情况进行特殊处理 异常处理 如果链表为空时，代码是否能正常工作？ 如果链表只包含一个结点时，代码是否能正常工作？ 如果链表只包含两个结点时，代码是否能正常工作？
（C语言版）链表（二）——实现单向循环链表创建、插入、删除、释放内存等简单操作
热门推荐
菜鸟学C/C++
02-23 2万+
昨天写了单向链表的代码，今天上午把单向循环链表的程序给敲完了。链表的相关操作一样的，包含链表的创建、判断链表是否为空、计算链表长度、向链表中插入节点、从链表中删除节点、删除整个链表释放内存。如果单向链表理解了，那单向循环链表也就不难了。 单向循环链表如下图所示： 看图可以知道，单向循环链表和单向链表差不多，只不过是最后的尾节点指向的不是空，而是指向头节点。理解这一点很重要，因为这是我们
C语言 字符串数组 二维数组 指针 动态内存分配（2018.11.25）
Rayyyyyyy的博客
11-25 1987
字符串数组 若字符串数组内内没有‘\0’,用%s输出时，系统会一直找到‘\0’为止。即使超出数组的范围也一直找。 char c[] = “I am happy”; //字符串，长度为11 char c[] = {‘I’, 使用strcat、strcpy，strcmp，strlen，strlur，strupr函数时，需要包含#include&amp;amp;lt;string.h&amp;amp;gt;的头文件 strcat 连接...
c语言链表末尾插入新结点
05-14
链表末尾插入新节点的基本思路是： 1. 遍历链表，找到最后一个结点。 2. 创建新结点，并将其插入到最后一个结点的 next 指针指向的位置。 下面是一个示例代码： ```c #include <stdio.h> #include <stdlib.h> // 定义链表结构体 struct Node { int data; struct Node* next; }; // 在链表末尾插入新节点 void insertAtEnd(struct Node** headRef, int data) { struct Node* newNode = (struct Node*)malloc(sizeof(struct Node)); newNode->data = data; newNode->next = NULL; if (*headRef == NULL) { // 如果链表为空，新节点就是头结点 *headRef = newNode; return; } struct Node* current = *headRef; while (current->next != NULL) { current = current->next; } current->next = newNode; } // 打印链表 void printList(struct Node* node) { while (node != NULL) { printf("%d ", node->data); node = node->next; } printf("\n"); } // 测试代码 int main() { struct Node* head = NULL; insertAtEnd(&head, 1); insertAtEnd(&head, 2); insertAtEnd(&head, 3); insertAtEnd(&head, 4); printf("链表内容："); printList(head); return 0; } ``` 输出结果为： ``` 链表内容：1 2 3 4 ``` 其中，insertAtEnd() 函数是实现链表末尾插入新节点的关键部分。它接收一个指向链表头指针的指针 headRef，因为在函数中需要修改 headRef 指向的内容（即链表头指针）。函数中首先创建一个新节点，然后遍历链表找到最后一个结点，并将新节点插入到最后一个结点的 next 指针指向的位置。注意在链表为空时需要特殊处理。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值