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

welcome to my blog

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

务必掌握题目二的进阶代码

题目二的进阶代码

题目二的进阶代码(递归版本)

题目一描述

在O(1)时间内删除链表节点.
给定单向链表的头指针和一个节点指针, 定义一个函数在O(1)时间内删除该节点.链表节点定义如下:

 public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}

思路

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

第四次做; 递归版; 和循环版的处理思路相同, 核心: 1) 脑中要有p1,p2,p3三个指针, pHead相当于p2, cur相当于p3, 没有p1 2)递归函数逻辑, 判断当前节点是否重复(当前条件), 不重复的话, 当前节点指向剩余的处理好的链表(新条件新递归); 重复的话, 找到第一个和当前节点不相等的节点, 返回以该节点开头的处理后的链表(新条件新递归)

public class Solution {
    //递归函数逻辑: 找到第一个不重复的节点(当前条件), 该节点指向剩余的已经处理好的链表(新条件新递归)
    public ListNode deleteDuplication(ListNode pHead)
    {
        //base case
        if(pHead==null || pHead.next==null)
            return pHead;
        ListNode cur = pHead.next;
        if(cur.val!=pHead.val){
            pHead.next = deleteDuplication(cur);
            return pHead;
        }
        //cur.val==pHead.val
        else{
            while(cur!=null && cur.val==pHead.val){
                cur = cur.next;
            }
            //here, cur==null || cur.val!=pHead.val
            return deleteDuplication(cur);
        }
    }
}

第四次做;核心:1)固定最后一个不重复的值, 使用双指针判断该值的下一个值是否重复 2)指针的含义: p1指向最后一个不重复的节点; p2指向p1的下一个节点,p3指向p2的下一个节点, p3用于检测p2是否重复 3)循环结束条件, p1,p2,p3只能往右移动,所以如果p3走到null就不用继续判断了 4)使用指针要随时检查是否越界 5)dummy节点

public class Solution {
    public ListNode deleteDuplication(ListNode pHead)
    {
        if(pHead==null || pHead.next==null)
            return pHead;
        ListNode dummy = new ListNode(0);
        dummy.next = pHead;
        //核心: 指针的含义: p1指向最后一个不重复的节点; p2指向p1的下一个节点,p3指向p2的下一个节点, p3用于检测p2是否重复
        ListNode p1=dummy, p2=pHead, p3=pHead.next;
        //核心:循环结束条件, p1,p2,p3只能往右移动,所以如果p3走到null就不用继续判断
        while(p3!=null){
            //p1的下一个节点p2不重复
            //核心:p3可能会指向null, 要注意检查;  使用指针要随时检查是否越界
            if(p3!=null && p3.val != p2.val){
                //p2成为最后一个不重复的节点
                p1 = p2;
                p2 = p3;
                p3 = p3==null? null : p3.next;
            }
            //p1的下一个节点p2出现重复
            else if(p3!=null){
                while(p3!=null && p3.val == p2.val){
                    p3 = p3.next;
                }
                //here, p3==null || p3.val != p2.val
                p1.next = p3;
                //update
                p2 = p3;
                p3 = p3==null ? null : p3.next;
            }
            //p3==null, 不需要操作了 
        }
        return dummy.next;
    }
}

思路

• 条件判断太多! 试错了好多次才成功, 如何在思考问题时就能将条件组合的很完备? 暂时的理解是: 考虑常规情况, 考虑所有特殊情况

收获

• while条件用什么? 对于链表来说, 可以这样: PCurr != null; 这样while循环就会处理所有的节点
• if中多个条件的不同组合
• 链表问题中, 用到pCurr.next时,大都需要判断pCurr.next是否为null

第三次做, 脑子有点混乱, 但还是一遍过了; 递归函数的逻辑:返回删除重复节点后的链表的头结点; 每个节点的处理逻辑是相同的, 只不过出现重复节点的时候会在一次递归中全部处理; 以pHead开头的链表,如果重复就找第一个值不等于pHead.val的节点, 以此节点为开头调用递归函数并返回; 如果不重复就让pHead.next指向以pHead.next为头结点的链表的第一个不重复节点

public class Solution {
    public ListNode deleteDuplication(ListNode pHead)
    {
        if(pHead==null||pHead.next==null)
            return pHead;
        ListNode right = pHead.next;
        if(right!=null && pHead.val == right.val){
            while(right!=null && right.val==pHead.val)
                right = right.next;
            return deleteDuplication(right);
        }
        else{
            pHead.next = deleteDuplication(right);
            return pHead;
        }
    }
}

第三次做, 还没吃透这道题; 注意left的更新方式: curr.val!=right.val时, 更新left, curr.valright.val时,更新left.next; 注意right的更新方式, 如果curr.valright.val, 那么right自己一直移动到null或者val!=curr.val的节点;

/*
这道题本来是要先处理头结点,再处理非头结点的, 可以创建一个临时节点,指向头结点,
这样,原来的头结点就变成了非头结点, 可以用一套流程处理原来所有的节点
*/
public class Solution {
    public ListNode deleteDuplication(ListNode pHead)
    {
        if(pHead==null)
            return null;
        ListNode tempHead = new ListNode(pHead.val);//初始值有讲究
        tempHead.next = pHead;
        ListNode left=tempHead, curr=pHead, right;
        while(curr!=null){
            //save
            right = curr.next;
            //execute
            if(right!=null && curr.val==right.val){//注意检查null
                while(right!=null && right.val==curr.val)
                    right = right.next;
                left.next = right;
                curr = right;
            }
            else{
                left = curr;
                curr = right;
            }
        }
        return tempHead.next;
    }
}

第二次做, 递归版; 在一次递归中处理多个连续重复节点

/*
一次递归调用中会一次性处理完当前节点连接的相邻重复节点
递归逻辑:在pHead, pHead.next,...,null这段链表中,
    如果pHead是重复的节点,那么返回curr,...,null这段链表中第一个非重复节点; 其中curr是不等于pHead值的最近的节点
    如果pHead不是重复的节点,那么pHead.next指向curr,...,null这段链表中第一个非重复节点; 其中curr是pHead.next
*/
public class Solution {
    public ListNode deleteDuplication(ListNode pHead)
    {
        //base case
        //当前节点是最后一个节点, 一定有当前节点和上一个节点值不相等
        //如果相等的话在上一轮递归中就考虑了本节点
        if(pHead==null || pHead.next==null)
            return pHead;
        //
        ListNode curr = pHead.next;
        if(curr.val == pHead.val){
            curr = curr.next;
            while(curr!=null && curr.val==pHead.val)
                curr = curr.next;
            return deleteDuplication(curr);
        }
        else{
            //pHead.next指向curr....null这段链表中第一个不重复的节点
            pHead.next = deleteDuplication(curr);
            return pHead;
        }
    }
}

第二次做, 核心:创建一个节点指向pHead,这样就能将pHead按照普通节点处理了; 改动了链表指向,使用三个指针, left的更新比较特殊: left.val != curr.val != right.val时才更新left; 此外,curr和right也不一定是挨着的

public class Solution {
    public ListNode deleteDuplication(ListNode pHead)
    {
        if(pHead==null || pHead.next == null)
            return pHead;
        //
        ListNode head = new ListNode(0);
        head.next = pHead;//这样就能用一套流程处理头节点和非头节点了! 这是一种思想
        ListNode left=head, curr=pHead, next;
        int temp;
        while(curr != null){
            next = curr.next;
            temp = curr.val;
            if(next != null && next.val == temp){
                next = next.next;
                while(next!=null && next.val == temp)
                    next = next.next;
                left.next = next; //也能让最后一个节点指向null
                curr = next;
            }
            else{
                left = curr;
                curr = next;
            }
        }
        return head.next;
    }
}

/*
 public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {
    public static ListNode deleteDuplication(ListNode pHead) {
        /*
        初始化pPre指向pHead, pCurr指向pHead.next, 重复标志位duplicated, 初始值false,表示当前没有重复
        sp1:链表只有一个节点, 直接return Head
        sp2:
        1.
        */
        // valid check
        if (pHead == null)
            return null;
        // sp1
        if (pHead.next == null)
            return pHead;
        // normally execution
        ListNode pPre = pHead;
        ListNode pCurr = pHead.next;
        boolean duplicated = false;
        // ensure pHead.val != pHead.next.val
        while (pHead != null) {
            if (pHead.next != null && pHead.val == pHead.next.val) {
                duplicated = true;
                pHead = pHead.next;
            } else if (pHead.next != null && pHead.val != pHead.next.val && duplicated) {
                pHead = pHead.next;
                duplicated = false;
            }
            else if (pHead.next != null && pHead.val != pHead.next.val)
                break;
            else if (pHead.next == null && !duplicated)
                break;
            else if(pHead.next == null )
                pHead = null;

        }

            //
            while (pCurr != null) { // 使用该条件确保while循环能够处理到最后一个节点
                if (pCurr.next == null && duplicated) {
                    pPre.next = null;
                    pCurr = null;
                } else if (pCurr.next == null && !duplicated) {
                    pPre.next = pCurr;
                    pCurr = null;
                }
                // 执行到这里, pCurr.next != null
                else if (pCurr.val == pCurr.next.val) {
                    duplicated = true;
                    pCurr = pCurr.next;
                } else if (pCurr.val != pCurr.next.val && duplicated) {
                    duplicated = false;
                    pCurr = pCurr.next;
                } else if (pCurr.val != pCurr.next.val && !duplicated) {
                    pPre.next = pCurr; // 删除重复节点
                    pPre = pCurr;
                    pCurr = pCurr.next;
                }
            }
        return pHead;
    }
}

题目二的进阶代码

思路

• 指针指向一个节点, 如果要使用本节点的val,那么就得判断本节点是否为null; 如果不适用本节点的val,那么就不用判断本节点是否为null
• 如何解决头节点重复问题? 创建一个节点head, 让head.next=pHead, 这样在执行主体函数时,如果pHead是重复节点,那么head.next会指向第一个不重复的节点或者指向末尾的null. 其实这样做的话,最大的好处是可以用处理普通节点的方法处理头节点, 也就是头节点和非头节点都可以用同一套流程进行处理
• 要不要单独处理链表的末尾null
• 判断重复节点的时候,最好不要判断相邻的节点值是否相同,最好是创建一个新的节点pNext, 向后移动pNext,直到pNext的值不等于pCurr
• pPre一定比pCurr慢, pPre.next一定会指向非重复的pCurr. 所以当pCurr==null时说明链表处理完毕! 仔细理解这句
• 一定要明确什么时候才会改变pPre.next的指向! 当且仅当pPre.val != pCurr.val 同时pCurr.val != pNext.val时

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;
        }
    }
}