浅谈:数据结构之双链表结构与代码模拟双链表的实现

双链表

本文是观看尚硅谷韩老师数据结构与算法根据老师讲解自己做的笔记,部分信息收集网络

与单链表区别

逻辑上没有区别。他们均是完成线性表的内容。主要的区别是结构上的构造有所区别。 对于单链表：

对于一个节点，有储存数据的data。和next后驱节点(指针)。也就是这个单链表想要一些遍历的操作都得通过前节点—>后节点。

对于双链表：

对于一个节点，有些和单链表一样有存储数据的data,指向后方的next（指针）。它拥有单链表的所有操作和内容。但是他还有一个前驱节点pre(指针)。

双向链表应用实例

双向链表的操作分析和实现
使用带 head 头的双向链表实现
管理单向链表的缺点分析:

1. 单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找。
2. 单向链表不能自我删除，需要靠辅助节点 ，而双向链表，则可以自我删除，所以前面我们单链表删除
   时节点，总是找到 temp,temp 是待删除节点的前一个节点(认真体会). 3) 分析了双向链表如何完成遍历，添加，修改和删除的思路
   
   对上图的说明:
   分析 双向链表的遍历，添加，修改，删除的操作思路===》代码实现
3. 遍历 方和 单链表一样，只是可以向前，也可以向后查找
4. 添加 (默认添加到双向链表的最后)
   (1) 先找到双向链表的最后这个节点
   (2) temp.next = newHeroNode
   (3) newHeroNode.pre = temp;
5. 修改 思路和 原来的单向链表一样. 4) 删除
   (1) 因为是双向链表，因此，我们可以实现自我删除某个节点
   (2) 直接找到要删除的这个节点，比如 temp
   (3) temp.pre.next = temp.next
   (4) temp.next.pre = temp.pre;

代码解释

package com.fs.demo_2020_07_14_DoubleLinkedList;

import java.util.Stack;

/**
 * 双链表 演示
 */
public class SingleDoubleLinkedListDemo {
    public static void main(String[] args) {

        //测试双链表的增删改查
        SingleDoubleLinkedList singleDoubleLinkedList = new SingleDoubleLinkedList();

        //创建节点
        System.out.println("---------添加4个节点(1,2,3,4)------------");
        Node node1 = new Node(1, "节点一");
        Node node2 = new Node(2, "节点二");
        Node node3 = new Node(3, "节点三");
        Node node4 = new Node(4, "节点四");

        //添加节点
        singleDoubleLinkedList.add(node1);
        singleDoubleLinkedList.add(node2);
        singleDoubleLinkedList.add(node3);
        singleDoubleLinkedList.add(node4);

        //显示一把
        System.out.println("----------------测试遍历双向链表---------------");
        singleDoubleLinkedList.showLinkedList();

        System.out.println("---------------测试添加节点到双链表的最后----------------------");
        Node node5 = new Node(5, "节点五");
        singleDoubleLinkedList.add(node5);
        //显示一把
        singleDoubleLinkedList.showLinkedList();

        System.out.println("----------删除节点为3的---------------");
        singleDoubleLinkedList.delNode(3);
        //显示一把
        singleDoubleLinkedList.showLinkedList();

        System.out.println("-----------修改节点5的数据为测试节点----------");
        singleDoubleLinkedList.updateByNum(new Node(5,"测试节点"));
        //显示一把
        singleDoubleLinkedList.showLinkedList();
    }


}

//创建一个类来模拟双链表
class SingleDoubleLinkedList {
    //先初始化一个头节点,头节点不动,不存放具体信息
    private Node headNode = new Node(0, "头结点");

    //生成一个get方法 返回头结点,便于后面的测试方法拿头结点测试
    public Node getHeadNode() {
        return headNode;
    }

    /*
        一  添加一个节点到双链表的最后
            思路:
         */
    public void add(Node node) {
        //拿到初始化的头结点,作为辅助遍历temp
        Node temp = headNode;
        //遍历链表,找到最后的节点
        while (true) {
            //由图解得知,单链表当遍历到最后一个节点后,next存储的值为null.因为没有下一个节点可以存储了
            if (temp.next == null) {
                //那就停止循环
                break;
            }
            //如果没有找到最后,那就将temp后移一个节点
            temp = temp.next;
        }
        //循环结束后,所明temp到达最后一个节点了,那么就在最后一个节点后添加数据,将temp的next存储添加的节点值
        temp.next = node;//将指针指到的这个节点的next指向添加的节点
        node.pre = temp;//将添加的节点的pre指向temp
    }


    /*
    三  修改节点信息,根据num来修改,但是num不能修改,只能修改num节点的name
     */
    public void updateByNum(Node newNode) {
        //还是先判断链表是否为空,判断头部节点的下一位是否为空
        if (headNode.next == null) {
            System.out.println("链表为空~~~");
            return;
        }
        //找到需要修改的节点,根据num号
        //定义一个辅助节点,这次就不是头结点了,因为头结点不能更改
        Node temp = headNode.next;
        //立一个flag,表示是否找到这个节点
        boolean flag = false;
        while (true) {
            if (temp == null) {
                break;//说明已经遍历完了
            }
            if (temp.num == newNode.num) {
                //说明找到
                flag = true;
                break;
            }
            //每次循环指针指向下一个
            temp = temp.next;
        }
        //根据flag来判断是否找到要修改的节点
        if (flag) {
            //说明找到,就将新节数据赋值给遍历到的这个节点
            temp.name = newNode.name;

        } else {
            //没有找到
            System.out.println("没有找到编号为:" + newNode.num + "的节点~~~");
        }
    }


    /*
    删除节点
        思路:
            由于是双链表结构,我们temp辅助指针指向后可以进行自我删除
     */
    public void delNode(int num) {
        //判断链表是否为空
        if (headNode.next == null) {
            System.out.println("链表为空~~~");
            return;
        }
        //同样,标志是否摘掉带删除的节点
        Node temp = headNode.next;
        //立flag
        boolean flag = false;
        while (true) {
            if (temp == null) {
                //已经到达最后的节点
                break;
            }
            //因为现在temp指向谁,谁就是可以自我删除
            if (temp.num == num) {
                //说明找到了删除节点的前一个节点temp
                flag = true;
                break;
            }
            temp = temp.next;//循环后移
        }

        //判断flag
        if (flag) {
            //说明找到,可以删除
            temp.pre.next = temp.next;//先将temp前面的next指向temp.next,这样temp就断了一条

            //因为我们可能要删除的是最后一条,最后一条的temp.next为空
            //那么temp.next== null.pre就 一定会空指针异常
            if (temp.next != null) {
                temp.next.pre = temp.pre;//在将temp的后一个的pre指向temp的pre.这样又断了一条,就实现了自我删除
            }

        } else {
            System.out.println("您需要删除的节点:" + num + "在链表中不存在~~~");
        }

    }


    /*
    显示链表,遍历查看
     */
    public void showLinkedList() {
        //判断链表否为空,
        if (headNode.next == null) {
            System.out.println("链表为空,请添加后查看~~~");
            return;
        }

        //同样,头结点不能动,作为辅助遍历,从头节点的下一位开始显示,头节点不显示
        Node temp = headNode.next;
        while (true) {
            //判断是否到最后一个节点了
            if (temp == null) {
                break;
            }
            //输出节点信息
            System.out.println(temp);
            //将temp后移
            temp = temp.next;
        }
    }


}


//创建一个类类模拟双链表节点
class Node {
    public int num;//当前节点数
    public String name;//给当前节点取个名字,模拟节点存储的数据
    public Node next;//当前节点存储的下一个节点信息
    public Node pre;//存储当前节点的前一个节点

    //提供构造方法来初始化这个节点信息
    public Node(int num, String name) {
        this.num = num;
        this.name = name;
    }


    @Override
    public String toString() {
        return "Node{" +
                "num=" + num +
                ", name='" + name + '\'' +
                '}';
    }
}

测试控制台结果

---------添加4个节点(1,2,3,4)------------
----------------测试遍历双向链表---------------
Node{num=1, name='节点一'}
Node{num=2, name='节点二'}
Node{num=3, name='节点三'}
Node{num=4, name='节点四'}
---------------测试添加节点到双链表的最后----------------------
Node{num=1, name='节点一'}
Node{num=2, name='节点二'}
Node{num=3, name='节点三'}
Node{num=4, name='节点四'}
Node{num=5, name='节点五'}
----------删除节点为3的---------------
Node{num=1, name='节点一'}
Node{num=2, name='节点二'}
Node{num=4, name='节点四'}
Node{num=5, name='节点五'}
-----------修改节点5的数据为测试节点----------
Node{num=1, name='节点一'}
Node{num=2, name='节点二'}
Node{num=4, name='节点四'}
Node{num=5, name='测试节点'}