《剑指offer》链表专题 (牛客10.23)

难度	题目	知识点
	03. 返回链表的反序 vector	递归，C++ STL reverse()
*	14. 链表中倒数第k个结点	指针操作
	15. 反转链表	头插法，递归
	16. 合并两个有序链表	指针操作
***	25. 复杂链表的复制	深度复制
*	36. 两个链表的第一个公共结点	栈辅助，链表拼接，链表截取
***	55. 链表中环的入口结点	断链法，快慢指针
*	56. 删除链表中重复的结点	指针操作

03. 返回链表的反序 vector

输入一个链表，按链表从尾到头的顺序返回一个ArrayList。

递归或者对正序 vector reverse。

class Solution {
public:
    vector printListFromTailToHead(ListNode* head) {
        vector rst;
        if(head == NULL)return rst;
        rst = printListFromTailToHead(head->next);
        rst.emplace_back(head->val);
        return rst;
    }
};

//----------------------vv---------------------------------
class Solution {
public:
    vector printListFromTailToHead(ListNode* head) {
        vector rst;
         
        ListNode* pNode = head;
        while(pNode!=NULL){
            rst.emplace_back(pNode->val);
            pNode=pNode->next;
        }
         
        reverse(rst.begin(),rst.end());
        return rst;
    }
};

14. 链表中倒数第k个结点+

输入一个链表，输出该链表中倒数第k个结点。

这道题去南大面试还被问了，两个指针的思路不错，但是涉及指针的细节很多，容易写崩。。。

/*
    首先要判断指针是否为空，以及k是否大于0！！
    然后p1移到最后一个为止，不能指到空
*/
class Solution {
public:
    ListNode* FindKthToTail(ListNode* pListHead, unsigned int k) {
        if(pListHead == NULL || k==0)
            return NULL;
         
        ListNode* p1=pListHead;
        ListNode* p2=pListHead;
        
        for(int i=1;inext==NULL){
                return NULL;
            }
            p1=p1->next;
        }
         
        while(p1->next != NULL){
            p1=p1->next;
            p2=p2->next;
        }
         
        return p2;
    }
};

15. 反转链表

用头插法新建了一个链表。当然不新开链表是可以的，似乎正解也是这样。。然后递归也可以但没必要。

16. 合并两个有序链表

输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

/*
A:  考归并操作。
T:  要时刻记得指针所指的结点，不要漏掉！
*/
class Solution {
public:
    ListNode* Merge(ListNode* pHead1, ListNode* pHead2)
    {
        ListNode *newList = new ListNode(0);
        ListNode *p1 = pHead1, *p2 = pHead2, *p3 = newList;
        
        while(p1 && p2){
            if(p1->val <= p2 -> val){
                p3->next = p1;
                p1 = p1->next;
            }else{
                p3->next = p2;
                p2 = p2->next;
            }
            p3 = p3->next;
            p3->next = NULL;
        }
        
        if(p1){
            p3->next = p1;
        }else if(p2){
            p3->next = p2;
        }
        
        return newList->next;
    }
};

25. 复杂链表的复制 ++

题目描述

输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空。

方法 1：map关联新节点旧结点

方法 2：妙啊（滑稽

public class Solution {
    public RandomListNode Clone(RandomListNode pHead)
    {
        if(pHead==null) return null;
        //1、复制每个结点，如复制结点A得到A1，将结点A1插到结点A后面；
        RandomListNode p=pHead,newHead=new RandomListNode(0),q;
        while(p!=null){
            RandomListNode newNode =new RandomListNode(p.label);
            newNode.next=p.next;
            p.next=newNode;
            p=newNode.next;
        }

        //2、重新遍历链表，复制老结点的随机指针给新结点，如A1.random = A.random.next;
        p=pHead;
        while(p!=null){
            if(p.random!=null)
                p.next.random=p.random.next;
            p=p.next.next;
        }

        //3、拆分链表，将链表拆分为原链表和复制后的链表
        p=pHead;
        q=newHead;
        while(p!=null){
            q.next=p.next;
            p.next=q.next.next;

            p=p.next;
            q=q.next;
        }

        return newHead.next;
    }
}

36. 两个链表的第一个公共结点+

从第一个公共结点开始，都为公共结点，

方法 1：借助辅助栈。

我们可以把两个链表的结点依次压入到两个辅助栈中，这样两个链表的尾结点就位于两个栈的栈顶，接下来比较两个栈顶的结点是否相同。如果相同，则把栈顶弹出继续比较下一个，直到找到最后一个相同的结点。此方法也很直观，时间复杂度为O(m+n)，但使用了O(m+n)的空间，相当于用空间换区了时间效率的提升。

方法 2：将两个链表设置成一样长。

具体做法是先求出两个链表各自的长度，然后将长的链表的头砍掉，也就是长的链表先走几步，使得剩余的长度与短链表一样长，这样同时向前遍历便可以得到公共结点。时间复杂度为O(m+n)，不需要额外空间。

方法 3：将两个链表拼接起来。

将两个链表进行拼接，一个链表1在前链表2在后，另一个链表2在前链表1在后，则合成的两个链表一样长，然后同时遍历两个链表，就可以找到公共结点，时间复杂度同样为O(m+n)。

//方法3
class Solution {
public:
    ListNode* FindFirstCommonNode( ListNode *pHead1, ListNode *pHead2) {
        ListNode *p1 = pHead1;
        ListNode *p2 = pHead2;
        while(p1!=p2){
            p1 = (p1==NULL ? pHead2 : p1->next);
            p2 = (p2==NULL ? pHead1 : p2->next);
        }
        return p1;
    }
};

55. 链表中环的入口结点+++

题目描述：

给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。

方法 1：断链法

采用断链法,访问过的节点都断开，最后到达的那个节点一定是循环的入口节点。

public class Solution {
    public ListNode EntryNodeOfLoop(ListNode pHead) {
        if (pHead == null || pHead.next == null) {
            return null;
        }
        ListNode fast = pHead.next;
        ListNode slow = pHead;
        while (fast != null) {
            slow.next = null;
            slow = fast;
            fast = fast.next;
        }
        return slow;
    }
}

方法 2：快慢指针

利用快慢指针，快指针一次走两步，慢指针一次走一步，具体思路如下：
①判断是否有环：若链表中存在环，快慢指针一定会在环上某一点相遇（因为相对速度为1）；
②确定环的起点：
​ 设x为环前面的路程（黑色路程），a为环入口到相遇点的路程（蓝色路程，假设顺时针走）， c为环的长度（蓝色+橙色路程）。则有

• 慢指针走的路程 Sslow = x + m * c + a，
• 快指针走的路程为Sfast = x + n * c + a，
• 且2 Sslow = Sfast

​ 可得 x = c - a，即相遇点后环剩余部分的路程。所以，我们可以让一个指针从链表起点开始走，让一个指针从相遇点开始继续往后走，俩指针会在环的起点相遇。

public class Solution {

    public ListNode EntryNodeOfLoop(ListNode pHead)
    {
        if(pHead==null || pHead.next == null ||pHead.next.next ==null)
            return null;

        // 判环
        ListNode fast= pHead.next.next;
        ListNode slow= pHead.next;

        while (fast!=slow){
            if(fast.next!=null && fast.next.next!=null){
                fast = fast.next.next;
                slow = slow.next;
            } else{
                return null;
            }
        }

        //循环出来的话就是有环，且此时fast==slow，快慢指针在相遇点
        fast=pHead;
        while (fast!=slow){//将在环的起点相遇
            fast=fast.next;
            slow=slow.next;
        }

        return slow;
    }
}

56. 删除链表中重复的结点+

题目描述：

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

很容易写错了。

public class Solution {
    public ListNode deleteDuplication(ListNode pHead)
    {
        ListNode newHead = new ListNode(-10000000);//增加头节点统一操作
        newHead.next=pHead;

        ListNode pre = newHead, cur;

        while(pre!=null && pre.next!=null && pre.next.next!=null){
            if(pre.next.val==pre.next.next.val){//pre指向重复元素的前一个元素
                cur=pre.next;
                while(cur.next!=null&&cur.next.val==pre.next.val){
                    cur=cur.next;
                }
                pre.next=cur.next;
            }
            else{// 放在else里是因为刚删完元素后，不能保证pre指针后面两个元素不等，所以pre要保持不动
                pre = pre.next;
            }
        }

        return newHead.next;
    }
}