双向链表中节点的增删改查

一. 基本介绍

1. 单向链表与双向链表的比较：
   (1) 查找的方向只能是一个方向，而双向链表可以向前或者向后查找。
   (2) 单向链表不能自我删除，需要依靠辅助节点 ，而双向链表，则可以自我删除。
2. 本次在节点中增加了指向前一个节点的指针，实现双向链表的增删改查操作。

二. 代码实现

1. 节点

package datastructure.linkedlist.doublelinkedlist;

public class HeroNode {

    public int no;         // 编号
    public String name;    // 姓名
    public HeroNode next;  // 下一个节点
    public HeroNode pre;   // 前一个节点

    public HeroNode() {
    }

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

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

}

2. 链表

package datastructure.linkedlist.doublelinkedlist;

public class DoubleLinkedList {

    private HeroNode head = new HeroNode(0, "");

    // 头结点的get方法
    public HeroNode getHead() {
        return head;
    }

    // 添加节点
    public void add(HeroNode heroNode) {
        HeroNode temp = head;
        // 寻找链表的最后一个节点
        while (true) {
            if (temp.next == null) {
                break;
            }
            temp = temp.next;
        }
        // 将要添加的节点连接在链表的最后面
        temp.next = heroNode;
        heroNode.pre = temp;
    }

    // 按照编号顺序添加节点
    public void addByOrder(HeroNode heroNode) {
        HeroNode temp = head;
        // 判断要添加节点的编号与链表中各节点的编号是否重复  true为重复
        boolean flag = false;
        // 寻找合适的位置
        while (true) {
            if (temp.next == null) {
                break;
            }
            if (temp.next.no > heroNode.no) {
                break;
            } else if (temp.next.no == heroNode.no) {
                // 编号重复
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            System.out.println("节点编号重复！");
        } else {
            // 将要添加的节点连接到合适的位置
            heroNode.pre = temp;
            temp.next = heroNode;
            if (temp.next != null) {
                temp.next.pre = heroNode;
                heroNode.next = temp.next;
            }
        }
    }

    /**
     *  删除节点
     * @param heroNo 要删除节点的编号
     */
    public void delete(int heroNo) {
        if (head.next == null) {
            System.out.println("此链表为空！");
        }
        HeroNode temp = head.next;
        // 判断链表是否包含要删除的节点
        boolean flag = false;
        // 寻找要删除的节点
        while (true) {
            if (temp.no == heroNo) {
                // 找到要删除的节点
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            // 把要删除的节点从链表中去除
            temp.pre.next = temp.next;
            if (temp.next != null) {
                temp.next.pre = temp.pre;
            }
        }
    }


    // 修改节点数据
    public void update(HeroNode heroNode) {
        HeroNode temp = head.next;
        boolean flag = false;
        while (true) {
            if (temp == null) {
                System.out.println("没有要修改的这个节点！");
                break;
            }
            if (temp.no == heroNode.no) {
                // 找到要修改的节点
                flag = true;
                break;
            }
            temp = temp.next;
        }
        // 如果在链表中找到了要修改的节点，就修改节点的数据
        if (flag) {
            temp.name = heroNode.name;
        }
    }

    // 遍历所有节点
    public void allNode() {
        HeroNode temp = head.next;
        if (temp == null) {
            System.out.println("此链表为空链表！");
            return;
        }
        // 打印链表中的节点
        while (true) {
            System.out.println(temp);
            temp = temp.next;
            if (temp == null) {
                break;
            }
        }
    }


}

3. 测试类

package datastructure.linkedlist.doublelinkedlist;

public class DoubleLinkedListTest {

    public static void main(String[] args) {
        HeroNode heroNode1 = new HeroNode(1, "宋江");
        HeroNode heroNode = new HeroNode(2, "卢俊义");
        HeroNode heroNode3 = new HeroNode(3, "吴用");
        HeroNode heroNode4 = new HeroNode(4, "林冲");

        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
        // 添加节点
        doubleLinkedList.addByOrder(heroNode);
        doubleLinkedList.addByOrder(heroNode4);
        doubleLinkedList.addByOrder(heroNode3);
        doubleLinkedList.addByOrder(heroNode1);
        /*doubleLinkedList.add(heroNode1);
        doubleLinkedList.add(heroNode3);
        doubleLinkedList.add(heroNode4);
        doubleLinkedList.add(heroNode2);*/
        // 遍历
        doubleLinkedList.allNode();
        // 修改双链表的节点
        HeroNode newHeroNode = new HeroNode(4, "小葱");
        doubleLinkedList.update(newHeroNode);
        // 遍历
        System.out.println("修改后的链表：");
        doubleLinkedList.allNode();
        // 删除节点
        doubleLinkedList.delete(3);
        doubleLinkedList.delete(4);
        // 遍历
        System.out.println("删除节点后的链表：");
        doubleLinkedList.allNode();
    }
}