双向链表笔记

6.3 双向链表

建议参考上一篇博客单向链表，一起看
单项链表的缺点分析：

1. 单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后
2. 单向链表不能进行自我删除，需要靠辅助节点，而双向链表，则可以自我删除，所以前面我们单向链表删除时，总是找到temp, temp是待删除节点的前一个节点

双向链表与单向链表相似，但是多了一个指向前一个节点的指针

分析：

1. 遍历方法和单链表相似，只是可以向前，也可以向后查找
2. 添加（默认添加到双向链表的最后）
   1. 先找到双向链表的最后这个节点
   2. temp.next = newNode
   3. newNode.pre = temp
3. 修改 思路和原来的单向链表一样
4. 删除
   1. 因为是双向链表，因此，我们可以实现自我删除某个节点
   2. 直接找到要删除的这个节点，比如temp
   3. temp.pre.next = temp.next
   4. temp.next.pre = temp.pre

package LinckedList;

public class DoubleLinkedListDemo {
    public static void main(String[] args) {
        DoubleLinkedList s2 = new DoubleLinkedList();
        DoubleNode d1 = new DoubleNode(1,"a");
        DoubleNode d2 = new DoubleNode(2,"b");
        DoubleNode d3 = new DoubleNode(3,"c");

        s2.addNode(d1);
        s2.addNode(d3);
        s2.addNode(d2);

        s2.list();

        System.out.println("修改");
        DoubleNode d4 = new DoubleNode(3,"d");
        s2.upadate(d4);
        s2.list();

        System.out.println("删除");
        s2.del(2);
        s2.list();

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

    // 获取头节点
    public DoubleNode getHead(){
        return head;
    }

    // 遍历双向链表
    public void list(){
        if (head.next == null){
            System.out.println("链表为空");
            return;
        }
        DoubleNode temp = head.next;
        while (true){
            if (temp == null){
                break;
            }
            System.out.println(temp);
            temp = temp.next;
        }
    }

    // 添加数据
    public void addNode(DoubleNode node){
        DoubleNode temp = head;
        boolean flag = false;
        while (true){
            if (temp.next == null){
                break;
            }
            if (temp.next.id == node.id){
                flag = true;
                break;
            }else if(temp.next.id > node.id){
                break;
            }
            temp = temp.next;
        }
        if (flag){
            System.out.println("Has exsist");
            return;
        }else {
            node.next = temp.next;
            temp.next = node;
            node.pre = temp;
        }

    }

    // 修改 双向链表的修改和单向链表一样，只是节点类型改成DoubleNode
    public void upadate(DoubleNode node){
        DoubleNode temp = head.next;
        boolean flag = false; // 判断是否找到当前值
        while (true){
            if (temp == null){
                break;
            }
            if (temp.id == node.id){
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag){
            temp.id = node.id;
            temp.name = node.name;
        }else {
            System.out.println("不存在");
        }
    }

    // 删除节点
    // 说明
    // 1. 对于双向链表，我们可以直接找到要删除的点
    // 2. 找到后自我删除就好
    public void del(int id){
        if (head.next == null){
            System.out.println("NULL List");
            return;
        }
        DoubleNode temp = head.next;
        boolean flag = false;
        while (true){
            if (temp == null){
                break;
            }
            if (temp.id == id){
                flag = true;
                break;
            }
            temp = temp.next;
        }
        // 判断flag
        if (flag){
            temp.pre.next = temp.next;
            // 如果是最后这个节点就不需要执行下面这段话
            if (temp.next != null){
                temp.next.pre = temp.pre;
            }
        }else {
            System.out.println("不存在");
        }
    }
}
class DoubleNode{
    public int id;
    public String name;
    public DoubleNode pre;
    public DoubleNode next;

    public DoubleNode(int id, String name) {
        this.id = id;
        this.name = name;
    }

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