03双向链表

双向链表

单向链表的缺点

1. 单向链表，只能是一个方向来查找，而双向链表可以向前或者向后查找。
2. 单向链表不能自我删除，需要靠辅助结点。而双向链表可以自我删除。所以我们单链表删除结点的时候，总要找到temp（待删除结点的前一个结点）的下一个结点来完成删除操作。

单向链表结点示意图

双向链表逻辑图

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

遍历

与单向链表一样，可以向前也可以向后遍历。

添加

添加在最后

1. 找到链表的最后一个结点temp
2. temp.next = newNode;
3. newNode.pre = temp;

在中间添加（需要考虑指针变动顺序）

1. 找到要添加的前一个结点temp
2. newNode.next = temp.next
3. temp.next.pre = newNode
4. newNode.pre = temp
5. temp.next = newNode

修改

思路与单向链表的一致

删除

1. 因为是双向链表，所以可以实现自我删除
2. 直接找到这个这个结点，temp
3. temp.pre.next = temp.next
4. temp.next.pre = temp.pre

代码实现

package com.linkedlist;

public class DoubleLinkedListDemo {
    public static void main(String[] args) {
        System.out.println("======双向链表的测试=======");
        HeroNode2 hero1 = new HeroNode2(1, "1", "1");
        HeroNode2 hero2 = new HeroNode2(2, "2", "2");
        HeroNode2 hero3 = new HeroNode2(3, "3", "3");
        HeroNode2 hero4 = new HeroNode2(4, "4", "4");
        HeroNode2 hero5 = new HeroNode2(5, "5", "5");

        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();

        //添加
        doubleLinkedList.addNode(hero1);
        doubleLinkedList.addNode(hero2);
        doubleLinkedList.addNode(hero3);
        doubleLinkedList.addNode(hero4);
        doubleLinkedList.addNode(hero5);
        doubleLinkedList.showList();

        //修改
        System.out.println("========修改四号结点信息========");
        doubleLinkedList.updateNode(new HeroNode2(4, "04", "04"));
        doubleLinkedList.showList();

        //删除
        System.out.println("========删除3号结点信息=======");
        doubleLinkedList.deleteNode(3);
        doubleLinkedList.showList();

        //按顺序添加
        System.out.println("=========按顺序添加==========");
        DoubleLinkedList doubleLinkedList1 = new DoubleLinkedList();
        doubleLinkedList1.addNodeByOrder(new HeroNode2(4,"4","4"));
        doubleLinkedList1.addNodeByOrder(new HeroNode2(3,"3","3"));
        doubleLinkedList1.addNodeByOrder(new HeroNode2(1,"1","1"));
        doubleLinkedList1.addNodeByOrder(new HeroNode2(1,"1","1"));
        doubleLinkedList1.addNodeByOrder(new HeroNode2(2,"2","2"));
        doubleLinkedList1.addNodeByOrder(new HeroNode2(5,"5","5"));

        doubleLinkedList1.showList();
    }
}

class DoubleLinkedList {
    private HeroNode2 head = new HeroNode2(0, "", "");

    public HeroNode2 getHead() {
        return head;
    }

    //遍历双向链表
    public void showList() {
        /**
         * 1. 判断链表是否为空。
         * 2. 因为头结点不能动，所以拷贝一份。temp
         */
        if (head.next == null) {
            System.out.println("当前链表为空");
            return;
        }
        //因为头结点没有使用，所以第一个显示的结点就是head.next
        HeroNode2 temp = head.next;
        while (temp != null) {
            System.out.println(temp);
            temp = temp.next;//变量后移
        }
    }

    //添加结点
    public void addNode(HeroNode2 hero) {
        //找到最后一个结点
        //因为head结点不能用，所以先拷贝一份
        HeroNode2 temp = head;
        while (true) {
            //最后一个结点特点，结点的next属性值为null
            if (temp.next == null) {
                break;
            }
            temp = temp.next;//指针后移
        }
        //形成双向链表
        temp.next = hero;
        hero.pre = temp;
    }

    //修改  与双向链表一致
    public void updateNode(HeroNode2 newHero) {
        /**
         * 思路
         * 1. 判断是否为空
         * 2. 找到需要修改的结点
         */
        if (head.next == null) {
            System.out.println("链表为空，不满足修改条件");
            return;
        }

        HeroNode2 temp = head;
        boolean flag = false;
        while (true) {
            if (temp == null) {      //遍历完了都没有找到
                break;//已经遍历结束了
            }
            if (temp.no == newHero.no) {
                flag = true;
                break;

            }
            temp = temp.next;
        }
        if (flag) {
            temp.name = newHero.name;
            temp.nickName = newHero.nickName;
        } else {
            System.out.printf("没有找到 编号为 %d 的结点信息，不能修改\n", newHero.no);
        }
    }

    //删除结点 -- 通过英雄编号，即hero.no

    /**
     * 思路：
     * 1. 我们先找到自己
     * 2. 自我删除
     * 3. 被删除的结点，将不会有其它引用指向，剩下的交给java的垃圾回收机制。
     */
    public void deleteNode(int no) {
        HeroNode2 temp = head.next;
        boolean flag = false;
        while (true) {
            //已经到链表的最后了，还没有找到
            if (temp == null) {
                break;
            }

            //找到的情况
            if (temp.no == no) {
                flag = true;
                break;
            }
            temp = temp.next;
        }
        //业务处理
        if (flag) {
            //自我删除
            temp.pre.next = temp.next;
            //如果删除最后一个结点是没有
            if (temp.next != null) {
                temp.next.pre = temp.pre;
            }
            System.out.printf("成功删除编号为 %d 的结点\n", no);
        } else {
            System.out.printf("没有找到编号为 %d 的结点\n", no);
        }
    }
    //根据序号来添加。
    public void addNodeByOrder(HeroNode2 hero) {
        //同理，做一个拷贝
        HeroNode2 temp = head;
        boolean flag = false; //添加的编号是否存在
        //这个指针要找到添加位置的前一个结点。
        while (true) {
            if (temp.next == null) {
                break;//如果此时就是最后一个结点
            }
            //下面这两个顺序不能交换，一定是先判断是否存在再判断下一个编号是否大
            if (temp.no == hero.no) {
                flag = true;//此时已经存在了
                break;
            }
            if (temp.next.no > hero.no) {
                break;//位置找到了在这个后面添加
            }
            temp = temp.next;
        }
        if (flag) {
            System.out.printf("准备加入的英雄%d  %s已经存在了，不能添加\n", hero.no, hero.name);
        } else {
            //插入到temp后面 -- 这个顺序不能搞错了。
            if (temp.next != null){
                hero.next = temp.next;
                temp.next.pre = hero;
                hero.pre = temp;
                temp.next = hero;
            }else {
                addNode(hero);
            }
        }
    }
}

class HeroNode2 {
    public int no;
    public String name;
    public String nickName;
    public HeroNode2 next;
    public HeroNode2 pre;

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

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