双向链表删除指定节点，JAVA实现

构造双向链表，删除指定节点：

public class NodeTest {

    static class MyNode {
        int val;
        MyNode preNode;
        MyNode nextNode;

        public MyNode(int val, MyNode preNode, MyNode nextNode) {
            this.val = val;
            this.preNode = preNode;
            this.nextNode = nextNode;
        }

        ;
    }

    public static void main(String[] args) {
        MyNode head = new MyNode(1, null, null);
        MyNode head1 = new MyNode(2, null, null);
        MyNode head2 = new MyNode(2, null, null);
        MyNode head3 = new MyNode(4, null, null);
        head.nextNode = head1;
        head1.preNode = head;
        head1.nextNode = head2;
        head2.preNode = head1;
        head2.nextNode = head3;
        head3.preNode = head2;

        MyNode heads = removeSpecialNode1(head, 4);
        while (heads != null) {
            System.out.println(heads.val);
            heads = heads.nextNode;
        }

    }

    private static MyNode  removeSpecialNode1(MyNode head, int i) {
        while (head != null && head.preNode == null && head.val == i) {
            //头节点
            //head指向空，下个节点前一个为空
            MyNode nextNode = head.nextNode;
            if (nextNode != null) {
                nextNode.preNode = null;
                head = nextNode;
            }
        }
        //构造指针，表面上操作headCopy，实际指向head，这样即使headCopy遍历完，head还是在头部
        //由于是构造对象引用，headCopy的删除还是会删除head对象的引用
        MyNode headCopy = head;
        while (headCopy != null) {
            if (headCopy.preNode != null&&headCopy.val == i) {
                //非头节点
                    MyNode preNode = headCopy.preNode;
                    MyNode nextNode = headCopy.nextNode;
                    if (nextNode != null) {
                        //中间节点
                        preNode.nextNode = nextNode;
                        nextNode.preNode = preNode;
                    }else {
                        //尾巴节点
                        preNode.nextNode =null;
                    }
            }
            headCopy = headCopy.nextNode;
        }
        return head;
    }

    private static MyNode  removeSpecialNodeByDummyHead(MyNode head, int i) {

        return null;
    }
}

双向链表，构造头部虚拟节点，删除指定节点 ，能有效降低代码复杂度

private static MyNode removeSpecialNodeByDummyHead(MyNode head, int i) {
        //构造虚拟节点
        MyNode dummy = new MyNode(0, null, null);
        //加入虚拟节点
        head.preNode = dummy;
        dummy.nextNode = head;
        MyNode current = dummy.nextNode;
        while (current != null) {
            if (current.val == i) {
                //前一个节点next指向当前节点下一个节点，下一个节点pre指向当前节点上一个节点
                MyNode preNode = current.preNode;
                MyNode nextNode = current.nextNode;
                preNode.nextNode = nextNode;
                if (nextNode != null) {
                    //预防尾节点空指针
                    nextNode.preNode = preNode;
                }
            }
            current = current.nextNode;
        }
        //移除虚拟头节点
        dummy.nextNode.preNode = null;
        return dummy.nextNode;
    }