Java数据结构与算法：双向链表、增删改查、思路分析、代码实现

双向链表

双链表示意图：

• 链表是以节点的方式存储，链式存储
• 每个节点包含pre域(用于存储上一个节点对象)、data域(用于存储该节点中的数据) 和 next域(用于存储下一个节点对象)
• 各个节点不一定连续存储
• 链表分带头节点和不带头节点两种，根据实际需求来确定

1、双链表的 增 删 改 查 思路分析

头节点不存任何数据，只用作链表的头，方便对链表操作等。

增加插入新节点

• 如果直接从双向链表的尾节点添加新的节点newNode：

  尾节点为temp，

  temp.next=newNode;
  newNode.pre = temp;
  

• 如果从双向链表中插入新的节点newNode：

  如图，data1为temp

  方式一：先将temp节点的下一个节点与新节点连接，再把新节点与temp节点连接
  newNode.next = temp.next;
  temp.next.pre = newNode;
  newNode.pre = temp;
  temp.next = newNode;
  
  方式二：先将temp节点与新节点连接，再把新节点与原来temp的下一个节点进行连接
  next = temp.next; // 将data1的下一个节点记录下来
  temp.next = newNode; // 将data1的next改为新节点
  newNode.pre = temp; // 新节点的pre指向temp
  newNode.next = next; // 将新新节点的next指向刚刚记录的节点
  next.pre = newNode; // 刚刚记录的节点的pre指向新节点
  

删除节点

双链表的好处就是节点可以自删。比如要删除data2，temp遍历到了data2：

temp.pre.next = temp.next;
if(temp.next != null){
     
    temp.next.pre = temp.pre; // 如果删除的是最后一个节点，就不用执行该语句
}

这样就删除了data2

修改节点内容

通过遍历，找到需要更改的节点，对其内容更改即可。

查询节点

通过遍历，查询所有节点，查询指定节点。

2、代码实现

public class DoubleLinkedListDemo {
     
    public static void main(String[] args) {
     
        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
        doubleLinkedList.addNodeById(new DouNode(1,"1"));
        doubleLinkedList.addNodeById(new DouNode(4,"4"));
        doubleLinkedList.addNodeById(new DouNode(2,"2"));
        doubleLinkedList.addNodeById(new DouNode(3,"3"));
        doubleLinkedList.addNodeById(new DouNode(2,"2"));
        doubleLinkedList.showNode();

        System.out.println("删除节点4：");
        doubleLinkedList.delNode(4);
        doubleLinkedList.showNode();
        System.out.println("删除节点2：");
        doubleLinkedList.delNode(2);
        doubleLinkedList.showNode();

        System.out.println("修改节点1：");
        doubleLinkedList.updateNode(new DouNode(1,"11111111111"));
        doubleLinkedList.showNode();
    }
}

class DoubleLinkedList{
     
    private DouNode head = new DouNode();

    // 依次添加节点
    public void addNode(DouNode node){
     
        DouNode temp = head;
        while (true){
     
            if(temp.next == null){
     
                temp.next = node;
                node.pre = temp;
                break;
            }
            temp = temp.next;
        }
    }

    // 根据id大小，添加节点
    public void addNodeById(DouNode node){
     
        DouNode temp = head;
        while (true){
     
            if(temp.next == null){
     
                temp.next = node;
                node.pre = temp;
                break;
            }
            if(temp.next.no == node.no){
     
                System.out.println("有重复节点添加...");
                break;
            }
            if (temp.next.no > node.no){
     
                temp.next.pre = node;
                node.next = temp.next;
                temp.next = node;
                node.pre = temp;
                break;
            }
            temp = temp.next;
        }
    }

    // 删除节点
    public void delNode(int no){
     
        DouNode temp = head.next;
        if(temp == null){
     
            System.out.println("链表为空，无法删除...");
            return;
        }
        while (true){
     
           if(temp == null){
     
               System.out.println("没有要删除的节点...");
               break;
           }
           if(temp.no == no){
     
               temp.pre.next = temp.next;
               if(temp.next!=null){
     
                   temp.next.pre = temp.pre;
               }
               break;
           }
           temp = temp.next;
        }
    }

    // 修改
    public void updateNode(DouNode node){
     
        DouNode temp = head.next;
        if(temp == null){
     
            System.out.println("链表为空，无法修改...");
            return;
        }
        while (true){
     
            if(temp == null){
     
                System.out.println("没有要修改的节点...");
                break;
            }
            if(temp.no == node.no){
     
                temp.name = node.name;
                break;
            }
            temp = temp.next;
        }
    }

    // 遍历链表
    public void showNode(){
     
        if(head.next == null){
     
            System.out.println("链表为空，无法遍历...");
            return;
        }
        DouNode temp = head.next;
        while (true){
     
            if(temp == null){
     
                break;
            }
            System.out.println(temp);
            temp = temp.next;
        }
    }
}

class DouNode{
     
    public int no;
    public String name;
    public DouNode pre;
    public DouNode next;

    public DouNode() {
     
    }

    public DouNode(int no, String name) {
     
        this.no = no;
        this.name = name;
    }

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

结果：

有重复节点添加...
DouNode{no=1, name='1'}
DouNode{no=2, name='2'}
DouNode{no=3, name='3'}
DouNode{no=4, name='4'}
删除节点4：
DouNode{no=1, name='1'}
DouNode{no=2, name='2'}
DouNode{no=3, name='3'}
删除节点2：
DouNode{no=1, name='1'}
DouNode{no=3, name='3'}
修改节点1：
DouNode{no=1, name='11111111111'}
DouNode{no=3, name='3'}