数据结构---双向链表

双向链表

双向链表和担心链表的区别

1. 单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找。

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

单向链表

双向链表

1.遍历方法和 单链表一样，只是可以向前，也可以向后查找

思路：

1. 判断链表是否为空
2. 创建一个临时变量，遍历链表

//打印双向链表
public void list() {
    //判断链表是否为null
    if (head.next == null) {
        System.out.println("list is null");
        return;
    }
    //因为head节点不能动，所以需要辅助节点，帮助找到尾节点
    DNode temp = head.next;
    while (true) {
        //判断链表是否走到了最后
        if (temp == null) {
            break;
        }
        //打印链表信息
        System.out.println(temp);
        //继续遍历链表
        temp = temp.next;
    }
}

2.添加 (默认添加到双向链表的最后)

1. 先找到双向链表的最后这个节点
2. temp.next = newNode
3. newNode.pre = temp;

//添加节点到最后
 public void add(DNode node) {
            //因为head节点不能动，所以需要辅助节点，帮助找到尾节点
            DNode temp = head;

            //遍历链表找到最后
            while (true) {
                if (temp.next == null) {
                    break;
                }
                //如果不是最后一个节点，把temp向后移动一位
                temp = temp.next;
            }
            //退出while循环时，temp就指向了链表的最后
            //形成双向链表
            temp.next = node;
            node.pre = temp;

        }

3.修改双向链表的内容

思路：

1. 先判断链表是否为null
2. 创建一个临时变量temp遍历链表
3. 遍历链表找到对应的节点，修改节点的值

//双向链表：指定位置修改链表的内容和单链表一样
  public void updata(int num,DNode node) {
            //判断是否为null
            if (head.next == null) {
                System.out.println("链表为null");
                return;
            }
            //根据节点编号num，找到需要修改的节点，
            //定义一个辅助变量
            DNode temp = head.next;
            boolean flag = false;//表示是否找到该节点
            while (true) {
                if (temp == null) {
                    break;//遍历链表结束，没有找到该节点
                }
                if (temp.num == node.num) {
                    //找到该节点
                    flag = true;
                    break;
                }
                temp = temp.next;
            }
            //根据flag，判断是否修改节点内容
            if (flag) {
                temp.name = node.name;
                temp.nickName = node.nickName;
            } else {
                System.out.println("没有找到该节点 " + node.num);
            }
        }

4.删除

(1) 因为是双向链表，因此，我们可以实现自我删除某个节点
(2) 直接找到要删除的这个节点，比如temp
(3) temp.pre.next = temp.next
(4) temp.next.pre = temp.pre;

//双向链表：删除指定节点
    /*
    1. 对于双向链表，我们可以直接删除这个节点
    2.找到该节点进行自我删除
     */
        public void remove(int num) {
            //判断链表是否为null
            if (head.next == null) {
                System.out.println("链表为空~~");
                return;
            }
            DNode temp = head.next;
            boolean flag = false;//表示是否找到要删除的节点
            while (true) {
                if (temp.next == null) {//以及走到了链表的结尾
                    break;
                }
                if (temp.num == num) {
                    //表示找到了删除节点的前一个节点
                    flag = true;
                    break;
                }
                temp = temp.next;
            }
            //判断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.println("要删除的节点不存在");
            }

        }