【LeetCode刷题日记】链表类题目常见题型_leetcode链表题型分类(1)

最新推荐文章于 2024-10-15 10:20:47 发布
最新推荐文章于 2024-10-15 10:20:47 发布
阅读量229 收藏 4
点赞数 4
分类专栏： 程序员 文章标签： go 学习 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BlackCATdog/article/details/138775533
版权

img
img
img

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Go语言开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取

21. 合并两个有序链表

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ux7cp8bi-1631410080337)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905170645075.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CnO95sQb-1631410080339)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905170953580.png)]

class Solution {
public:
    ListNode\* mergeTwoLists(ListNode\* l1, ListNode\* l2) {
        if (l1 == nullptr) {
            return l2;
        } else if (l2 == nullptr) {
            return l1;
        } else if (l1->val < l2->val) {
            l1->next = mergeTwoLists(l1->next, l2);
            return l1;
        } else {
            l2->next = mergeTwoLists(l1, l2->next);
            return l2;
        }
    }
};

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2M02bxdB-1631410080340)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905171310198.png)]

class Solution {
public:
    ListNode\* mergeTwoLists(ListNode\* l1, ListNode\* l2) {
        ListNode\* preHead = new ListNode(-1);

        ListNode\* prev = preHead;
        while (l1 != nullptr && l2 != nullptr) {
            if (l1->val < l2->val) {
                prev->next = l1;
                l1 = l1->next;
            } else {
                prev->next = l2;
                l2 = l2->next;
            }
            prev = prev->next;
        }

        // 合并后 l1 和 l2 最多只有一个还未被合并完，我们直接将链表末尾指向未合并完的链表即可
        prev->next = l1 == nullptr ? l2 : l1;

        return preHead->next;
    }
};

19. 删除链表的倒数第 N 个结点

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sfyEpXNQ-1631410080341)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905171900612.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xqhWsQGB-1631410080341)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905172040030.png)]

int getLength(struct ListNode\* head) {
    int length = 0;
    while (head) {
        ++length;
        head = head->next;
    }
    return length;
}

struct ListNode\* removeNthFromEnd(struct ListNode\* head, int n) {
    struct ListNode\* dummy = malloc(sizeof(struct ListNode));
    dummy->val = 0, dummy->next = head;
    int length = getLength(head);
    struct ListNode\* cur = dummy;
    for (int i = 1; i < length - n + 1; ++i) {
        cur = cur->next;
    }
    cur->next = cur->next->next;
    struct ListNode\* ans = dummy->next;
    free(dummy);
    return ans;
}

-----------------------------------------------------------------
/\*\*
 \* Definition for singly-linked list.
 \* struct ListNode {
 \* int val;
 \* ListNode \*next;
 \* ListNode() : val(0), next(nullptr) {}
 \* ListNode(int x) : val(x), next(nullptr) {}
 \* ListNode(int x, ListNode \*next) : val(x), next(next) {}
 \* };
 \*/
class Solution {
public:
    int getLength(ListNode\* head) {
        int length = 0;
        while (head) {
            ++length;
            head = head->next;
        }
        return length;
    }

    ListNode\* removeNthFromEnd(ListNode\* head, int n) {
        ListNode\* dummy = new ListNode(0, head);
        int length = getLength(head);
        ListNode\* cur = dummy;
        for (int i = 1; i < length - n + 1; ++i) {
            cur = cur->next;
        }
        cur->next = cur->next->next;
        ListNode\* ans = dummy->next;
        delete dummy;
        return ans;
    }
};

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4ddtjT5a-1631410080342)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905172302647.png)]

struct Stack {
    struct ListNode\* val;
    struct Stack\* next;
};

struct ListNode\* removeNthFromEnd(struct ListNode\* head, int n) {
    struct ListNode\* dummy = malloc(sizeof(struct ListNode));
    dummy->val = 0, dummy->next = head;
    struct Stack\* stk = NULL;
    struct ListNode\* cur = dummy;
    while (cur) {
        struct Stack\* tmp = malloc(sizeof(struct Stack));
        tmp->val = cur, tmp->next = stk;
        stk = tmp;
        cur = cur->next;
    }
    for (int i = 0; i < n; ++i) {
        struct Stack\* tmp = stk->next;
        free(stk);
        stk = tmp;
    }
    struct ListNode\* prev = stk->val;
    prev->next = prev->next->next;
    struct ListNode\* ans = dummy->next;
    free(dummy);
    return ans;
}

---------------------------------------------------------------------
/\*\*
 \* Definition for singly-linked list.
 \* struct ListNode {
 \* int val;
 \* ListNode \*next;
 \* ListNode() : val(0), next(nullptr) {}
 \* ListNode(int x) : val(x), next(nullptr) {}
 \* ListNode(int x, ListNode \*next) : val(x), next(next) {}
 \* };
 \*/
class Solution {
public:
    ListNode\* removeNthFromEnd(ListNode\* head, int n) {
        ListNode\* dummy = new ListNode(0, head);
        stack<ListNode\*> stk;
        ListNode\* cur = dummy;
        while (cur) {
            stk.push(cur);
            cur = cur->next;
        }
        for (int i = 0; i < n; ++i) {
            stk.pop();
        }
        ListNode\* prev = stk.top();
        prev->next = prev->next->next;
        ListNode\* ans = dummy->next;
        delete dummy;
        return ans;
    }
};

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1KHK0Drz-1631410080343)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905172356807.png)]

p3

struct ListNode\* removeNthFromEnd(struct ListNode\* head, int n) {
    struct ListNode\* dummy = malloc(sizeof(struct ListNode));
    dummy->val = 0, dummy->next = head;
    struct ListNode\* first = head;
    struct ListNode\* second = dummy;
    for (int i = 0; i < n; ++i) {
        first = first->next;
    }
    while (first) {
        first = first->next;
        second = second->next;
    }
    second->next = second->next->next;
    struct ListNode\* ans = dummy->next;
    free(dummy);
    return ans;
}

---------------------------------------------------------------
/\*\*
 \* Definition for singly-linked list.
 \* struct ListNode {
 \* int val;
 \* ListNode \*next;
 \* ListNode() : val(0), next(nullptr) {}
 \* ListNode(int x) : val(x), next(nullptr) {}
 \* ListNode(int x, ListNode \*next) : val(x), next(next) {}
 \* };
 \*/
class Solution {
public:
    ListNode\* removeNthFromEnd(ListNode\* head, int n) {
        ListNode\* dummy = new ListNode(0, head);
        ListNode\* first = head;
        ListNode\* second = dummy;
        for (int i = 0; i < n; ++i) {
            first = first->next;
        }
        while (first) {
            first = first->next;
            second = second->next;
        }
        second->next = second->next->next;
        ListNode\* ans = dummy->next;
        delete dummy;
        return ans;
    }
};

2. 两数相加

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MDVCfGZa-1631410080344)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905172714235.png)]

struct ListNode\* addTwoNumbers(struct ListNode\* l1, struct ListNode\* l2) {
    struct ListNode \*head = NULL, \*tail = NULL;
    int carry = 0;
    while (l1 || l2) {
        int n1 = l1 ? l1->val : 0;
        int n2 = l2 ? l2->val : 0;
        int sum = n1 + n2 + carry;
        if (!head) {
            head = tail = malloc(sizeof(struct ListNode));
            tail->val = sum % 10;
            tail->next = NULL;
        } else {
            tail->next = malloc(sizeof(struct ListNode));
            tail->next->val = sum % 10;
            tail = tail->next;
            tail->next = NULL;
        }
        carry = sum / 10;
        if (l1) {
            l1 = l1->next;
        }
        if (l2) {
            l2 = l2->next;
        }
    }
    if (carry > 0) {
        tail->next = malloc(sizeof(struct ListNode));
        tail->next->val = carry;
        tail->next->next = NULL;
    }
    return head;
}

----------------------------------------------------------------------
/\*\*
 \* Definition for singly-linked list.
 \* struct ListNode {
 \* int val;
 \* ListNode \*next;
 \* ListNode() : val(0), next(nullptr) {}
 \* ListNode(int x) : val(x), next(nullptr) {}
 \* ListNode(int x, ListNode \*next) : val(x), next(next) {}
 \* };
 \*/
class Solution {
public:
    ListNode\* addTwoNumbers(ListNode\* l1, ListNode\* l2) {
        ListNode \*head = nullptr, \*tail = nullptr;
        int carry = 0;
        while (l1 || l2) {
            int n1 = l1 ? l1->val: 0;
            int n2 = l2 ? l2->val: 0;
            int sum = n1 + n2 + carry;
            if (!head) {
                head = tail = new ListNode(sum % 10);
            } else {
                tail->next = new ListNode(sum % 10);
                tail = tail->next;
            }
            carry = sum / 10;
            if (l1) {
                l1 = l1->next;
            }
            if (l2) {
                l2 = l2->next;
            }
        }
        if (carry > 0) {
            tail->next = new ListNode(carry);
        }
        return head;
    }
};

24. 两两交换链表中的节点

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-clARU6jS-1631410080344)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905200722159.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ckZRTkPl-1631410080345)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905200812085.png)]

struct ListNode\* swapPairs(struct ListNode\* head) {
    if (head == NULL || head->next == NULL) {
        return head;
    }
    struct ListNode\* newHead = head->next;
    head->next = swapPairs(newHead->next);
    newHead->next = head;
    return newHead;
}

-----------------------------------------------------------------
class Solution {
public:
    ListNode\* swapPairs(ListNode\* head) {
        if (head == nullptr || head->next == nullptr) {
            return head;
        }
        ListNode\* newHead = head->next;
        head->next = swapPairs(newHead->next);
        newHead->next = head;
        return newHead;
    }
};

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0ahmc7Tm-1631410080345)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905201103933.png)]

struct ListNode\* swapPairs(struct ListNode\* head) {
    struct ListNode dummyHead;
    dummyHead.next = head;
    struct ListNode\* temp = &dummyHead;
    while (temp->next != NULL && temp->next->next != NULL) {
        struct ListNode\* node1 = temp->next;
        struct ListNode\* node2 = temp->next->next;
        temp->next = node2;
        node1->next = node2->next;
        node2->next = node1;
        temp = node1;
    }
    return dummyHead.next;
}

class Solution {
public:
    ListNode\* swapPairs(ListNode\* head) {
        ListNode\* dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode\* temp = dummyHead;
        while (temp->next != nullptr && temp->next->next != nullptr) {
            ListNode\* node1 = temp->next;
            ListNode\* node2 = temp->next->next;
            temp->next = node2;
            node1->next = node2->next;
            node2->next = node1;
            temp = node1;
        }
        return dummyHead->next;
    }
};

206. 反转链表

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mTv5SyrN-1631410080346)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905201236408.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rvlqsjR9-1631410080346)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905201720326.png)]

struct ListNode\* reverseList(struct ListNode\* head) {
    struct ListNode\* prev = NULL;
    struct ListNode\* curr = head;
    while (curr) {
        struct ListNode\* next = curr->next;
        curr->next = prev;
        prev = curr;
        curr = next;
    }
    return prev;
}

------------------------------------------------------
class Solution {
public:
    ListNode\* reverseList(ListNode\* head) {
        ListNode\* prev = nullptr;
        ListNode\* curr = head;
        while (curr) {
            ListNode\* next = curr->next;
            curr->next = prev;
            prev = curr;
            curr = next;
        }
        return prev;
    }
};

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-w8vpEfaa-1631410080347)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905201850306.png)]

struct ListNode\* reverseList(struct ListNode\* head) {
    if (head == NULL || head->next == NULL) {
        return head;
    }
    struct ListNode\* newHead = reverseList(head->next);
    head->next->next = head;
    head->next = NULL;
    return newHead;
}

-------------------------------------------------------------------------
class Solution {
public:
    ListNode\* reverseList(ListNode\* head) {
        if (!head || !head->next) {
            return head;
        }
        ListNode\* newHead = reverseList(head->next);
        head->next->next = head;
        head->next = nullptr;
        return newHead;
    }
};

141. 环形链表

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1jKSUI1k-1631410080347)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905203203031.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-A28wIaka-1631410080347)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905203423441.png)]

struct hashTable {
    struct ListNode\* key;
    UT_hash_handle hh;
};

struct hashTable\* hashtable;

struct hashTable\* find(struct ListNode\* ikey) {
    struct hashTable\* tmp;
    HASH\_FIND\_PTR(hashtable, &ikey, tmp);
    return tmp;
}

void insert(struct ListNode\* ikey) {
    struct hashTable\* tmp = malloc(sizeof(struct hashTable));
    tmp->key = ikey;
    HASH\_ADD\_PTR(hashtable, key, tmp);
}

bool hasCycle(struct ListNode\* head) {
    hashtable = NULL;
    while (head != NULL) {
        if (find(head) != NULL) {
            return true;
        }
        insert(head);
        head = head->next;
    }
    return false;
}

---------------------------------------------------------------
/\*\*
 \* Definition for singly-linked list.
 \* struct ListNode {
 \* int val;
 \* ListNode \*next;
 \* ListNode(int x) : val(x), next(NULL) {}
 \* };
 \*/
class Solution {
public:
    bool hasCycle(ListNode \*head) {
        unordered_set<ListNode\*> seen;
        while (head != nullptr) {
            if (seen.count(head)) {
                return true;
            }
            seen.insert(head);
            head = head->next;
        }
        return false;
    }
};

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RW6Db3Jn-1631410080348)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905203518134.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cwgke1vk-1631410080348)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905203615964.png)]

bool hasCycle(struct ListNode\* head) {
    if (head == NULL || head->next == NULL) {
        return false;
    }
    struct ListNode\* slow = head;
    struct ListNode\* fast = head->next;
    while (slow != fast) {
        if (fast == NULL || fast->next == NULL) {
            return false;
        }
        slow = slow->next;
        fast = fast->next->next;
    }
    return true;
}

--------------------------------------------------------------------------
class Solution {
public:
    bool hasCycle(ListNode\* head) {
        if (head == nullptr || head->next == nullptr) {
            return false;
        }
        ListNode\* slow = head;
        ListNode\* fast = head->next;
        while (slow != fast) {
            if (fast == nullptr || fast->next == nullptr) {
                return false;
            }
            slow = slow->next;
            fast = fast->next->next;
        }
        return true;
    }
};

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GO2cHsqJ-1631410080349)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905203757623.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vzqVUaW3-1631410080349)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905203823175.png)]

/\*\*
 \* 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) {
        int n = 0;
        ListNode\* node = nullptr;

        for (node = head; node; node = node->next) {
            n++;
        }
        for (node = head; n > k; n--) {
            node = node->next;
        }
      
        return node;
    }
};

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OKcNKbgb-1631410080350)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905203919520.png)]

/\*\*
 \* 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\* fast = head;
        ListNode\* slow = head;

        while (fast && k > 0) {
            fast = fast->next;
            k--;
        }
        while (fast) {
            fast = fast->next;
            slow = slow->next;
        }

        return slow;
    }
};

25. K 个一组翻转链表

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hOy2NZ6V-1631410080350)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905204059546.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-V7LiIt70-1631410080350)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905204119590.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Zk9UL32c-1631410080351)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905204246343.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DIcgj47J-1631410080351)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905204303965.png)]

/\*\*
 \* Definition for singly-linked list.
 \* struct ListNode {
 \* int val;
 \* ListNode \*next;
 \* ListNode() : val(0), next(nullptr) {}
 \* ListNode(int x) : val(x), next(nullptr) {}
 \* ListNode(int x, ListNode \*next) : val(x), next(next) {}
 \* };
 \*/
class Solution {
public:
    // 翻转一个子链表，并且返回新的头与尾
    pair<ListNode\*, ListNode\*> myReverse(ListNode\* head, ListNode\* tail) {
        ListNode\* prev = tail->next;
        ListNode\* p = head;
        while (prev != tail) {
            ListNode\* nex = p->next;
            p->next = prev;
            prev = p;
            p = nex;
        }
        return {tail, head};
    }

    ListNode\* reverseKGroup(ListNode\* head, int k) {
        ListNode\* hair = new ListNode(0);
        hair->next = head;
        ListNode\* pre = hair;

        while (head) {
            ListNode\* tail = pre;
            // 查看剩余部分长度是否大于等于 k
            for (int i = 0; i < k; ++i) {
                tail = tail->next;
                if (!tail) {
                    return hair->next;
                }
            }
            ListNode\* nex = tail->next;
            // 这里是 C++17 的写法，也可以写成
            // pair<ListNode\*, ListNode\*> result = myReverse(head, tail);
            // head = result.first;
            // tail = result.second;
            tie(head, tail) = myReverse(head, tail);
            // 把子链表重新接回原链表
            pre->next = head;
            tail->next = nex;
            pre = tail;
            head = tail->next;
        }

        return hair->next;
    }
};

23. 合并K个升序链表

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lLFJHMBH-1631410080352)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905204424400.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PZ4tUpPv-1631410080352)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905204721839.png)]

ListNode\* mergeTwoLists(ListNode \*a, ListNode \*b) {
    if ((!a) || (!b)) return a ? a : b;
    ListNode head, \*tail = &head, \*aPtr = a, \*bPtr = b;
    while (aPtr && bPtr) {
        if (aPtr->val < bPtr->val) {
            tail->next = aPtr; aPtr = aPtr->next;
        } else {
            tail->next = bPtr; bPtr = bPtr->next;
        }
        tail = tail->next;
    }
    tail->next = (aPtr ? aPtr : bPtr);
    return head.next;
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-a7u1ODtd-1631410080352)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905204816853.png)]

/\*\*
 \* Definition for singly-linked list.
 \* struct ListNode {
 \* int val;
 \* ListNode \*next;
 \* ListNode() : val(0), next(nullptr) {}
 \* ListNode(int x) : val(x), next(nullptr) {}
 \* ListNode(int x, ListNode \*next) : val(x), next(next) {}
 \* };
 \*/
class Solution {
public:
    ListNode\* mergeTwoLists(ListNode \*a, ListNode \*b) {
        if ((!a) || (!b)) return a ? a : b;
        ListNode head, \*tail = &head, \*aPtr = a, \*bPtr = b;
        while (aPtr && bPtr) {
            if (aPtr->val < bPtr->val) {
                tail->next = aPtr; aPtr = aPtr->next;
            } else {
                tail->next = bPtr; bPtr = bPtr->next;
            }
            tail = tail->next;
        }
        tail->next = (aPtr ? aPtr : bPtr);
        return head.next;
    }

    ListNode\* mergeKLists(vector<ListNode\*>& lists) {
        ListNode \*ans = nullptr;
        for (size_t i = 0; i < lists.size(); ++i) {
            ans = mergeTwoLists(ans, lists[i]);
        }
        return ans;
    }
};

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Fh055srO-1631410080353)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905204858264.png)]

class Solution {
public:
    ListNode\* mergeTwoLists(ListNode \*a, ListNode \*b) {
        if ((!a) || (!b)) return a ? a : b;
        ListNode head, \*tail = &head, \*aPtr = a, \*bPtr = b;
        while (aPtr && bPtr) {
            if (aPtr->val < bPtr->val) {
                tail->next = aPtr; aPtr = aPtr->next;
            } else {
                tail->next = bPtr; bPtr = bPtr->next;
            }
            tail = tail->next;
        }
        tail->next = (aPtr ? aPtr : bPtr);
        return head.next;
    }

    ListNode\* merge(vector <ListNode\*> &lists, int l, int r) {
        if (l == r) return lists[l];
        if (l > r) return nullptr;
        int mid = (l + r) >> 1;
        return mergeTwoLists(merge(lists, l, mid), merge(lists, mid + 1, r));
    }

    ListNode\* mergeKLists(vector<ListNode\*>& lists) {
        return merge(lists, 0, lists.size() - 1);
    }
};

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uH7WtZxs-1631410080353)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905205010709.png)]

class Solution {
public:
    struct Status {
        int val;
        ListNode \*ptr;
        bool operator < (const Status &rhs) const {
            return val > rhs.val;
        }
    };

    priority_queue <Status> q;

    ListNode\* mergeKLists(vector<ListNode\*>& lists) {
        for (auto node: lists) {
            if (node) q.push({node->val, node});
        }
        ListNode head, \*tail = &head;
        while (!q.empty()) {
            auto f = q.top(); q.pop();
            tail->next = f.ptr; 
            tail = tail->next;
            if (f.ptr->next) q.push({f.ptr->next->val, f.ptr->next});
        }
        return head.next;
    }
};

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Hd9K4VbA-1631410080353)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905205117053.png)]

1.回溯法
/\*\*
 \* Definition for singly-linked list.
 \* struct ListNode {
 \* int val;
 \* ListNode \*next;
 \* ListNode(int x) : val(x), next(NULL) {}
 \* };
 \*/
class Solution {
public:
    void method(vector<int>& res,ListNode\* head){
        if(head==NULL) return;
        method(res,head->next);
        res.push\_back(head->val);
    }
    vector<int> reversePrint(ListNode\* head) {
        vector<int> res;
        method(res,head);
        return res;
    }
};
2.用栈
/\*\*
 \* 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) {
        stack<int> s;
        vector<int> res;
        ListNode\* pre=head;
        while(pre){
            s.push(pre->val);
            pre=pre->next;
        }
        while(!s.empty()){
            res.push\_back(s.top());
            s.pop();
        }
        return res;
    }
};
3.利用vector的insert特性
/\*\*
 \* 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> res;
        ListNode\* pre=head;
        while(pre){
            res.insert(res.begin(),pre->val);
            pre=pre->next;
        }
        return res;
    }
};

92. 反转链表 II

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wn9vVvCa-1631410080354)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905210440394.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ut1kK6BS-1631410080354)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905211255527.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cnMUp0kG-1631410080354)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905211313238.png)]

void reverseLinkedList(struct ListNode \*head) {
    // 也可以使用递归反转一个链表
    struct ListNode \*pre = NULL;
    struct ListNode \*cur = head;

    while (cur != NULL) {
        struct ListNode \*next = cur->next;
        cur->next = pre;
        pre = cur;
        cur = next;
    }
}

struct ListNode \*reverseBetween(struct ListNode \*head, int left, int right) {
    // 因为头节点有可能发生变化，使用虚拟头节点可以避免复杂的分类讨论
    struct ListNode \*dummyNode = malloc(sizeof(struct ListNode));
    dummyNode->val = -1;
    dummyNode->next = head;

    struct ListNode \*pre = dummyNode;
    // 第 1 步：从虚拟头节点走 left - 1 步，来到 left 节点的前一个节点
    // 建议写在 for 循环里，语义清晰
    for (int i = 0; i < left - 1; i++) {
        pre = pre->next;
    }

    // 第 2 步：从 pre 再走 right - left + 1 步，来到 right 节点
    struct ListNode \*rightNode = pre;
    for (int i = 0; i < right - left + 1; i++) {
        rightNode = rightNode->next;
    }

    // 第 3 步：切断出一个子链表（截取链表）
    struct ListNode \*leftNode = pre->next;
    struct ListNode \*curr = rightNode->next;

    // 注意：切断链接
    pre->next = NULL;
    rightNode->next = NULL;

    // 第 4 步：同第 206 题，反转链表的子区间
    reverseLinkedList(leftNode);

    // 第 5 步：接回到原来的链表中
    pre->next = rightNode;
    leftNode->next = curr;
    return dummyNode->next;
}

--------------------------------------------------------

/\*\*
 \* Definition for singly-linked list.
 \* struct ListNode {
 \* int val;
 \* ListNode \*next;
 \* ListNode() : val(0), next(nullptr) {}
 \* ListNode(int x) : val(x), next(nullptr) {}
 \* ListNode(int x, ListNode \*next) : val(x), next(next) {}
 \* };
 \*/
class Solution {
private:
    void reverseLinkedList(ListNode \*head) {
        // 也可以使用递归反转一个链表
        ListNode \*pre = nullptr;
        ListNode \*cur = head;

        while (cur != nullptr) {
            ListNode \*next = cur->next;
            cur->next = pre;
            pre = cur;
            cur = next;
        }
    }

public:
    ListNode \*reverseBetween(ListNode \*head, int left, int right) {
        // 因为头节点有可能发生变化，使用虚拟头节点可以避免复杂的分类讨论
        ListNode \*dummyNode = new ListNode(-1);
        dummyNode->next = head;

        ListNode \*pre = dummyNode;
        // 第 1 步：从虚拟头节点走 left - 1 步，来到 left 节点的前一个节点
        // 建议写在 for 循环里，语义清晰
        for (int i = 0; i < left - 1; i++) {
            pre = pre->next;
        }

        // 第 2 步：从 pre 再走 right - left + 1 步，来到 right 节点
        ListNode \*rightNode = pre;
        for (int i = 0; i < right - left + 1; i++) {
            rightNode = rightNode->next;
        }

        // 第 3 步：切断出一个子链表（截取链表）
        ListNode \*leftNode = pre->next;
        ListNode \*curr = rightNode->next;

        // 注意：切断链接
        pre->next = nullptr;
        rightNode->next = nullptr;

        // 第 4 步：同第 206 题，反转链表的子区间
        reverseLinkedList(leftNode);

        // 第 5 步：接回到原来的链表中
        pre->next = rightNode;
        leftNode->next = curr;
        return dummyNode->next;
    }
};

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WEaxJrfW-1631410080355)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905211444495.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SDaq757O-1631410080355)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905211508445.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3arbBwKD-1631410080356)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905211530179.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UNtAApBS-1631410080356)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905211545955.png)]

struct ListNode \*reverseBetween(struct ListNode \*head, int left, int right) {
    // 因为头节点有可能发生变化，使用虚拟头节点可以避免复杂的分类讨论
    struct ListNode \*dummyNode = malloc(sizeof(struct ListNode));
    dummyNode->val = -1;
    dummyNode->next = head;

    struct ListNode \*pre = dummyNode;
    for (int i = 0; i < left - 1; i++) {
        pre = pre->next;
    }
    struct ListNode \*cur = pre->next;
    struct ListNode \*next;
    for (int i = 0; i < right - left; i++) {
        next = cur->next;
        cur->next = next->next;
        next->next = pre->next;
        pre->next = next;
    }
    return dummyNode->next;
}

class Solution {
public:
    ListNode \*reverseBetween(ListNode \*head, int left, int right) {
        // 设置 dummyNode 是这一类问题的一般做法
        ListNode \*dummyNode = new ListNode(-1);
        dummyNode->next = head;
        ListNode \*pre = dummyNode;
        for (int i = 0; i < left - 1; i++) {
            pre = pre->next;
        }
        ListNode \*cur = pre->next;
        ListNode \*next;
        for (int i = 0; i < right - left; i++) {
            next = cur->next;
            cur->next = next->next;
            next->next = pre->next;
            pre->next = next;
        }
        return dummyNode->next;
    }
};

61. 旋转链表

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1MDJiQzg-1631410080357)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905211820557.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fZJHOkWS-1631410080357)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905212013766.png)]

struct ListNode\* rotateRight(struct ListNode\* head, int k) {
    if (k == 0 || head == NULL || head->next == NULL) {
        return head;
    }
    int n = 1;
    struct ListNode\* iter = head;
    while (iter->next != NULL) {
        iter = iter->next;
        n++;
    }
    int add = n - k % n;
    if (add == n) {
        return head;
    }
    iter->next = head;
    while (add--) {
        iter = iter->next;
    }
    struct ListNode\* ret = iter->next;
    iter->next = NULL;
    return ret;
}

--------------------------------------
/\*\*
 \* Definition for singly-linked list.
 \* struct ListNode {
 \* int val;
 \* ListNode \*next;
 \* ListNode() : val(0), next(nullptr) {}
 \* ListNode(int x) : val(x), next(nullptr) {}
 \* ListNode(int x, ListNode \*next) : val(x), next(next) {}
 \* };
 \*/
class Solution {
public:
    ListNode\* rotateRight(ListNode\* head, int k) {
        if (k == 0 || head == nullptr || head->next == nullptr) {
            return head;
        }
        int n = 1;
        ListNode\* iter = head;
        while (iter->next != nullptr) {
            iter = iter->next;
            n++;
        }
        int add = n - k % n;
        if (add == n) {
            return head;
        }
        iter->next = head;
        while (add--) {
            iter = iter->next;
        }
        ListNode\* ret = iter->next;
        iter->next = nullptr;
        return ret;
    }
};

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KqnTy2mK-1631410080358)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905212057168.png)]

234. 回文链表

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fBOhQ0IO-1631410080358)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905212221447.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-B6gUA4tx-1631410080358)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905212515583.png)]

bool isPalindrome(struct ListNode\* head) {
    int vals[50001], vals_num = 0;
    while (head != NULL) {
        vals[vals_num++] = head->val;
        head = head->next;
    }
    for (int i = 0, j = vals_num - 1; i < j; ++i, --j) {
        if (vals[i] != vals[j]) {
            return false;
        }
    }
    return true;
}

------------------------------------------

/\*\*
 \* Definition for singly-linked list.
 \* struct ListNode {
 \* int val;
 \* ListNode \*next;
 \* ListNode() : val(0), next(nullptr) {}
 \* ListNode(int x) : val(x), next(nullptr) {}
 \* ListNode(int x, ListNode \*next) : val(x), next(next) {}
 \* };
 \*/
class Solution {
public:
    bool isPalindrome(ListNode\* head) {
        vector<int> vals;
        while (head != nullptr) {
            vals.emplace\_back(head->val);
            head = head->next;
        }
        for (int i = 0, j = (int)vals.size() - 1; i < j; ++i, --j) {
            if (vals[i] != vals[j]) {
                return false;
            }
        }
        return true;
    }
};

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YAoUbP9i-1631410080359)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905212646870.png)]

struct ListNode\* frontPointer;

bool recursivelyCheck(struct ListNode\* currentNode) {
    if (currentNode != NULL) {
        if (!recursivelyCheck(currentNode->next)) {
            return false;
        }
        if (currentNode->val != frontPointer->val) {
            return false;
        }
        frontPointer = frontPointer->next;
    }
    return true;
}

bool isPalindrome(struct ListNode\* head) {
    frontPointer = head;
    return recursivelyCheck(head);
}

---------------------------------------------------------------------
class Solution {
    ListNode\* frontPointer;
public:
    bool recursivelyCheck(ListNode\* currentNode) {
        if (currentNode != nullptr) {
            if (!recursivelyCheck(currentNode->next)) {
                return false;
            }
            if (currentNode->val != frontPointer->val) {
                return false;
            }
            frontPointer = frontPointer->next;
        }
        return true;
    }

    bool isPalindrome(ListNode\* head) {
        frontPointer = head;
        return recursivelyCheck(head);
    }
};

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AKxY3gJ0-1631410080359)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905212745050.png)]

struct ListNode\* reverseList(struct ListNode\* head) {
    struct ListNode\* prev = NULL;
    struct ListNode\* curr = head;
    while (curr != NULL) {
        struct ListNode\* nextTemp = curr->next;
        curr->next = prev;
        prev = curr;
        curr = nextTemp;
    }
    return prev;
}

struct ListNode\* endOfFirstHalf(struct ListNode\* head) {
    struct ListNode\* fast = head;
    struct ListNode\* slow = head;
    while (fast->next != NULL && fast->next->next != NULL) {
        fast = fast->next->next;
        slow = slow->next;
    }
    return slow;
}

bool isPalindrome(struct ListNode\* head) {
    if (head == NULL) {
        return true;
    }

    // 找到前半部分链表的尾节点并反转后半部分链表
    struct ListNode\* firstHalfEnd = endOfFirstHalf(head);
    struct ListNode\* secondHalfStart = reverseList(firstHalfEnd->next);

    // 判断是否回文
    struct ListNode\* p1 = head;
    struct ListNode\* p2 = secondHalfStart;
    bool result = true;
    while (result && p2 != NULL) {
        if (p1->val != p2->val) {
            result = false;
        }
        p1 = p1->next;
        p2 = p2->next;
    }

    // 还原链表并返回结果
    firstHalfEnd->next = reverseList(secondHalfStart);
    return result;
}

------------------------------------------------------------------------
class Solution {
public:
    bool isPalindrome(ListNode\* head) {
        if (head == nullptr) {
            return true;
        }

        // 找到前半部分链表的尾节点并反转后半部分链表
        ListNode\* firstHalfEnd = endOfFirstHalf(head);
        ListNode\* secondHalfStart = reverseList(firstHalfEnd->next);

        // 判断是否回文
        ListNode\* p1 = head;
        ListNode\* p2 = secondHalfStart;
        bool result = true;
        while (result && p2 != nullptr) {
            if (p1->val != p2->val) {
                result = false;
            }
            p1 = p1->next;
            p2 = p2->next;
        }        

        // 还原链表并返回结果
        firstHalfEnd->next = reverseList(secondHalfStart);
        return result;
    }

    ListNode\* reverseList(ListNode\* head) {
        ListNode\* prev = nullptr;
        ListNode\* curr = head;
        while (curr != nullptr) {
            ListNode\* nextTemp = curr->next;
            curr->next = prev;
            prev = curr;
            curr = nextTemp;
        }
        return prev;
    }

    ListNode\* endOfFirstHalf(ListNode\* head) {
        ListNode\* fast = head;
        ListNode\* slow = head;
        while (fast->next != nullptr && fast->next->next != nullptr) {
            fast = fast->next->next;
            slow = slow->next;
        }
        return slow;
    }
};

160. 相交链表

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xvbl8czi-1631410080360)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905213134048.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vCpc6BDH-1631410080360)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905213351830.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Li0YuSSE-1631410080360)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210905213633355.png)]

struct HashTable {
    struct ListNode \*key;
    UT_hash_handle hh;
};

struct ListNode \*getIntersectionNode(struct ListNode \*headA, struct ListNode \*headB) {
    struct HashTable \*hashTable = NULL;
    struct ListNode \*temp = headA;
    while (temp != NULL) {
        struct HashTable \*tmp;
        HASH\_FIND(hh, hashTable, &temp, sizeof(struct HashTable \*), tmp);
        if (tmp == NULL) {
            tmp = malloc(sizeof(struct HashTable));
            tmp->key = temp;
            HASH\_ADD(hh, hashTable, key, sizeof(struct HashTable \*), tmp);
        }
        temp = temp->next;
    }
    temp = headB;
    while (temp != NULL) {
        struct HashTable \*tmp;
        HASH\_FIND(hh, hashTable, &temp, sizeof(struct HashTable \*), tmp);
        if (tmp != NULL) {
            return temp;
        }
        temp = temp->next;
    }
    return NULL;
}

--------------------------------
/\*\*
 \* 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_set<ListNode \*> visited;
        ListNode \*temp = headA;
        while (temp != nullptr) {
            visited.insert(temp);
            temp = temp->next;
        }
        temp = headB;
        while (temp != nullptr) {
            if (visited.count(temp)) {


![img](https://img-blog.csdnimg.cn/img_convert/bb13c399c04bf10671ca518401a73a26.png)
![img](https://img-blog.csdnimg.cn/img_convert/a72ab1a84faaa7660095e2ce0daba937.png)
![img](https://img-blog.csdnimg.cn/img_convert/abc81e524665a2b888e64f0ef2c8e95b.png)

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Go语言开发知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[如果你需要这些资料，可以戳这里获取](https://bbs.csdn.net/topics/618658159)**


        struct HashTable \*tmp;
        HASH\_FIND(hh, hashTable, &temp, sizeof(struct HashTable \*), tmp);
        if (tmp == NULL) {
            tmp = malloc(sizeof(struct HashTable));
            tmp->key = temp;
            HASH\_ADD(hh, hashTable, key, sizeof(struct HashTable \*), tmp);
        }
        temp = temp->next;
    }
    temp = headB;
    while (temp != NULL) {
        struct HashTable \*tmp;
        HASH\_FIND(hh, hashTable, &temp, sizeof(struct HashTable \*), tmp);
        if (tmp != NULL) {
            return temp;
        }
        temp = temp->next;
    }
    return NULL;
}

--------------------------------
/\*\*
 \* 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_set<ListNode \*> visited;
        ListNode \*temp = headA;
        while (temp != nullptr) {
            visited.insert(temp);
            temp = temp->next;
        }
        temp = headB;
        while (temp != nullptr) {
            if (visited.count(temp)) {


[外链图片转存中...(img-2IFtQPIZ-1715536071623)]
[外链图片转存中...(img-Zbov6QIN-1715536071624)]
[外链图片转存中...(img-C7Rcults-1715536071624)]

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Go语言开发知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[如果你需要这些资料，可以戳这里获取](https://bbs.csdn.net/topics/618658159)**
BlackCATdog
关注
专栏目录
力扣笔记之链表常见题型
m0_46191714的博客
09-16 116
记录刷力扣时遇到的技巧（链表） /* * public class ListNode { * int val; * ListNode next; * ListNode() {} * ListNode(int val) { this.val = val; } * ListNode(int val, ListNode next) { this.val = val; this.next = next; } */ ListNode header = new Li
链表的基本操作 及力扣典型题型
June的博客
01-07 749
掌握此文，链表使用便可得心应手
【LeetCode刷题日记】链表类题目常见题型
qq_41854911的博客
09-12 467
文章目录[21. 合并两个有序链表](https://leetcode-cn.com/problems/merge-two-sorted-lists/)[19. 删除链表的倒数第 N 个结点](https://leetcode-cn.com/problems/remove-nth-node-from-end-of-list/)[2. 两数相加](https://leetcode-cn.com/problems/add-two-numbers/)[24. 两两交换链表中的节点](https://leetcod
Python3爬虫项目集：爬取知乎十几万张小姐姐美图
零度的博客
11-06 8414
文章目录前言注意点代码实例 前言 github：https://github.com/pasca520/Python3SpiderSet 知乎上有很多钓鱼贴，也成功的钓上了很多鱼，你懂的~~~ 这里通过 python 爬了一些图片，总共大概有十几万张，仅供练习使用： 示例 python 库 爬取模块 request 解析模块 re 存储类型 存储图片到本地&七牛云存...
洛谷日报索引
王俊吉的博客
02-16 8万+
2022 年洛谷日报索引 2月 #383 [159号程序员] CSP初赛知识点梳理 https://www.luogu.com.cn/blog/334586/csp-pre-knowledge #382 [xtx1092515503] 群论学习笔记 https://www.luogu.com.cn/blog/Troverld/qun-lun-xue-xi-bi-ji #381 [Alpha1022] 浅谈集合幂级数 https://www.luogu.com.cn/blog/your-alpha1022/q
leetcode分类-leetcode:leetcode刷题（中等难度分类）
06-30
1. 回溯法：中等难度题目中，回溯法是一种常见的解决方案，如"Combination Sum"（组合总和）和"N-Queens"（皇后问题），通过回溯可以找到所有可能的解。 2. 动态规划："House Robber"（打家劫舍）系列问题，展示了...
1_leetcode刷题指南.pdf
05-08
本文件为《1_leetcode刷题指南.pdf》的内容摘录，它是一份关于在leetcode上进行编程刷题的分组指南。leetcode是一个提供编程题目和在线评测系统的平台，广泛用于计算机科学和软件工程领域的算法和编程技能训练。根据...
leetcode分类-Leetcode:Leetcode刷题分类
06-30
本篇文章将详细探讨LeetCode中的题型分类，并结合其开源系统的特点，帮助读者更有效地进行刷题与学习。 首先，LeetCode的题型主要分为五大类：数组、字符串、链表、树和二分查找。这五大类涵盖了数据结构和算法的...
谷歌师兄的leetcode刷题笔记-HackBU2020_Gruszecki_Meliti_Chaudhary:可怕的广告黑客
06-30
7. **面试准备**：可能还包含了如何准备面试，常见面试题型，以及如何通过算法题展示自己的技术实力。 总之，这份笔记对于希望提升编程技能，尤其是算法和数据结构应用能力的开发者，以及对广告优化感兴趣的人员，...
LeetCode刷题笔记.rar
07-05
在LeetCode中，常见的算法题型涉及排序（快速排序、归并排序、堆排序等）、搜索（二分查找、深度优先搜索、广度优先搜索等）、动态规划、贪心算法、回溯法、分治法等。动态规划通常用于解决最优化问题，如背包问题、...
azchn.com+app.html,Analysis.ipynb
热门推荐
weixin_34518190的博客
07-02 41万+
{"cells": [{"cell_type": "code","execution_count": 1,"metadata": {},"outputs": [],"source": ["import torch\n","import matplotlib.pyplot as plt\n","import cv2\n","import pandas as pd"]},{"cell_type": "...
com.android.kyj.onj,Android 自学之列表选择框Spinner
weixin_39635657的博客
05-28 29万+
列表选择框(Spinner)与Swing编程里面的Spinner不同，这里的Spinner其实就是一个列表选项框。Spinner是ViewGroup的间接子类，因此他也可作为容器使用。Spinner支持的常用XML属性和说明：XML属性说明android：prompt设置该列表框的提示android：entries使用数组资源设置该下拉列表框的列表项目啥都不说了我们看看代码：layout/main...
qaz69.com forum.php,Eclipse Community Forums
weixin_39586395的博客
03-21 2万+
Originally posted by: richkulp.us.NO_SPAM.ibm.comThis is a multi-part message in MIME format.--------------080707010607010307000006Content-Type: text/plain; charset=ISO-8859-15; format=flowedContent-T...
101个shell脚本
weixin_34337381的博客
11-30 1万+
本文用于记录学习和日常中使用过的shell脚本 【脚本1】打印形状 打印等腰三角形、直角三角形、倒直角三角形、菱形 #!/bin/bash # 等腰三角形 read -p "Please input the length: " n for i in `seq 1 $n` do for ((j=$n;j>i;j--)) do echo -n " " done ...
ZOJ2599：Graduated Lexicographical Ordering(很经典的数位DP)
weixin_34254823的博客
07-08 139
Consider integer numbers from 1 to n. Let us call the sum of digits of an integer number its weight. Denote the weight of the number x as w(x). Now let us order the numbers using so called gradua...
今天面了一个大学生：这82道SpringBoot面试题都答不上来？还想进大厂？
jiey0407的博客
05-31 2300
Spring Boot面试题 1、什么是Spring Boot？ 多年来，随着新功能的增加，spring变得越来越复杂。只需访问页面，我们就会看到可以在我们的应用程序中使用的所有Spring项目的不同功能。如果必须启动一个新的Spring项目，我们必须添加构建路径或添加Maven依赖关系，配置应用程序服务器，添加spring配置。因此，开始一个新的spring项目需要很多努力，因为我们现在必须从头开始做所有事情。 Spring Boot是解决这个问题的方法。Spring Boot已经建立在现有spring框
Leetcode13、90、78、717、89、10、14回溯子集和罗马数字
weixin_51081223的博客
04-18 301
试的顺序一定是先从大的，一直试到小的 s = s.substr(), 前面必须有s=做接受才行。 while循环，第一个匹配不上，从大到小继续去匹配。 一直匹配大的数字，匹配到后来前面的大数不必匹配的 class Solution { public: int romanToInt(string s) { int num[]={1000,900,500,400,100,90,50,40,10,9,5,4,1}; string temp[]={"M","CM"..
verilog FAQ
Augusdi的专栏
03-19 2113
1. What is the race condition in verilog? Ans :The situation when two expressions are allowed to execute at same instance of time without mentioning the order of execution. 2. List the levels of abs...
如何用3个月零基础入门网络安全？_网络安全零基础怎么学习
最新发布
2401_84466224的博客
10-15 1175
我们知道计算机最早是在西方发明出来的，很多名词或者代码都是英文的，甚至现有的一些教程最初也是英文原版翻译过来的，而且一个漏洞被发现到翻译成中文一般需要一个星期的时间，在这个时间差上漏洞可能都修补了。”答案是否定的，黑客用的电脑,不需要什么高的配置,只要稳定就行.因为黑客所使用的一些程序,低端CPU也可以很好的运行,而且不占什么内存.还有一个,黑客是在DOS命令下对进行的,所以电脑能使用到最佳状态!观看学习近十年所有0day挖掘的帖，然后搭建环境，去复现漏洞，去思考学习笔者的挖洞思维，培养自己的渗透思维。
LeetCode题目难度与数据结构分类指南
刷题时，建议先从简单的题目入手，逐步熟悉 LeetCode 的题型和常见算法，再逐渐挑战中等和困难级别。通过这种方式，你可以更好地理解不同算法的应用场景，提升解决问题的能力。同时，结合题目描述中的数据结构和算法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值