双链表的尾增，删，显示以及单链表的反向

已于 2023-02-11 00:10:53 修改
阅读量297 收藏 1
点赞数
分类专栏： C语言 文章标签： 链表 数据结构 c语言 算法
于 2023-02-11 00:09:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52983712/article/details/128979103
版权

目录

双链表

结构体定义

双链表创建

双链表节点删除

双链表显示

双链表末尾加节点

总代码块

结果

单链表的反向

结构体定义

单链表创建

单链表遍历

单链表的逆转

总代码

Result

双链表

下面是双向链表，而对于双向循环链表来讲，将头节点指针指向尾节点，尾节点指针指向头节点即可。此双向链表的头节点同单链表一样，不存有数据。

没学过的建议跳过，这一篇解释并不详细。对指针不了解的话看着可能很难受。

结构体定义

typedef struct node
{
    int data;
    struct node* next;
    struct node* previous;
}NODE;

双链表创建

NODE* creat()
{
    NODE* head, * p, * q;
    
    head =(NODE*) malloc(sizeof(NODE));
    if (!head)
        return NULL;
    head->previous = head;
    head->next = NULL;
    p = head;
    while (1)
    {
        int t = 0;
        printf("输入一个正整数(以负数结束)：");
        scanf_s("%d", &t);
        if (t < 0)
            break;
        q =(NODE*)malloc(sizeof(NODE));
        if (!q)
            return NULL;
        q->data = t;
        q->previous = p;
        p->next = q;
        q->next = NULL;
        p = q;
    }
    return head;
}

双链表节点删除

void dele(NODE* head, int t)
{
    if (!head->next)
    {
        printf("该链表为空\n");
        return;
    }
    while (head->next->data != t && head->next != NULL) 
        head = head->next;
    if (!head->next) 
        printf("链表无此值");
    else
        head->next = head->next->next;
}

双链表显示

void print(NODE* p)
{
    if (!p->next)
        printf("该链表为空!\n");
    else
    {
        printf("链表中的数据为：\n");
        while (p->next != NULL)
        {
            printf("<-->%d", p->next->data);
            p = p->next;    
        }
        printf("\n");
    }
}

双链表末尾加节点

void add(NODE* head, int value)   //尾插
{
    NODE* thisadd = (NODE*)malloc(sizeof(NODE));
    if (!thisadd)
        return;
    else
        thisadd->data = value;
    while (head->next != NULL)
        head = head->next;
    thisadd->next = head->next;
    head->next = thisadd;
    thisadd->previous = head;
}

总代码块

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct node
{
    int data;
    struct node* next;
    struct node* previous;
}NODE;
NODE* creat()
{
    NODE* head, * p, * q;
    
    head =(NODE*) malloc(sizeof(NODE));
    if (!head)
        return NULL;
    head->previous = head;
    head->next = NULL;
    p = head;
    while (1)
    {
        int t = 0;
        printf("输入一个正整数(以负数结束)：");
        scanf_s("%d", &t);
        if (t < 0)
            break;
        q =(NODE*)malloc(sizeof(NODE));
        if (!q)
            return NULL;
        q->data = t;
        q->previous = p;
        p->next = q;
        q->next = NULL;
        p = q;
    }
    return head;
}
void print(NODE* p)
{
    if (!p->next)
        printf("该链表为空!\n");
    else
    {
        printf("链表中的数据为：\n");
        while (p->next != NULL)
        {
            printf("<-->%d", p->next->data);
            p = p->next;    
        }
        printf("\n");
    }
}
void dele(NODE* head, int t)
{
    if (!head->next)
    {
        printf("该链表为空\n");
        return;
    }
    while (head->next->data != t && head->next != NULL) 
        head = head->next;
    if (!head->next) 
        printf("链表无此值");
    else
        head->next = head->next->next;
}
void add(NODE* head, int value)   //尾插
{
    NODE* thisadd = (NODE*)malloc(sizeof(NODE));
    if (!thisadd)
        return;
    else
        thisadd->data = value;
    while (head->next != NULL)
        head = head->next;
    thisadd->next = head->next;
    head->next = thisadd;
    thisadd->previous = head;
}

int main()
{
    NODE* h;
    h = creat();
    print(h);

    while (1)
    {
        int data = 0;
        printf("请输入待删除结点的值(以负数结束)：");
        scanf_s("%d", &data);
        if (data < 0)
            break;
        dele(h, data);
        print(h);
    }
    while (1)
    {
        int data = 0;
        printf("请输入增加尾结点的值(以负数结束)：");
        scanf_s("%d", &data);
        if (data < 0)
            break;
        add(h, data);
        print(h);
    }
    
    return 0;
}

结果

单链表的反向

结构体定义

typedef struct node
{
    int data;
    struct node* next;
}NODE;

单链表创建

NODE* creat()
{
    NODE* head, * p, * q;
    int t = 0;
    head = malloc(sizeof(NODE));
    if (!head)
        return NULL;
    p = head;
    while (1)
    {
        printf("输入一个正整数(以负数结束)：");
        scanf_s("%d", &t);
        if (t < 0)
            break;
        q = malloc(sizeof(NODE));
        if (!q)
            return NULL;
        q->data = t;
        p->next = q;
        p = q;
    }
    p->next = NULL;
    return head;
}

单链表遍历

void print(NODE* p)
{

    if (!p->next)
    {
        printf("该链表为空!\n");
        return;
    }
    else
    {
        printf("链表中的数据为：\n");
        while (p->next)
        {
            printf("->%d", p->next->data);
            p = p->next;    
        }
        printf("\n");
    }
}

单链表的逆转

以上示意图假设每个结构体都有值。首先把old_head指向的第一个节点复制给New_head,在这次循环后，让Old_head指向下一个节点，New_head指向已经旋转的节点。

while (OldHead)
    {
        temp = OldHead->next;
        OldHead->next = NewHead;
        NewHead = OldHead;
        OldHead = temp;
    }

    以上循环的主体部分，将old_head指向的第一个节点插入到New_head头上，同时更新oldhead和Newhead的值。当将old_head指向的第一个节点插入到New_head头上时，我们需要知道oldhead的下一个节点，因此创建一个临时变量temp。

    以上思想的本质是我们将单链表看成一个一个独立的单元，然后像我们折莲藕一样，把一节一节的部分从头到尾变成从尾到头。

    经过以上循环，此时的newhead组成的单链表并不符合单链表的初始定义。因此，重新创建一个结构体指针插入为其头节点。

NODE* Reverse(NODE* L)
{
    assert(L);
    NODE* NewHead, *OldHead, *temp;
    OldHead = L->next;
    NewHead = NULL;
    while (OldHead)
    {
        temp = OldHead->next;
        OldHead->next = NewHead;
        NewHead = OldHead;
        OldHead = temp;
    }
    NODE* CreatHead = (NODE*)malloc(sizeof(NODE));
    if (!CreatHead)
    {
        printf("头节点创建失败！！！");
        L = NewHead;
        printf("打印出来的头节点数据已经丢失");
    }
    else
    {
        CreatHead->next = NewHead;
        L = CreatHead;
    }
    return L;
}

总代码

#include <stdlib.h>
#include <assert.h>
typedef struct node
{
    int data;
    struct node* next;
}NODE;
NODE* creat()
{
    NODE* head, * p, * q;
    int t = 0;
    head = malloc(sizeof(NODE));
    if (!head)
        return NULL;
    p = head;
    while (1)
    {
        printf("输入一个正整数(以负数结束)：");
        scanf_s("%d", &t);
        if (t < 0)
            break;
        q = malloc(sizeof(NODE));
        if (!q)
            return NULL;
        q->data = t;
        p->next = q;
        p = q;
    }
    p->next = NULL;
    return head;
}
void print(NODE* p)
{

    if (!p->next)
    {
        printf("该链表为空!\n");
        return;
    }
    else
    {
        printf("链表中的数据为：\n");
        while (p->next)
        {
            printf("->%d", p->next->data);
            p = p->next;    
        }
        printf("\n");
    }
}
NODE* Reverse(NODE* L)
{
    assert(L);
    NODE* NewHead, *OldHead, *temp;
    OldHead = L->next;
    NewHead = NULL;
    while (OldHead)
    {
        temp = OldHead->next;
        OldHead->next = NewHead;
        NewHead = OldHead;
        OldHead = temp;
    }
    NODE* CreatHead = (NODE*)malloc(sizeof(NODE));
    if (!CreatHead)
    {
        printf("头节点创建失败！！！");
        L = NewHead;
        printf("打印出来的头节点数据已经丢失");
    }
    else
    {
        CreatHead->next = NewHead;
        L = CreatHead;
    }
    return L;
}
int main()
{
    NODE* h;
    h = creat();
    print(h);
    NODE*h1=Reverse(h);
    print(h1);
    return 0;
}

Result

天是蓝的嘛
关注
专栏目录
数组、单链表和双链表介绍以及双向链表的C/C++实现
SB202211的博客
07-19 800
节点10"的后继节点是"节点20"(数据为10的节点)，"节点20"的前继节点是"节点10"；表头为空，表头的后继节点是"节点10"(数据为10的节点)，"节点10"的后继节点是"节点20"(数据为10的节点)，..."节点20"的后继节点为"节点30"，而"节点30"的后继节点为"节点40"。"节点10"的后继节点为"节点15"，而"节点15"的后继节点为"节点20"。"节点10"的后继节点为"节点20"，"节点20"的前继节点为"节点10"。"节点10"的后继节点为"节点20"。......
链表详解（单链表、双向链表、链表逆序）
别呀的博客
04-07 2027
单链表 想了解单链表的一些概念可以看我另一篇博客： 链表基础 单链表结构体定义 //单链表的结构定义 typedef struct LNode { int data; //data存放结点数据域 struct LNode *next; //指向后继结点的指针 }LNode; 单链表的建立 （1）定义单链表的数据结构； （2）读取数据； （3）生成新结点； （4）将数据存入结点的成员变量中； （5）将新结点连接到表头或表尾。 重复（2）~（5）直到输入结束。 //头插法建立单链表 void c
【C】循环双向链表的基本操作，头插、头删、尾插、尾删
mysterious superstar
08-15 849
//double slist.h #pragma once #include<stdio.h> #include<stdlib.h> #include<string.h> typedef int LTDataType; typedef struct ListNode { LTDataType _data; struct ListNode* _next; ...
数据结构-双向循环链表的尾插尾删 具体位置插入和删除操作
姜守威的博客
02-08 1617
双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。 直接上代码 下面是DouLsit.h #pragma once #include <stdio.h> #include <assert.h> #include <stdlib.h> typedef int DataType; typedef struct ListN.
双向链表(链表尾加数据链表头加数据删除销毁)
u012502219的专栏
11-02 452
#include"list.h"   //创建一个空的链表  struct  node  *list_create(int size) { struct node *head  = NULL; } int list_addtail(struct node *head, void *dat) {   } int list_addhead(struct *head,void *
双向循环链表的头插尾插，头删尾删
要变老程序员不的博客
07-28 176
#include<stdio.h> #include<stdlib.h> #include<string.h> #include<assert.h> typedef int ElemType; typedef struct ListNode { ElemType data; struct ListNode* prev; struct ListNode* next; }ListNode; typedef struct { struct ListNod
双链表的头插头删及尾插尾删操作
qq_45648990的博客
12-01 304
双链表的头插头删及尾插尾删操作： 定义链表: Node类： public class Node { int val; Node next; Node prev; Node(int val, Node next,Node prev){ this.val=val; this.next=next; this.prev=pr...
JAVA实现双向链表的增删功能的方法
08-27
在上面的代码中，我们使用了out()方法来遍历链表，该方法使用了两种遍历方式，一种是正向遍历，从头节点开始遍历到尾节点，一种是反向遍历，从尾节点开始遍历到头节点。 七、总结 本篇文章主要介绍了JAVA实现双向...
C语言实例-双向链表增删改查
最新发布
09-11
这个C语言代码片段提供了一个基础框架，可以根据实际需求添加更多功能，如删除、修改节点，以及实现链表的排序和查找等操作。双向链表在C语言编程中是一个重要的数据结构，理解和熟练掌握它的操作对解决许多算法问题...
数据结构--数组、单链表和双链表介绍以及双向链表 数组和链表.pdf
04-18
数据结构--数组、单链表和双链表介绍以及双向链表 数据结构是计算机科学中的一种基本概念，指的是数据的组织和存储方式。数组、链表是两种常见的数据结构，下面将对它们进行介绍。 一、数组 数组是数据结构中的一...
关于链表的尾节点删除
垂皎的博客
04-23 1426
创建两个节点 void delete(LinkList &L){ LNode *p=L; LNode *q; while(p->next!=NULL){ q=p; p=p->next; } q->next=NULL; delete§； }
双链表初始化、头插、尾插、头删、尾删、任意位置插入和删除、判空、销毁、打印、查找操作
weixin_46153828的博客
03-14 1024
ListNode* buyDListNode(LTDataType data) { ListNode* newNode = (ListNode*)malloc(sizeof(ListNode)); if (NULL == newNode) { assert(0); return NULL; } newNode->data = data; newNode->prev = NULL; newNode->next = NULL; return newNode; } .
双向链表，添加，删除一个节点
wuyiyu_的博客
12-29 3974
链表有几种，大致分为：单链表， 双向链表，循环链表，静态链表。这里为大家简单介绍双向链表节点的添加，删除。提示：以下是本篇文章正文内容，下面案例可供参考双向指针并不难，大家要多加理解。
数据结构第三天--双向链表的增删改查
weixin_45861045的博客
07-29 331
数据结构第三天学习--双向链表
C语言实现双向链表：插入和删除
weixin_63301726的博客
10-05 3412
C语言实现双向链表：插入和删除
JavaSE之List中ArrayList底层和LinkedList底层
weixin_47543906的博客
11-05 462
List接口下的集合特点： 1.有索引 2.元素可以重复 3.存入和取出顺序一致
【数据结构】—— 双链表的增删改查
周小末天天开心的博客
11-25 2049
双链表基础以及案例演示
链表基本操作
chetezheng3608的博客
04-18 104
#include <iostream.h> #include "stdio.h" #include <stdlib.h> #include "string.h" typedef int ElemType ; /****************************...
C语言实现链表之单向链表（八）删除尾结点
君临天下的博客
11-08 7582
C语言实现链表之单向链表（八）删除尾结点     上一篇文章给出了在尾结点之后插入结点的函数，本篇文章将给出删除尾结点的函数。 /*============================================================================== * 操作 ：删除尾结点 * 操作前：ppHeadNode为链表的头指针
C语言实现双向链表的增删改查详解
C语言实例-双向链表增删改查教程 在计算机科学中，双向链表（Doubly Linked List）是一种重要的数据结构，它在单链表的基础上引入了额外的向前指针，使得节点能够同时访问前一个和后一个节点。这种数据结构的主要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

天是蓝的嘛

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值