数据结构--------双向链表的增删改查

双向链表

单向链表缺点分析

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

2. 单向链表不能自我删除，需要靠辅助节点，而双向链表可以自我删除

分析双向链表的遍历，添加，修改，删除的操作思路 ===》代码实现

1. 遍历方法和单链表一样，既可以从前面遍历，也可以从后面遍历

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

   1. 先找到双向链表的最后节点

   2. temp.next = newHeroNode

3. 修改的思路和原来的单向链表一样

4. 删除

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

   2. 直接找到要删除的这个节点，比如temp（被删除的那个节点）

   3. temp.pre.next = temp.next

   4. temp.next.pre = temp.pre

增加

//添加节点到双向链表（直接添加到尾部）
     public void add(HeroNode2 heroNode2) {
         HeroNode2 temp = head;
         while (true) {
             if (temp.next==null) {
                 break;
             }
             temp = temp.next;
         }
         temp.next = heroNode2;
         heroNode2.pre = temp;
     }
 //第二种添加节点到双向链表(按照编号顺序进行添加)
     public void add2(HeroNode2 heroNode2) {
         HeroNode2 temp = head;
         boolean flag = false;
         while (true) {
             if (temp.next==null) {
                 break;
             }
             if (temp.next.no>heroNode2.no) {
                 break;
             }
             if (temp.no==heroNode2.no) {
                 flag = true;
                 break;
             }
             temp = temp.next;
         }
         if (flag) {
             System.out.println("输入的链表已经存在~");
         }else {
             heroNode2.next = temp.next;
             heroNode2.pre = temp;
             temp.next = heroNode2;
             if (heroNode2.next!=null) {
                 heroNode2.next.pre = heroNode2;
             }
             
         }
     }

修改

//修改双向链表中的节点
     public void update(HeroNode2 newheroNode2) {
         //判断链表是否为空
         if (head.next ==null) {
             System.out.println("链表为空");
             return;
         }
         HeroNode2 temp = head.next;
         boolean flag = false;
         while (true) {
             if (temp == null) { //表示链表已经遍历完了
                 break;
             }
             if (temp.no == newheroNode2.no) { //表示已经找到要修改的节点
                 flag = true;
                 break;
             }
             temp = temp.next;
         }
         //根据flag判断是否找到要修改的节点
         if (flag) {
             temp.name = newheroNode2.name;
             temp.nickName = newheroNode2.nickName;
         }else {
             System.out.printf("没有找到编号%d的节点\n",newheroNode2.no);
         }
     }

删除

//从双向链表中删除一个节点
     /**
      * 说明
      * 1、对于双向链表，我们可以直接找到要删除的这个节点
      * 2、找到后，自我删除即可
      * */
     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) {  //找到要删除的那个节点
                 flag = true;
                 break;
             }
             temp = temp.next;
         }
         if (flag) {
             temp.pre.next = temp.next;
             //如果是最后一个节点，就不需要执行下面这句话，否则出现空指针
             if (temp.next!=null) {
                 temp.next.pre = temp.pre;
             }
         }else {
             System.out.printf("找不到%d的节点\n",no);
         }
     }