春节刷题day2：LeetCode[剑指 Offer 22、06、24、25、52、18]

春节刷题day2：LeetCode

剑指 Offer 22. 链表中倒数第k个节点

剑指 Offer 06. 从尾到头打印链表

剑指 Offer 24. 反转链表

剑指 Offer 25. 合并两个排序的链表

剑指 Offer 52. 两个链表的第一个公共节点

剑指 Offer 18. 删除链表的节点

---

1、剑指 Offer 22. 链表中倒数第k个节点

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* getKthFromEnd(ListNode* head, int k) {
        ListNode* l = head;
        ListNode* r = head;
        int cnt = 1;
        while(cnt != k){ r = r -> next; cnt++; }
        while(r -> next){ r = r -> next; l = l -> next; }
        return l;
    }
};

2、剑指 Offer 06. 从尾到头打印链表

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> reversePrint(ListNode* head) {
        vector<int> ans;
        if(head == NULL) return ans;
        ListNode* p = head -> next;
        head -> next = NULL;
        while(p){
            ListNode* r = p -> next;
            p -> next = head;
            head = p; p = r;
        }
        while(head){
            ans.push_back(head -> val); head = head -> next;
        }
        return ans;
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> reversePrint(ListNode* head) {
        vector<int> ans;
        if(head == NULL) return ans;
        else{
            ListNode* HEAD = new ListNode(1); HEAD -> next = NULL;
            ListNode* p = head;
            while(p){
                ListNode* r = p -> next;
                p -> next = HEAD -> next;
                HEAD -> next = p;
                p = r;
            }
            HEAD = HEAD -> next;
            while(HEAD){
                ans.push_back(HEAD -> val); HEAD = HEAD -> next;
            }
            return ans;
        }
    }
};

3、剑指 Offer 24. 反转链表

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head == NULL) return head;
        ListNode* p = head -> next;
        head -> next = NULL;
        while(p){
            ListNode* r = p -> next;
            p -> next = head;
            head = p; p = r;
        }
        return head;
    }
};

4、剑指 Offer 25. 合并两个排序的链表

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if(l1 == NULL && l2 == NULL) return NULL;
        else if(l1 == NULL && l2 != NULL) return l2;
        else if(l1 != NULL && l2 == NULL) return l1;
        ListNode* head = new ListNode(1);
        ListNode* p = head;
        ListNode* p1 = l1;
        ListNode* p2 = l2;
        while(p1 && p2){
            ListNode* r1 = p1 -> next;
            ListNode* r2 = p2 -> next;
            if(p1 -> val <= p2 -> val){
                p -> next = p1; p1 = r1;
            }else{
                p -> next = p2; p2 = r2;
            }
            p = p -> next;
        }
        if(p1) p -> next = p1;
        else p -> next = p2;
        return head -> next;
    }
};

5、剑指 Offer 52. 两个链表的第一个公共节点

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        unordered_map<ListNode*, int> pa;
        ListNode* ans = NULL;
        while(headA){
            pa[headA]++;
            headA = headA -> next;
        }
        while(headB){
            if(pa[headB] == 1){
                ans = headB; break;
            }
            headB = headB -> next;
        }
        return ans;
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* p1 = headA;
        ListNode* p2 = headB;
        while(p1 != p2){
            p1 = p1 == NULL ? headB : p1 -> next;
            p2 = p2 == NULL ? headA : p2 -> next;
        }
        return p1;
    }
};

6、剑指 Offer 18. 删除链表的节点

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* deleteNode(ListNode* head, int val) {
        if(head == NULL) return head;
        if(head -> val == val) return head -> next;
        ListNode* pre = head;
        ListNode* p = pre -> next;
        while(p){
            ListNode* r = p -> next;
            if(p -> val == val){
                 pre -> next = r; p = r;
            }else{
                pre = pre -> next; p = p -> next;
            }
        }
        return head;
    }
};

---

2021/2/7完结（刷了下LeetCode上有关链表的题目，希望可以保持下手感，但是都是Easy水平的题目，再接再厉，向着Medium和Hard进发）。