剑指offer 面试题18：删除链表结点（java）

题目一：删除链表的节点
  给定单向链表的头指针和一个节点指针，定义一个函数在O(1)时间内删除该节点。

思路：

1.要删除的结点不是尾结点 （链表中间的结点）

  将要删除的结点的下一节点j内容复制到要删除的节点上，再把要删除结点的指针指向j的下一个节点。再删除j

2.要删除的结点是头结点 链表中只有一个节点

  在删除节点之后还需要把链表头结点设为null。

3.要删除的结点是链表的尾结点

  要删除的结点没有下一节点，需要从链表头结点开始，顺序遍历得到该节点的前序节点，完成删除操作。

  时间复杂度：[n-1]*O(1) + O(n)]/n = O(1)

  上述方法基于一个假设：要删除的节点的确在链表中。因需要O(n)的时间才能判断链表中是否包含某一节点，受到O(1)时间的限制，不得不将确保节点在链表中的责任推给函数的调用者

public class A_18删除链表的结点 {
    public static class ListNode {
        ListNode(){
            m_nNext=null;
        }
        int m_nValue;
        ListNode m_nNext;
    }

    public static void main(String[] args) {
        ListNode node1=new ListNode();
        ListNode node2=new ListNode();
        ListNode node3=new ListNode();
        ListNode node4=new ListNode();
        node1.m_nNext=node2;
        node2.m_nNext=node3;
        node3.m_nNext=node4;
        node1.m_nValue=1;
        node2.m_nValue=2;
        node3.m_nValue=3;
        node4.m_nValue=4;
        DeleteNode(node1,node1);
        ListNode node=node1;
        if(node==null){
            return;
        }
        while(node!=null){
            System.out.print(node.m_nValue+" ");
            node=node.m_nNext;
        }
    }
    public static void DeleteNode(ListNode pListHead,ListNode pToBeDeleted){
        if(pListHead==null||pToBeDeleted==null){
            return;
        }
        //1.删除的结点不是尾结点 （链表中间的结点）
        if(pToBeDeleted.m_nNext!=null){
            ListNode pNext=pToBeDeleted.m_nNext;
            pToBeDeleted.m_nValue=pNext.m_nValue;
            pToBeDeleted.m_nNext=pNext.m_nNext;
        }else if(pListHead==pToBeDeleted){
            //要删除的结点是头结点   链表中只有一个节点
            pListHead=null;
            pToBeDeleted=null;
        }else{//要删除的结点是链表的尾结点
            ListNode node=new ListNode();
            node=pListHead;
            while(node.m_nNext!=pToBeDeleted){
                node=node.m_nNext;
            }
            node.m_nNext=null;
        }
    }

题目二：删除链表中重复的节点
  1.头结点可能会被删除
  2.从头开始遍历整个链表。如果当前节点的值与下一个节点的值相同，那么就代表他们是重复的结点，都可以被删除。我们需要把当前节点的前一个节点和后面值比当前节点的值大的节点相连。

代码输出结果为：
        1 2 5

 public static void main(String[] args) {
        ListNode node1=new ListNode();
        ListNode node2=new ListNode();
        ListNode node3=new ListNode();
        ListNode node4=new ListNode();
        ListNode node5=new ListNode();
        ListNode node6=new ListNode();
        ListNode node7=new ListNode();
        node1.m_nNext=node2;
        node2.m_nNext=node3;
        node3.m_nNext=node4;
        node3.m_nNext=node4;
        node4.m_nNext=node5;
        node5.m_nNext=node6;
        node6.m_nNext=node7;
        node1.m_nValue=1;
        node2.m_nValue=2;
        node3.m_nValue=3;
        node4.m_nValue=3;
        node5.m_nValue=4;
        node6.m_nValue=4;
        node7.m_nValue=5;
        DeleteDuplicastion(node1);
        ListNode node=node1;
        if(node==null){
            return;
        }
        while(node!=null){
            System.out.print(node.m_nValue+" ");
            node=node.m_nNext;
        }

    }
    public static void DeleteDuplicastion(ListNode pHead){
        if(pHead==null)return;
        ListNode pPreNode=null;
        ListNode pNode=pHead;
        while(pNode!=null){
            ListNode pNext=pNode.m_nNext;
            boolean needDelete=false;
            if(pNext!=null && pNext.m_nValue==pNode.m_nValue){
                needDelete=true;
            }
            if(!needDelete){
                pPreNode=pNode;
                pNode=pNode.m_nNext;
            }else {
                int value=pNode.m_nValue;
                ListNode pToBeDel=pNode;
                while (pToBeDel!=null && pToBeDel.m_nValue==value){
                    pNext=pToBeDel.m_nNext;
                    pToBeDel=null;
                    pToBeDel=pNext;
                }
                if(pPreNode==null){
                    pHead=pNext;
                }else {
                    pPreNode.m_nNext=pNext;
                    pNode=pNext;
                }
            }
        }
    }