Java数据结构和算法（双向链表）

双向链表：

    1、单向链表只能是一个方向查找，双向链表向前或者向后查找

    2、双向链表可以自我删除

    3、next pre【指向前一个节点】

双向链表的遍历，添加，修改，删除思路：

    1、遍历：遍历的方式和单链表一样，可以向前，也可以向后

    2、添加（默认添加到双向链表的最后）

    （1）、先找到双向链表的最后这个节点

    （2）、temp.next = newHeroNode

    （3）、newHeroNode.pre = temp

    3、修改 思路和原理和单项链表一样

    4、删除

    （1）、因为是双向链表，因此我们可以实现自我删除某个节点

    （2）、直接找到删除的节点，比如temp

    （3）、temp.pre.next = temp.next

    （4）、temp.next.pre = temp.pre

 

代码如下：

package com.huaze.sparsearray;

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

        doubleLinkedList.list();

        //修改测试
        HeroNode2 newHeroNode = new HeroNode2(4, "公孙胜", "入云龙");
        doubleLinkedList.update(newHeroNode);
        System.out.println("修改后的链表情况~~");
        doubleLinkedList.list();

        //删除测试
        doubleLinkedList.del(3);
        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);
                //将next后移
                temp = temp.next;
            }
        }

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

        //修改一个节点的内容，双向链表 节点内容修改 和单向链表一样，节点的类型改成HeroNode2
        public void update(HeroNode2 NewHerNode) {
            //判断是否为空
            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 == NewHerNode.no) {
                    //找到
                    flag = true;
                    break;
                }
                temp = temp.next;
            }
            //根据flag 判断是否找到要修改的节点
            if (flag) {
                temp.name = NewHerNode.name;
                temp.nickname = NewHerNode.nickname;
            } else { //没有找到
                System.out.printf("没有找到编号 %d的节点，不能修改\n", NewHerNode.no);
            }
        }

        //从双向链表中删除一个节点
        //对于双向链表，直接找到删除节点，找到以后自我删除
        public void del(int no) {
            //判断当前链表是否为空
            if (head.next == null) {
                System.out.println("链表为空，不能删除");
                return;
            }

            HeroNode2 temp = head.next;//辅助指针
            boolean flag = false; // 表示是否找到待删除节点
            while (true) {
                if (temp == null) { //已经到链表最后
                    break;
                }
                if (temp.no == no) {
                    //找到了待删除节点的前一个节点 temp
                    flag = true;
                    break;
                }
                temp = temp.next;//temp后移 实现遍历
            }
            //判断flag
            if (flag) {
                //找到
                //可以删除
                temp.pre.next = temp.next;
                //如果是最后一个节点，就不需要执行这句话，不然会出现空指针异常
                if (temp.next != null) {
                    temp.next.pre = temp.pre;
                }
            } else {
                System.out.printf("要删除的 %d 节点不存在", no);
            }
        }
    }
        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 ninckname) {
                this.no = no;
                this.name = name;
                this.nickname = ninckname;
            }

            //为了显示方便，重写toString方法

            @Override
            public String toString() {
                return "HeroNode{" +
                        "no=" + no +
                        ", name='" + name + '\'' +
                        ", nickname='" + nickname + '\'' +
                        '}';
            }
        }