雙鏈表的實現（Java實現）

雙鏈表與單鏈表的區別是，單鏈表只能沿着一個方向去查找，雙鏈表可以沿着正向和反向進行查找。如下圖所示。單鏈表的實現可以看我前面的博客

 

實現原理

在原來單鏈表的屬性中會添加一個pre（存放前一個節點的地址），原有屬性不變。

查找：和單鏈表的查找是完全一樣的，只不過，通過反方向也可以進行查找

修改：和單鏈表的修改是一樣的。

刪除：刪除有點特殊，單鏈表是將一個節點移除之後，將該節點的前一個節點的next指向該節點的下一個節點。但是雙鏈表有點不同，除了將一個方向的指針移動之外，還要操作反方向的指針，即將刪除節點的下一個節點的前驅指向刪除節點的上一個節點，即完成刪除。

添加：添加操作也有點不同，之前單鏈表是將節點添加到該鏈表的最後一個節點之後，將最後一個節點的next指向添加的節點即可。雙鏈表也是將節點添加到最後一個節點之後，只不過還要將添加節點的前驅指向最後一個節點，實現雙向鏈接。

實現代碼

package cn.mrlij.linkedlist;

/**
 * 雙向鏈表的實現
 */
public class DoubleLinkedList {
    public static void main(String[] args) {
        DoubleLinkedListDemo s = new DoubleLinkedListDemo();
        s.add(new HeroNode2(1,"張飛","小張"));
        s.add(new HeroNode2(2,"劉備","小劉"));
        s.add(new HeroNode2(3,"關羽","小關"));
//        s.del(3); //刪除
        s.update(new HeroNode2(3,"曹操","小曹"));
        s.list();
    }
}
class DoubleLinkedListDemo{
    //創建一個頭結點，初始化數據，頭結點不要動，不放具體的數據

    private HeroNode2 head = new HeroNode2(0,"","");
    public HeroNode2 getHead() {
        return head;
    }
    //刪除節點 與單鏈表不同的是，要刪除節點.next.pre指向 要刪除節點的前一個節點（排除刪除最後一個節點的情況）
    public void del(int no) {
        if(head.next == null) {
            System.out.println("鏈表爲空！");
            return;
        }
        HeroNode2 temp = head;
        boolean flag = false;
        while(true) {
            if(temp.next == null) {
                break;
            }
            if(temp.next.no == no) {
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if(flag) {
            temp.next = temp.next.next;
            //需要做出判斷，當刪除的是最後一個節點，不作處理就會報空指針異常
            if(temp.next != null){
                temp.next.pre = temp;
            }
//            temp.pre.next = temp.next;
//            if(temp.next!=null){
//                temp.next.pre = temp.pre;
//            }
//            temp.pre.next = temp.next;
//
//            //需要做出判斷，當刪除的是最後一個節點，就會報空指針異常
//            if(temp.next!=null){
//                temp.next.pre = temp.pre;
//            }

        }else {
            System.out.println("該節點不存在！");
        }
    }
    //修改節點內容
    public void update(HeroNode2 node ) {
        if(head.next == null) {
            System.out.println("鏈表爲空！");
            return;
        }
        HeroNode2 temp = head.next;
        boolean flag = false;
        while(true) {
            if(temp == null) {
                break;
            }
            if(temp.no == node.no) {
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if(flag) {
            temp.name = node.name;
            temp.nickname = node.nickname;
        }else {
            System.out.println("不存在該節點！");
        }
    }
    //添加英雄
    public void add(HeroNode2 node) {
        //先找出最後的一個節點，把新加的節點放在最後一個節點的後面
        HeroNode2 temp = head;
        while(true) {
            if(temp.next == null) {
                break;
            }
            temp = temp.next;
        }
        temp.next = node;
        //與單鏈表不同的是，添加的節點的前驅指向上一個節點
        node.pre = temp;
    }
    //遍歷鏈表，與單鏈表不同的是，可以從不同的方向遍歷雙向鏈表,即可以從前面遍歷，也可以從後面遍歷
    public void list() {
        HeroNode2 temp = head;
        //首先判斷鏈表是否爲空
        if(temp.next == null) {
            System.out.println("鏈表爲空！");
            return;
        }
        while(true) {
            if(temp.next == null) {
                break;
            }
            System.out.println(temp.next);
            temp = temp.next;
        }
    }
}
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 + "]";
    }
}