剑指offer 第18题

剑指offer面试题18(java版):删除链表的节点

题目一描述

在O(1)时间内删除链表节点.

思路

1.常规思路: 删除一个节点, 让待删节点的前一个节点指向待删节点的下一个节点
2.寻找待删节点的前一个节点的时间复杂度是O(n),不满足O(1)的要求
3.另一种思路: 将待删节点的value改成待删节点的下一个节点的value, 然后将待删节点指向下一个节点的下一个节点.
4.上面这种思路不需要寻找待删节点的上一个节点, 时间复杂度是O(1)
5.链表问题特别要注意的是: 末尾节点; 只有一个节点的链表
6.待删节点为末尾节点时, 只能从头开始找到末尾节点的上一个节点, 将该节点指向null
7.链表只有一个节点时, 直接将头指针指向null

复杂度

时间复杂度: O(1)
空间复杂度: O(1)

public class MST18 {
    public static void main(String[] args) {

    }
    public static class ListNode {
        int val;
        ListNode next = null;
        ListNode(int val) {
            this.val = val;
        }
    }
    public static void deleteNode(ListNode pHead, ListNode pToBeDeleted)
    {
        // 健壮性判断
        if(pHead == null || pToBeDeleted == null)
            throw new RuntimeException("链表为空或未指定待删除节点");
        // 正常执行
        /*
        1. sp:链表只有一个节点, 头指针指向null即可
        2. sp:删除最后一个节点, 找出倒数第二个节点并让该节点指向null
        3. 令待删节点的value等于待删节点下一个节点的value, 并令待删节点指向下一个节点的下一个节点
         */
        //1.
        if(pHead.next == null)
            pHead = null;
        //2.
        ListNode temp = pHead;
        if(pToBeDeleted.next == null){
            while(temp.next != pToBeDeleted)
                temp = temp.next;
            temp.next = null;
        }
        //3.
        temp = pToBeDeleted.next;
        pToBeDeleted.val = temp.val;
        pToBeDeleted.next = temp.next;
    }
}

题目二描述

在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5

第一种方法：

public class Solution {
    public ListNode deleteDuplication(ListNode pHead)
    {
        // input check
        if(pHead == null)
            return null;
        // execute
        ListNode head = new ListNode(0); //head在pHead前面, 如果LinkList全是重复的,则head指向null; 否则指向pHead
        head.next = pHead;
        ListNode pPre = head; // pPre一定比pCurr慢
        ListNode pCurr = pHead;
        
        while(pCurr!=null){
            int val = pCurr.val;
            ListNode pNext = pCurr.next; 
            if(pNext != null && pNext.val == val){
                while(pNext != null && pNext.val == val){
                    pNext = pNext.next;
                }
                pPre.next = pNext;
                pCurr = pNext;
            }
            else{
                pPre.next = pCurr;
                pPre = pCurr;
                pCurr = pCurr.next;
            }
        }
        return head.next;
    }
}

第二种方法 递归

public class Solution {
    public ListNode deleteDuplication(ListNode pHead)
    {
        // 递归版本. 功能: 从当前节点开始,找到下一个非重复节点并返回;  递归终止条件:当前节点是链表末尾null或者当前节点是链表最后一个节点
        // input check
        if(pHead == null)
            return null;
        if(pHead.next == null)
            return pHead;
        // 执行到这里, 链表至少两个节点
        // 判断节点是否重复,需要用到节点的值.   相邻两节点值的关系: 相等, 不相等, 所以用if else就能将这两大类情况考虑完备
        ListNode pCurr = pHead.next;
        if(pCurr.val == pHead.val){
            while(pCurr != null && pCurr.val == pHead.val){
                pCurr = pCurr.next;
            }
            // while循环外, pCurr可能是null, 也可能不是null
            // 继续递归
            // 是null的话,下一次递归返回null,返回的null将会被上一个非重复节点所指向
            // 不是null的话, 下一次继续递归将会继续从当前节点开始寻找下一个非重复节点
            return deleteDuplication(pCurr); // 弄清楚返回给谁!
        }
        else{ // pHead.next.val != pHead.val
            pHead.next = deleteDuplication(pCurr);
            return pHead;
        }
    }
}