双向链表的实例

最新推荐文章于 2023-01-29 08:32:30 发布
最新推荐文章于 2023-01-29 08:32:30 发布
阅读量352 收藏 4
点赞数
分类专栏： Java数据结构与算法 文章标签： 双向链表的实例
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43618030/article/details/103074247
版权

使用带head头的双向链表实现-水浒传英雄排行榜管理单向链表的缺点分析
在这里插入图片描述
分析双向链表的遍历，添加，修改，删除的操作思路—代码实现
在这里插入图片描述双向链表增删改查代码实现
增加

 //添加一个节点到双向链表的最后
    public void add(HeroNode2 heroNode2){
        //因为head节点不能动，因此我们需要一个辅助遍历temp
        HeroNode2 temp =head;
        //遍历链表，找到最后
        while (true){
            //找到链表的最后
            if (temp.next==null){
                break;
            }
            //如果没有找到最后的，将temp后移
            temp=temp.next;
        }
        //但退出while循环时，temp就指向链表的最后
        //形成一个双向链表
        temp.next=heroNode2;
        temp.pre=temp;
    }

删除

 //从双向链表中删除一个节点
    //说明 1.对于双向链表，我们可以直接找到要删除的这个节点
    //2.找到后，自我删除即可
    public void del(int no){
        //判断当前链表是否为空
        if (head.next==null){
            System.out.println("链表为空不能删除");
        }
        HeroNode2 temp=head.next;//辅助节点
        boolean flag=false;//标志是否找到待删除节点的
        while (true){
            if (temp==null){//已经到链表的最后节点的next
                break;
            }
            if (temp.no==no){
                //找到待删除节点的前一个节点temp
                flag=true;
                break;
            }
            temp=temp.next;//temp后移，遍历
        }
        //判断flag
        if (flag){//找到
            //可以删除
           // temp.next=temp.next.next;//单向链表的删除方式
            temp.pre.next=temp.next;
            //这里代码有问题，如果是最后一个节点，就不需要执行下面这句话，否则出现空指针
            if (temp.next != null){
                temp.next.pre=temp.pre;
            }
        }else {
            System.out.printf("要删除的%d 节点不存在\n",no);
        }
    }

修改

//修改一个节点的内容，可以看到双向链表的节点内容修改和单向链表一样
    //只是节点类型改成HeroNode2
    public void update(HeroNode2 heroNode2){
        //判断是否为空
        if (head.next==null){
            System.out.println("链表为空-");
            return;
        }
        //找到需要修改的节点，根据no编号
        //定义一个辅助变量
        HeroNode2 temp=head.next;
        boolean flag=false;//表示是否找到该节点
        while (true){
            if(temp==null){
                break;//已经遍历结束
            }
            if (temp.no==heroNode2.no){
                //找到
                flag=true;
                break;
            }
            temp=temp.next;
        }
        //根据flag判断sf找到要修改的节点
        if (flag){
            temp.name=heroNode2.name;
            temp.nickname=heroNode2.nickname;
        }else {//没有找到
            System.out.printf("没有找到编号%d的节点，不能修改\n",heroNode2.no);
        }
    }

**查看**

 //显示链表（通过遍历）
public void list(){
    //判断链表的是否为空
    if(head.next==null){
        System.out.println("链表为空");
        return;
    }
    //因为头节点不能动，因此我们需要一个辅助变量来遍历
    HeroNode2 temp=head.next;
    while (true) {
        //判断是否到链表最后
        if (temp == null) {
            break;
        }
        //输出节点信息
        System.out.println(temp);
        //将temp后移，一定要小心，不然就是个死循环
        temp = temp.next;
    }
}

测试
/

/测试
        System.out.println("双向链表的测试");
        //先创建节点
         HeroNode2 hero1 = new HeroNode2(1, "松江", "及时雨");
         HeroNode2 hero2 = new HeroNode2(3, "吴用", "智多星");
         HeroNode2 hero3 = new HeroNode2(2, "卢俊义", "玉麒麟");
         HeroNode2 hero4 = new HeroNode2(4, "林冲", "豹子头");

         //创建一个双向链表对象
        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
        doubleLinkedList.add(hero1);
        doubleLinkedList.add(hero2);
        doubleLinkedList.add(hero3);
        doubleLinkedList.add(hero4);

        doubleLinkedList.list();

        //修改
        HeroNode2 newHerNode=new HeroNode2(3,"唐三","蓝银草");
        doubleLinkedList.update(newHerNode);
        System.out.println("修改后的链表情况");
        doubleLinkedList.list();

        //删除
        doubleLinkedList.del(4);
        System.out.println("删除后的链表情况");
        doubleLinkedList.list();

实现
在这里插入图片描述

完整代码

package com.linkedlist;

public class DoubleLinkedListDemo {

    public static void main(String[] args){
        //测试
        System.out.println("双向链表的测试");
        //先创建节点
         HeroNode2 hero1 = new HeroNode2(1, "松江", "及时雨");
         HeroNode2 hero2 = new HeroNode2(3, "吴用", "智多星");
         HeroNode2 hero3 = new HeroNode2(2, "卢俊义", "玉麒麟");
         HeroNode2 hero4 = new HeroNode2(4, "林冲", "豹子头");

         //创建一个双向链表对象
        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
        doubleLinkedList.add(hero1);
        doubleLinkedList.add(hero2);
        doubleLinkedList.add(hero3);
        doubleLinkedList.add(hero4);

        doubleLinkedList.list();

        //修改
        HeroNode2 newHerNode=new HeroNode2(3,"唐三","蓝银草");
        doubleLinkedList.update(newHerNode);
        System.out.println("修改后的链表情况");
        doubleLinkedList.list();

        //删除
        doubleLinkedList.del(2);
        System.out.println("删除后的链表情况");
        doubleLinkedList.list();
    }
}
//创建一个双向链表的类
class DoubleLinkedList{
    //先初始化以一个头节点，头节点不要动，不放具体数据
    private HeroNode2 head =new HeroNode2(0,"","");

    //返回头节点
    public HeroNode2 getHead(){
        return head;
    }
    //显示链表（通过遍历）
    public void list(){
        //判断链表的是否为空
        if(head.next==null){
            System.out.println("链表为空");
            return;
        }
        //因为头节点不能动，因此我们需要一个辅助变量来遍历
        HeroNode2 temp=head.next;
        while (true) {
            //判断是否到链表最后
            if (temp == null) {
                break;
            }
            //输出节点信息
            System.out.println(temp);
            //将temp后移，一定要小心，不然就是个死循环
            temp = temp.next;
        }
    }
        //添加一个节点到双向链表的最后
    public void add(HeroNode2 heroNode2){
        //因为head节点不能动，因此我们需要一个辅助遍历temp
        HeroNode2 temp =head;
        //遍历链表，找到最后
        while (true){
            //找到链表的最后
            if (temp.next==null){
                break;
            }
            //如果没有找到最后的，将temp后移
            temp=temp.next;
        }
        //但退出while循环时，temp就指向链表的最后
        //形成一个双向链表
        temp.next=heroNode2;
        temp.pre=temp;
    }

    //修改一个节点的内容，可以看到双向链表的节点内容修改和单向链表一样
    //只是节点类型改成HeroNode2
    public void update(HeroNode2 heroNode2){
        //判断是否为空
        if (head.next==null){
            System.out.println("链表为空-");
            return;
        }
        //找到需要修改的节点，根据no编号
        //定义一个辅助变量
        HeroNode2 temp=head.next;
        boolean flag=false;//表示是否找到该节点
        while (true){
            if(temp==null){
                break;//已经遍历结束
            }
            if (temp.no==heroNode2.no){
                //找到
                flag=true;
                break;
            }
            temp=temp.next;
        }
        //根据flag判断sf找到要修改的节点
        if (flag){
            temp.name=heroNode2.name;
            temp.nickname=heroNode2.nickname;
        }else {//没有找到
            System.out.printf("没有找到编号%d的节点，不能修改\n",heroNode2.no);
        }
    }
    //从双向链表中删除一个节点
    //说明 1.对于双向链表，我们可以直接找到要删除的这个节点
    //2.找到后，自我删除即可
    public void del(int no){
        //判断当前链表是否为空
        if (head.next==null){
            System.out.println("链表为空不能删除");
        }
        HeroNode2 temp=head.next;//辅助节点
        boolean flag=false;//标志是否找到待删除节点的
        while (true){
            if (temp==null){//已经到链表的最后节点的next
                break;
            }
            if (temp.no==no){
                //找到待删除节点的前一个节点temp
                flag=true;
                break;
            }
            temp=temp.next;//temp后移，遍历
        }
        //判断flag
        if (flag){//找到
            //可以删除
           // temp.next=temp.next.next;//单向链表的删除方式
            temp.pre.next=temp.next;
            //这里代码有问题，如果是最后一个节点，就不需要执行下面这句话，否则出现空指针
            if (temp.next != null){
                temp.next.pre=temp.pre;
            }
        }else {
            System.out.printf("要删除的%d 节点不存在\n",no);
        }
    }

}
//定义一个HeroNode，每个HeroNode对象就是一个节点
class HeroNode2{
    public int no;
    public String name;
    public String nickname;
    public HeroNode2 next;//指向下一个节点，默认为null
    public HeroNode2 pre;//指向前一个节点，默认为null

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

    //为了显示方便 重新写下toString
    @Override
    public String toString(){
        return "HeroNode[no"+no+",name="+name+",nickname="+nickname+"]";
    }

}
Dkui
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
双向链表的增删查改
zw_ss
03-31 755
双向链表顾名思义，链表的每一个节点都有两个指针，一个指向上一个节点，一个指向下一个节点，通过指针将链表的头和尾连起来形成一个循环结构。 SeqList.h #pragma once #include<stdio.h> #include<Windows.h> #include<assert.h> typedef int DataType; typedef st...
java 双向链表的示例
孤舟残月梦还长存的专栏
10-11 396
双向链表在查询数据时有一个优势，就是在查询数据时并不像单向链表那样要从头到尾的查，而是可以在链表的某一中间的某一个数据向前或向后查询其它数据，使查询时间进一步缩短了那么一点点。1.检验双向链表是否成功？
双向链表实现简单的增删查改
最新发布
weixin_72868952的博客
01-29 1636
双向带头循环链表——用最复杂的结构完成最简单的工作
双链表的删除操作
m0_65060417的博客
11-05 759
删除p节点的后继节点。
数据结构双向链表学习
fengjuju的博客
05-02 1266
目录 一.双链表 二.代码展示 1.双向链表的定义 2.双向链表的初始化 3.双向链表在指定位置插入新元素 4.双向链表删除指定元素 5.找到指定元素的位置 6.打印链表长度 7.双向链表的整表删除 8.返回指定结点的地址 9.完整代码 10.样例测试输出 三.总结 一.双链表 双链表对比于单链表添加了一个前驱指针域，优势是可以实现双向遍历，而单链表只能从头结点开始遍历。 学生作业，大佬路过有误请指正。 二.代码展示 1.双向链表的定义 /** * Do
双链表的基本操作与习题练习
weixin_56169816的博客
05-09 1785
一、双链表的定义 双向链表也是链表的一种，有一个数据域data,它是用来存放数据的，有两个指针域，分别指向直接前驱pre和直接后继next。 从任意一个节点开始，都可以很方便的访问它的前驱节点和后继节点。使用这种方式解决了单链表中不能使用反向遍历的问题。 二、双链表的结构 双向链表也是采用的链式存储结构 ，因此它的结构图为： 双链表节点类型D_LinkList的声明如下： typedef int ElemType; typedef int Status; typedef struct D_LinkLis
java 实现双向链表实例详解
08-31
Java 实现双向链表实例详解 Java 实现双向链表实例详解是一种基本的数据结构，在 Java 中 LinkedList 已经实现了这种结构，但是作为开发者，也要拥有自己显示这种结构的能力。双向链表是一种动态的数据结构，它可以...
双向链表实例
06-05
双向链表是一种特殊的数据结构，它在计算机科学中被广泛应用于数据存储和处理。相比于单向链表，双向链表的每个节点不仅包含指向下一个...在`DuLinkList`实例中，通过实践这些操作，可以加深对双向链表工作原理的认识。
C++ 实现双向链表的实例
12-31
双向链表C++ 的实现   本文是通过C++ 的知识实现数据结构中的双向链表，这里不多说 了，代码注释很清楚， 实现代码： //double LinkList implement with C++ template #include using namespace std; /*template...
python双向链表实现实例代码
12-25
python双向链表实现代码： 复制代码 代码如下:#!/usr/bin/python# -*- coding: utf-8 -*- class Node(object): def __init__(self,val,p=0): self.data = val self.next = p self.prev = p class LinkList...
关于双向链表的增删改查和排序的C++实现
08-31
下面小编就为大家带来一篇关于双向链表的增删改查和排序的C++实现。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
数据结构与算法作业2——双向链表
Mike峰
09-27 445
第二次作业： 习题1 双向链表 双向链表的知识点： 同单链表相比，双链表仅是各节点多了一个用于指向直接前驱的指针域。因此，我们可以在单链表的基础轻松实现对双链表的创建。 与单链表不同，双链表创建过程中，每创建一个新节点，都要与其前驱节点建立两次联系，分别是： 将新节点的 prior 指针指向直接前驱节点； 将直接前驱节点的 next 指针指向新节点。 双向链表的创建 2021/9/26 Doubly Linked List | Set 1 (Introduction and Inser.
双向链表的简单介绍和实现增删改查功能
weixin_44824500的博客
02-28 339
使用单链表查找的方向只能是一个方向，而且不能自我删除，得要依赖一个辅助节点， 而使用双向链表就可以解决这些缺点。 单链表中的每个节点包含着一个存放数据的data域，和一个指向下一节点的next域。 双向链表中，每个节点除了包含着一个存放数据的data域，和一个指向下一节点的next域外，还多了一个指向上一节点的pre域。 下面来实现代码： 先在HeroNode中添加一个指向上一节点的pre ...
双链表的增删改查
weixin_52875557的博客
12-23 2721
1、啥是双链表？ 双链表也是链表的一种，相对于单链表而言，双链表是双向的。既有包含指向序列的前一个节点的指针，又包含指向序列的下一个节点的指针。所以基本的操作都是大同小异的，还没有了解过单链表的小伙伴可以先去了解一下。 2、思路 对上图的说明: 分析 双向链表的遍历，添加，修改，删除的操作思路 1) 遍历 2) 添加 3) 修改 4) 删除 在初始化链表时，只需要在在单链表的基础上，加上 heroNode.previous = temp; 让每次添加都指向前...
线性表——双链表的增删改查（头插法，尾插法，按序号查找，按值查找，某个位置插入元素，某个位置删除元素）
weixin_46398446的博客
01-07 1391
在学习双链表之前，可先复习巩固一下单链表，双链表这个删改查原理与单链表大致相同。 原文博客如下 单链表的增删改查 目录一、双链表的特点二、双链表的组成三、代码实现结构体1.头插法2.尾插法3.按序号查找4.按值查找5.某个位置插入元素6.某个位置删除元素打印链表 一、双链表的特点 与单链表不同是，单链表指针域中只有next指针，而双链表有两个指针，前驱指针prior和后继指针next。但是思路与单链表基本类似，不同的是指针指向必须是双向的，a->b,b->a。 二、双链表的组成 p.
一个简单的双向链表的例子
_Previous的博客
05-20 2764
题目描述： Implement the class with given header. As you guess, DouList means 逗list, very funny. to_str() function means displaying the list with std::string, formating like [1, 2, 3, 4] , [2] or [] (emp
双向链表应用实例
frozen122的博客
04-10 357
Q2：整数序列保存在双向链表中，实现如下操作： （1）创建； （2）遍历输出； （3）按值查找； （4）按位序插入； （5）按位序删除； #include<string.h> #include<stdio.h> #include<stdlib.h> typedef int ElemType; typedef struct Dnode { ElemType data; struct Dnode* pre; struct Dnode* next; }Dnode, *D
数据结构--------双向链表的增删改查
Rice_w的博客
03-08 289
双向链表 单向链表缺点分析 单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找 单向链表不能自我删除，需要靠辅助节点，而双向链表可以自我删除 分析双向链表的遍历，添加，修改，删除的操作思路 ===》代码实现 遍历方法和单链表一样，既可以从前面遍历，也可以从后面遍历 添加（默认添加到双向链表的最后） 先找到双向链表的最后节点 temp.next = newHeroNode 修改的思路和原来的单向链表一样
循环链表与双向链表详解：基本操作与应用实例
本资源是一份关于数据结构与算法的第五讲，主要涵盖循环链表和双向链表的概念、特征以及基本运算。内容分为以下几个部分： 1. 带头结点的链表： - 头结点的引入是为了方便处理，它存储链表相关信息，如表中结点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值