题18：删除链表中的节点

题18（一）：删除链表中的节点
给定一个头节点和一个要删除的节点，在链表中删除要删除的节点

我们可以把需要删除的节点的下一个节点的内容复制到需要删除节点，覆盖要删除的节点的内容后，再把要删除的节点的下一个节点指针指向下一个节点的下一个节点。
当然，需要删除的节点可能是尾节点，这时候需要遍历整个链表；也有可能是链表中的唯一一个节点，这时候直接删除头节点就好。

class Node{
    public Object value;
    public Node next;
}

public class DeleteNode {

    //可以把要删除的节点的下一个节点的内容复制到要删除的节点，然后把要删除的节点的下一个节点删除
    public void deleteNode(Node head,Node node){

        if(head == null && node == null){
            return;
        }

        //要删除的节点不是尾节点
        if(node.next != null){
            node.value = node.next.value;
            node.next = node.next.next;
        }
        //要删除的节点是唯一一个节点
        else if(head == node){
           node = null;
        }
        //删除尾节点
        else{
            Node p = head;
            while(p.next != node){
                p = p.next;
            }
            p.next = null;
        }


    }

    //test
    public static void main(String[] args) {

        Node head = new Node();
        Node node1 = new Node();
        Node node2 = new Node();
        Node node3 = new Node();

        head.next = node1;
        head.value = "head";
        node1.next = node2;
        node1.value = "node1";
        node2.next = node3;
        node2.value = "node2";
        node3.next = null;
        node3.value = "node3";

        DeleteNode dn = new DeleteNode();
        dn.deleteNode(head,node3);

        Node p = head;
        while(p != null){
            System.out.println(p.value);
            p = p.next;
        }


    }

}

题18（2）：删除链表中的重复节点
在一个排序的链表中，删除重复的节点。
例：1 -> 2 -> 3 ->3 -> 4 -> 4 -> 5
处理后：1 -> 2-> 5

class ListNode{
    public Object value;
    public ListNode next;

    public ListNode(Object value) {
        this.value = value;
    }
}

public class DeleteDuplicateNode {

    public ListNode deleteDuplacateNode(ListNode head){
       if(head == null || head.next == null){
            return head;
        }
		//设置一个临时头节点，防止第一第二个就是重复的节点
        ListNode tem = new ListNode(0);
        tem.next = head;
        ListNode pre = tem;
        ListNode node = tem.next;

        while(node != null){
            if(node.next != null && node.value == node.next.value){
                while(node.next != null && node.value == node.next.value){
                    node = node.next;
                }
                pre.next = node.next;
                node = node.next;
            }else{
                pre = pre.next;
                node = node.next;
            }

        }
        return tem.next;
    }

	//test
    public static void main(String[] args) {

        ListNode head = new ListNode(2);
        ListNode node1 = new ListNode(2);
        ListNode node2 = new ListNode(3);
        ListNode node3 = new ListNode(3);
        ListNode node4 = new ListNode(4);
        ListNode node5 = new ListNode(4);
        ListNode node6 = new ListNode(5);

        head.next = node1;
        node1.next = node2;
        node2.next = node3;
        node3.next = node4;
        node4.next = node5;
        node5.next = node6;
        node6.next = null;


        DeleteDuplicateNode dpn = new DeleteDuplicateNode();
        ListNode node = dpn.deleteDuplacateNode(head);

        ListNode p = node;
        while(p != null){
           System.out.println(p.value);
           p = p.next;
        }

    }


}