剑指offer之链表

1.从尾到头打印链表

题目：https://leetcode-cn.com/problems/cong-wei-dao-tou-da-yin-lian-biao-lcof

思路：栈的特点是后进先出，即最后压入栈的元素最先弹出。考虑到栈的这一特点，使用栈将链表元素顺序倒置。从链表的头节点开始，依次将每个节点压入栈内，然后依次弹出栈内的元素并存储到数组中。

class Solution {
public:
    vector<int> reversePrint(ListNode* head) {
        vector<int> res;
        stack<int> tmp;
        ListNode* phead=head;
        while(phead != nullptr){
            tmp.push(phead->val);
            phead=phead->next;
        }
        while(!tmp.empty()){
            int num=tmp.top();
            res.push_back(num);
            tmp.pop();
        }
        return res;
    }
};


class Solution {
public:
    vector<int> reversePrint(ListNode* head) {
        vector<int> res;
        if(head==nullptr)  return res;
        res=reversePrint(head->next);
        res.push_back(head->val);
        return res;
    }
};

2.删除链表节点

题目：https://leetcode-cn.com/problems/shan-chu-lian-biao-de-jie-dian-lcof

思路：直接遍历即可

class Solution {
public:
    ListNode* deleteNode(ListNode* head, int val) {
        if(head==nullptr)   return nullptr;
        if(head->val==val)  return head->next;
        ListNode* cur=head;
        while(cur->next->val != val  && cur->next!=nullptr){
            cur=cur->next;
        }
        if(cur->next!=nullptr)  cur->next=cur->next->next;
        return head; 
    }
};

3.链表中倒数第K个节点

题目：https://leetcode-cn.com/problems/lian-biao-zhong-dao-shu-di-kge-jie-dian-lcof

思路：快慢指针

• 初始化： 前指针 former 、后指针 latter ，双指针都指向头节点 head​ 。
• 构建双指针距离： 前指针 former 先向前走 k 步（结束后，双指针 former 和 latter 间相距 k 步）。
• 双指针共同移动： 循环中，双指针 former 和 latter 每轮都向前走一步，直至 former 走过链表 尾节点 时跳出（跳出后， latter 与尾节点距离为 k-1，即 latter 指向倒数第 k 个节点）。
• 返回值： 返回 latter 即可。

class Solution {
public:
    ListNode* getKthFromEnd(ListNode* head, int k) {
        ListNode* former=head;
        ListNode* latter=head;
        for(int i=0; i<k;i++){
            former=former->next;
        }
        while(former!=nullptr){
            former=former->next;
            latter=latter->next;
        }
        return latter;
    }
};

4.反转链表

题目：https://leetcode-cn.com/problems/fan-zhuan-lian-biao-lcof

思路：法一：双指针     法二：递归

//双指针
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* pre=nullptr, *cur=head;
        while(cur != nullptr){
            ListNode* tmp=cur->next;
            cur->next=pre;
            pre=cur;
            cur=tmp;
        }
        return pre;
    }
};

//递归
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head == nullptr || head->next==nullptr)  return head;
        ListNode* cur=head;
        cur=reverseList(head->next);
        head->next->next=head;
        head->next=nullptr;
        return cur;
    }
};

5.复杂链表的复制

题目：https://leetcode-cn.com/problems/fu-za-lian-biao-de-fu-zhi-lcof

思路：

只介绍法一：

• 遍历原来的链表并拷贝每一个节点，将拷贝节点放在原来节点的旁边，创造出一个旧节点和新节点交错的链表。
• 迭代这个新旧节点交错的链表，并用旧节点的 random 指针去更新对应新节点的 random 指针
• 现在 random 指针已经被赋值给正确的节点， next 指针也需要被正确赋值，以便将新的节点正确链接同时将旧节点重新正确链接。

class Solution {
public:
    Node* copyRandomList(Node* head) {
        if(head==nullptr)  return nullptr;
        Node* cur=head;
        //创建相邻节点
        while(cur!=nullptr){
            Node* cloned_cur=new Node(cur->val);
            cloned_cur->next=cur->next;  //克隆节点的下一位是源节点的下一位
            cur->next=cloned_cur;        //源节点的下一位变成了新节点
            cur=cloned_cur->next;  
        }

        cur=head;
        //复制random指针
        while(cur!=nullptr){
            if(cur->random != nullptr){
                cur->next->random=cur->random->next;//克隆节点的随机指针为原随机指针下一位
            }
            else cur->next->random=nullptr;
            cur=cur->next->next;                   //前进"2"步
        }

        //拆分链表
        Node* old_list_head=head;
        Node* new_list_head=head->next;
        Node* res=head->next;
        while(old_list_head!=nullptr){
            //原节点的下一位是原节点的下一位的下一位
            old_list_head->next=old_list_head->next->next; 
            //新节点的下一位是新节点下一位的下一位
            new_list_head->next=(new_list_head->next==nullptr)?nullptr:new_list_head->next->next;
            old_list_head=old_list_head->next;//前进
            new_list_head=new_list_head->next;//前进
        }
        return res;
    }
};

/*哈希
class Solution {
public:
    Node* copyRandomList(Node* head) {
        if(head==NULL)  return head;
        unordered_map<Node*,Node*> mp;
        Node *t=head;
        while(t!=NULL){                         //1. 复制节点的值
            mp[t]=new Node(t->val);
            t=t->next;
        }
        t=head;
        while(t!=NULL){                         //2. 复制节点指向
            if(t->next){
                mp[t]->next=mp[t->next];        //新节点next的指向=旧节点next的指向
            }
            if(t->random){
                mp[t]->random=mp[t->random];    //新节点random的指向=旧节点random的指向
            }
            t=t->next;
        }
        return mp[head];                        //3. 返回复制链表
    }
};
*/

6.两个链表的第一个公共节点

题目：https://leetcode-cn.com/problems/liang-ge-lian-biao-de-di-yi-ge-gong-gong-jie-dian-lcof

思路：

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* node1=headA,*node2=headB;
        while(node1!=node2){
            node1=(node1==nullptr)?headB:node1->next;
            node2=(node2==nullptr)?headA:node2->next;
        }
        return node1;
    }
};