【数据结构】双向链表的遍历、添加、修改和删除

最新推荐文章于 2023-11-04 09:23:43 发布
最新推荐文章于 2023-11-04 09:23:43 发布
阅读量2.4k 收藏 16
点赞数 1
分类专栏： 链表 数据结构 文章标签： 链表 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40839718/article/details/124734405
版权

双向链表的遍历、添加、修改和删除

（1）单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找。
（2）单向链表不能自我删除，需要靠辅助节点，而双向链表，则可以自我删除。
在这里插入图片描述

1、双向链表的遍历

1.1 思路

双向链表的遍历方法和单链表一样，只是可以向前，也可以向后查找。

1.2 代码编写

//显示链表（遍历）
    public void show() {
        //判断链表是否为空
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //因为head节点不能动，因此需要新建一个辅助变量temp
        HeroNode temp = head.next;
        while (true) {
            //判断是否到链表最后
            if (temp == null) {
                break;
            }
            //输出节点信息
            System.out.println(temp);
            //将temp后移
            temp = temp.next;
        }
    }
    //主程序
     public static void main(String[] args) {
        HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode hero2 = new HeroNode(2,"卢俊义","玉麒麟");
        HeroNode hero3 = new HeroNode(3,"吴用","智多星");
        HeroNode hero4 = new HeroNode(4,"林冲","豹子头");
        DoubleSingleLikedList singleLikedList = new DoubleSingleLikedList();
        singleLikedList.addLast(hero1);
        singleLikedList.addLast(hero2);
        singleLikedList.addLast(hero3);
        singleLikedList.addLast(hero4);
        System.out.println("====遍历链表信息====");
        singleLikedList.show();
    }

1.3 运行结果

在这里插入图片描述

2、双向链表的添加

2.1 思路

默认添加到双向链表最后。
（1）先找到双向链表的最后一个节点，赋给temp；
（2）temp.next = newHer

2.2 代码编写

//添加节点到双向链表最后
    public void addLast(HeroNode heroNode) {
        //因为head节点不能动，因此需要新建一个辅助变量temp
        HeroNode temp = head;
        while (temp.next != null)
        {
            temp = temp.next;//遍历到最后一个节点，赋给temp
        }
        temp.next = heroNode;
        heroNode.pre = temp;
    }
    //主程序
    public static void main(String[] args) {
        HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode hero2 = new HeroNode(2,"卢俊义","玉麒麟");
        HeroNode hero3 = new HeroNode(3,"吴用","智多星");
        HeroNode hero4 = new HeroNode(4,"林冲","豹子头");
        DoubleSingleLikedList singleLikedList = new DoubleSingleLikedList();
        singleLikedList.addLast(hero1);
        singleLikedList.addLast(hero2);
        singleLikedList.addLast(hero3);
        System.out.println("====添加前遍历链表信息====");
        singleLikedList.show();
        System.out.println("====添加后遍历链表信息====");
        singleLikedList.addLast(hero4);
        singleLikedList.show();
    }

2.3 运行结果

在这里插入图片描述

3、双向链表的修改

3.1 思路

修改节点的信息，根据编号no来修改，即编号no不能改。

3.2 代码编写

//修改节点的信息，根据编号no来修改，即编号no不能改
    public void update(HeroNode heroNode){
        //判断链表是否为空
        if (head.next == null){
            System.out.println("链表为空");
            return;
        }
        //根据编号no找到需要修改的节点
        //因为head节点不能动，因此需要新建一个辅助变量temp
        HeroNode temp = head.next;
        boolean flag = false;//表示是否找到该节点
        while(true){
            if(temp == null){//表示链表已经遍历结束
                break;
            }
            if(temp.no == heroNode.no){//表示找到了
                flag = true;
                break;
            }
            temp = temp.next;
        }
        //根据flag判断是否找到要修改的节点
        if(flag){
            temp.name = heroNode.name;
            temp.nickname = heroNode.nickname;
        }else {
            System.out.printf("没有找到编号%d的节点，不能修改\n",heroNode.no);
        }
    }
    //主程序
    public static void main(String[] args) {
        HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode hero2 = new HeroNode(2,"卢俊义","玉麒麟");
        HeroNode hero3 = new HeroNode(3,"吴用","智多星");
        HeroNode hero4 = new HeroNode(4,"林冲","豹子头");
        HeroNode hero5 = new HeroNode(1,"宋押司","及时雨~~");
        DoubleSingleLikedList singleLikedList = new DoubleSingleLikedList();
        singleLikedList.addLast(hero1);
        singleLikedList.addLast(hero2);
        singleLikedList.addLast(hero3);
        singleLikedList.addLast(hero4);
        System.out.println("====修改前遍历链表信息====");
        singleLikedList.show();
        System.out.println("====修改后遍历链表信息====");
        singleLikedList.update(hero5);
        singleLikedList.show();
    }

3.3 运行结果

在这里插入图片描述

4、双向链表的删除

4.1 思路

（1）因为是双向链表，因此可以实现自我删除某个节点；
（2）直接找到要删除的这个节点，比如temp;
（3）temp.pre.next = temp.next;
（4）temp.next.pre = temp.pre.

4.2 代码编写

 //删除节点
    public void delete(int no) {
        //判断链表是否为空
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //因为head节点不能动，因此需要新建一个辅助变量temp
        HeroNode temp = head.next;
        boolean flag = false;//flag标识是否找到需要删除节点，默认为false
        while (true) {
            //判断是否到链表最后
            if (temp == null) {
                break;
            }
            if (temp.no == no)//找到了需要删除节点的前一个节点
            {
                flag = true;
                break;
            }
            //将temp后移
            temp = temp.next;
        }
        if (flag) {
            temp.pre.next = temp.next;
            if(temp.next != null){
                temp.next.pre = temp.pre;
            }

        } else {
            System.out.printf("需要删除节点编号%d不存在", no);
        }
    }

4.3 运行结果

在这里插入图片描述

5、完整代码

public class DoubleLinedListDemo {
    public static void main(String[] args) {
        HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode hero2 = new HeroNode(2,"卢俊义","玉麒麟");
        HeroNode hero3 = new HeroNode(3,"吴用","智多星");
        HeroNode hero4 = new HeroNode(4,"林冲","豹子头");
        DoubleSingleLikedList singleLikedList = new DoubleSingleLikedList();
        singleLikedList.addLast(hero1);
        singleLikedList.addLast(hero2);
        singleLikedList.addLast(hero3);
        singleLikedList.addLast(hero4);
        System.out.println("====删除前遍历链表信息====");
        singleLikedList.show();
        System.out.println("====删除后遍历链表信息====");
        singleLikedList.delete(4);
        singleLikedList.show();
    }
}
//定义SingleLinkedList来管理英雄
class DoubleSingleLikedList {
    //先初始化一个头节点，头节点不要动，不存放具体数据
    private HeroNode head = new HeroNode(0, "", "");

    //返回头节点
    public HeroNode getHead() {
        return head;
    }
    //显示链表（遍历）
    public void show() {
        //判断链表是否为空
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //因为head节点不能动，因此需要新建一个辅助变量temp
        HeroNode temp = head.next;
        while (true) {
            //判断是否到链表最后
            if (temp == null) {
                break;
            }
            //输出节点信息
            System.out.println(temp);
            //将temp后移
            temp = temp.next;
        }
    }

    //添加节点到双向链表最后
    public void addLast(HeroNode heroNode) {
        //因为head节点不能动，因此需要新建一个辅助变量temp
        HeroNode temp = head;
        while (temp.next != null)
        {
            temp = temp.next;//遍历到最后一个节点，赋给temp
        }
        temp.next = heroNode;
        heroNode.pre = temp;
    }

    //修改节点的信息，根据编号no来修改，即编号no不能改
    public void update(HeroNode heroNode){
        //判断链表是否为空
        if (head.next == null){
            System.out.println("链表为空");
            return;
        }
        //根据编号no找到需要修改的节点
        //因为head节点不能动，因此需要新建一个辅助变量temp
        HeroNode temp = head.next;
        boolean flag = false;//表示是否找到该节点
        while(true){
            if(temp == null){//表示链表已经遍历结束
                break;
            }
            if(temp.no == heroNode.no){//表示找到了
                flag = true;
                break;
            }
            temp = temp.next;
        }
        //根据flag判断是否找到要修改的节点
        if(flag){
            temp.name = heroNode.name;
            temp.nickname = heroNode.nickname;
        }else {
            System.out.printf("没有找到编号%d的节点，不能修改\n",heroNode.no);
        }
    }

    //删除节点
    public void delete(int no) {
        //判断链表是否为空
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //因为head节点不能动，因此需要新建一个辅助变量temp
        HeroNode temp = head.next;
        boolean flag = false;//flag标识是否找到需要删除节点，默认为false
        while (true) {
            //判断是否到链表最后
            if (temp == null) {
                break;
            }
            if (temp.no == no)//找到了需要删除节点的前一个节点
            {
                flag = true;
                break;
            }
            //将temp后移
            temp = temp.next;
        }
        if (flag) {
            temp.pre.next = temp.next;
            if(temp.next != null){
                temp.next.pre = temp.pre;
            }

        } else {
            System.out.printf("需要删除节点编号%d不存在", no);
        }
    }

}
//定义HeroNode类，每个HeroNode对象就是一个节点
class HeroNode {
    public int no;
    public String name;
    public String nickname;
    public HeroNode next;//指向下一个节点
    public HeroNode pre;//指向上一个节点

    //构造器
    public HeroNode(int no, String name, String nickname) {
        this.no = no;
        this.name = name;
        this.nickname = nickname;
    }

    //重写toString方法
    public String toString() {
        return "HeroNode[no=" + no + ",name=" + name + ",nickname=" + nickname + "]";
    }
}
dengmsjava
关注
  • 1
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构与算法--双向链表(Double Linked List)、单向环形链表(Circular Linked List)
ZZay's
01-22 1328
此文章仅作为自己学习过程中的记录和总结，同时会有意地去用英文来做笔记，一些术语的英译不太准确，内容如有错漏也请多指教，谢谢！ 一、双向链表-概述 -双向链表的基本组成结构： Node：自定义的结点结构。 (Node) head：指向单链表头结点的“头指针”。 -自定义结点的基本组成结构： 数据域：存放具有实际意义的数据。 “指针”域(next)：存放一个指向下一结点的“指针”。 “指针”域(pre)：存放一个指向上一结点的“指针”。【与单链表的区别】 -优点： 遍历方向：单链表只能朝向一个方向
C语言使用双向循环链表实现通讯录
weixin_45050042的博客
10-11 3073
使用双向链表实现通信录，实现添加功能、删除功能、查询功能、修改功能、显示功能。 #include<stdio.h> #include<stdlib.h> #include<string.h> typedef struct linkman { char name[10]; char Tel[20]; struct linkman *prev; struc...
双向链表的实现(头插尾插和删除、遍历)
august5291的博客
09-12 748
关于双向链表和循环链表，维基上的解释是： 双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。 循环链表是一种链式存储结构，它的最后一个结点指向头结点，形成一个环。因此，从循环链表中的任何一个结点出发都能找到任何其他结点。循环链表的操作和单链表的操作基本一致，差别仅仅在于算法中的循环条件有所不同。 #include <stdio.h&g
双链表详解(初始化、插入、删除、遍历)(数据结构与算法)
最新发布
AII_IIA的博客
11-04 2505
同时，删除节点后必须确保释放相应的内存空间，以防止内存泄漏问题的发生。11. 双链表相较于单链表需要额外存储指向前一个节点的指针，因此会在空间上占用更多的内存。7. 双链表的每个节点包含三个部分：数据域、指向前一个节点的指针和指向下一个节点的指针。在双链表中删除节点的操作相对比较复杂，因为我们需要维护前驱节点和后继节点之间的指针连接。在双链表中插入节点需要更新前驱节点和后继节点的指针连接，操作相对比较复杂。将 p 结点的next指针，指向q结点的后继结点。程序设计如下：注意修改指针时要注意顺序！
【数据结构】--双向链表
m0_74044018的博客
04-15 942
1、主要讲述了双向循环链表的实现细节 2、再述了顺序表和链表的优缺点
双向链表的实现（插入，删除，修改，遍历）
m0_46400910的博客
12-06 943
目录 双向链表遍历 思路 代码 双向链表无序添加 双向链表顺序添加 思路 双向链表修改 代码 双向链表删除 双向链表遍历 与单链表思路一样 public void list() { // 判断链表是否为空 if (head.next == null) { System.out.println("链表为空"); return; } // 因为头节
C语言 数据结构双向链表简单实例
08-31
本文主要介绍了C语言数据结构双向链表简单实例的相关知识点，包括双向链表的基本操作、删除元素、插入元素、判断对称性、排序等。 一、双向链表的基本操作 双向链表是一种数据结构，它可以在链表的任意位置插入或...
数据结构 双向链表（C++）
06-07
双向链表是一种特殊的数据结构，它在计算机程序设计中扮演着重要角色，特别是在C++这样的编程语言中。本节将深入探讨双向链表的概念、其结构、操作以及C++中的实现。 双向链表与单链表不同，它允许每个节点不仅有一...
数据结构 双向链表的创建和读取详解及实例代码
08-31
数据结构双向链表的创建和读取详解及实例代码 双向链表是一种重要的数据结构，它允许用户从头部和尾部访问链表的任意节点，提高了查找和插入的效率。在本节中，我们将详细介绍双向链表的创建和读取，并提供实例代码...
数据结构双向链表
09-24
这种设计使得双向链表在插入、删除和遍历等操作上比单链表更灵活，因为我们可以从任一方向进行操作。 在C语言中，实现双向链表通常需要定义一个结构体来表示链表节点，如下： ```c typedef struct Node { int ...
C语言实现数据结构和双向链表操作
08-31
本文主要介绍了C语言实现数据结构双向链表操作的相关知识点。双向链表是一种常用的数据结构，它可以从两个方向搜索某个结点，且可以从头结点和尾结点进行遍历。 1. 双向链表的类型描述 在C语言中，双向链表结点的...
自己动手写数据结构：双向循环List类模板C++实现（功能较全）
jobsxiao的专栏
08-04 740
双向循环链表的概念想必大家应该比我清楚呵，在此不多说，主要想总结一下我在编程过程中的两点经验：        第一，如果在链表中插入时仅仅指出直接前驱结点，钩链时必须注意先后次序是： “先右后左”。部分语句组如下： L= new LNode(); L->val=e; L->next=p->next;   p->next->prev=L; p->next=L;         L->p
数据结构双向链表学习
fengjuju的博客
05-02 1265
目录 一.双链表 二.代码展示 1.双向链表的定义 2.双向链表的初始化 3.双向链表在指定位置插入新元素 4.双向链表删除指定元素 5.找到指定元素的位置 6.打印链表长度 7.双向链表的整表删除 8.返回指定结点的地址 9.完整代码 10.样例测试输出 三.总结 一.双链表 双链表对比于单链表添加了一个前驱指针域，优势是可以实现双向遍历，而单链表只能从头结点开始遍历。 学生作业，大佬路过有误请指正。 二.代码展示 1.双向链表的定义 /** * Do
遍历双向链表
Graylag
11-05 3640
<br /> <br />一 list_for_each()<br />遍历head(struct list_head)索引的双向链表，没找到一个节点就将该节点赋给pos(struct list_head)<br /><br /> #define list_for_each(pos, head) /<br />     for (pos = (head)->next; prefetch(pos->next), pos != (head); pos = pos->next)<br />       
双向链表的遍历，添加，修改，删除的操作思路
wenchang-的博客
04-30 425
1) 遍历 方和 单链表一样，只是可以向前，也可以向后查找 2) 添加 (默认添加到双向链表的最后) 先找到双向链表的最后这个节点 temp.next = newHeroNode newHeroNode.pre = temp; 3) 修改 思路和 原来的单向链表一样. 4) 删除 因为是双向链表，因此，我们可以实现自我删除某个节点 直接找到要删除的这个节点，比如temp temp.pr...
6、双向链表：从双向开始都可以遍历所有数据
大宇的专栏
04-24 2659
链表中，从前向后和从后向前两个方向都有链，并将有顺序的数据连接起来的方法叫做双向链表。 双向链表有以下三种要素： 数据 指向前一结点的指针 指向后一结点的指针 “数据” 是结点中保存的整数、浮点数和字符串等，由链表管理的数值。 “指向后一结点的指针” 又叫 “后继指针”， 起到连接后继结点的作用，指向后继结点的位置信息。 “指向前一结点的指针” 又叫 “前驱指针”， 起到连接前驱...
双向链表的创建与遍历（c++实现）
qq_36472818的博客
04-30 2863
目录前言双向链表双向链表的创建与遍历实现代码运行截图总结 前言 前面学习了单向链表的各项操作，本篇主要介绍双向链表的各种操作！ 双向链表 单向链表只能单向遍历，万一不幸其中有一个链接断裂，那么后面的链表数据便会遗失而无法复原。因此可以将两个方向不同的链表结合起来，除了存放数据的字段外，它还有两个指针变量，其中一个指向逻辑后（逻辑右）的节点，其中一个指向逻辑前（逻辑左）的节点，这样的链表被称作双向链...
双向链表与循环链表
热门推荐
wyqwilliam的博客
09-16 1万+
双向链表 单链表的一个优点是结构简单，但是它也有一个缺点，即在单链表中只能通过一个结点的引用访问其后续结点，而无法直接访问其前驱结点， 要在单链表中找到某个结点的前驱结点，必须从链表的首结点出发依次向后寻找，但是需要Ο(n)时间。 为此我们可以扩展单链表的结点结构，使得通过一个结点的引用，不但能够访问其后续结点，也可以方便的访问其前驱结点。 扩展单链表结点结构的方法是，在单链表结点结构中新增加一...
双向循环链表
xu_ya_fei的专栏
11-12 1万+
双向循环链表
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值