小工具知识网

当前位置: 首页 > 行业知识 > Offer必备算法12

行业知识

Offer必备算法12

2026-11-16 10:21:14 来源:互联网转载

���录

①力扣2. 两数相加

解析代码

②力扣24. 两两交换链表中的节点

解析代码

③力扣143. 重排链表

解析代码

④力扣23. 合并 K 个升序链表

解析代码1(小根堆优化)

解析代码2(递归_归并)

⑤力扣25. K 个一组翻转链表

解析代码

本篇完。


①力扣2. 两数相加

2. 两数相加

难度 中等

给你两个 非空 的链表,表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的,并且每个节点只能存储 一位 数字。

请你将两个数相加,并以相同形式返回一个表示和的链表。

你可以假设除了数字 0 之外,这两个数都不会以 0 开头。

示例 1:

输入:l1 = [2,4,3], l2 = [5,6,4]输出:[7,0,8]解释:342 + 465 = 807.

示例 2:

输入:l1 = [0], l2 = [0]输出:[0]

示例 3:

输入:l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]输出:[8,9,9,9,0,0,0,1]

提示:

  • 每个链表中的节点数在范围 [1, 100] 内
  • 0 next; } if(cur2) { val += cur2->val; cur2 = cur2->next; } head->next = new ListNode(val % 10); head = head->next; carry = val / 10; } return ret->next; }};

    ②力扣24. 两两交换链表中的节点

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

    难度 中等

    给你一个链表,两两交换其中相邻的节点,并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题(即,只能进行节点交换)。

    示例 1:

    输入:head = [1,2,3,4]输出:[2,1,4,3]

    示例 2:

    输入:head = []输出:[]

    示例 3:

    输入:head = [1]输出:[1]

    提示:

    • 链表中节点的数目在范围 [0, 100] 内
    • 0 1 -> 2 -> 3 // 1和2换 -> cur和next1换 // prev -> cur -> next1 -> next2 // cur -> prev -> next1 -> next2 ListNode *prev=newHead, *cur=head, *next1=head->next, *next2=next1->next; while(cur && next1) { prev->next = next1; next1->next = cur; cur->next = next2; prev = cur; cur = next2; if(cur) next1 = cur->next; if(next1) next2 = next1->next; } cur = newHead->next; delete newHead; return cur; // 递归法 // if(head == nullptr || head->next == nullptr) // return head; // ListNode* tmp = swapPairs(head->next->next); // 把两个结点之外的看成另一部分 // head->next->next = head; // auto ret = head->next; // 保存一下要返回的结点 // head->next = tmp; // return ret; }};

      ③力扣143. 重排链表

      难度 中等

      给定一个单链表 L 的头节点 head ,单链表 L 表示为:

      L0 → L1 → … → Ln - 1 → Ln

      请将其重新排列后变为:

      L0 → Ln → L1 → Ln - 1 → L2 → Ln - 2 → …

      不能只是单纯的改变节点内部的值,而是需要实际的进行节点交换。

      示例 1:

      输入:head = [1,2,3,4]输出:[1,4,2,3]

      示例 2:

      输入:head = [1,2,3,4,5]输出:[1,5,2,4,3]

      提示:

      • 链表的长度范围为 [1, 5 * 10^4]
      • 1 next->next==nullptr) return; // 处理边界情况 ListNode *fast = head, *slow = head; while(fast && fast->next) // 找到中间结点 { slow = slow->next; fast = fast->next->next; } ListNode* slowNext = slow->next; slow->next = nullptr; // 两个链表断开 slow = slowNext; ListNode *reverseList = nullptr; while(slow) // 中间结点后面的头插到翻转链表 { slowNext = slow->next; slow->next = reverseList; reverseList = slow; slow = slowNext; } ListNode* tmp = head; // 合并两个链表 ListNode *cur1 = head->next, *cur2 = reverseList; while(cur1 && cur2) { tmp->next = cur2; tmp = tmp->next; cur2 = cur2->next; tmp->next = cur1; cur1 = cur1->next; tmp = tmp->next; } }};

        ④力扣23. 合并 K 个升序链表

        23. 合并 K 个升序链表

         难度 困难

        给你一个链表数组,每个链表都已经按升序排列。

        请你将所有链表合并到一个升序链表中,返回合并后的链表。

        示例 1:

        输入:lists = [[1,4,5],[1,3,4],[2,6]]输出:[1,1,2,3,4,4,5,6]解释:链表数组如下:[  1->4->5,  1->3->4,  2->6]将它们合并到一个有序链表中得到。1->1->2->3->4->4->5->6

        示例 2:

        输入:lists = []输出:[]

        示例 3:

        输入:lists = [[]]输出:[]

        提示:

        • k == lists.length
        • 0 next); } } tmp = newHead->next; delete newHead; return tmp; }};

          解析代码2(递归_归并)

          1. 递归出口:如果当前要合并的链表编号范围左右值相等,无需合并,直接返回当前链表。
          2. 应用二分思想,等额划分左右两段需要合并的链表,使这两段合并后的长度尽可能相等。
          3. 对左右两段分别递归,合并[left,right]范围内的链表。
          4. 最后调用合并两个链表函数进行合并。
          /** * 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* mergeKLists(vector& lists) {        return merge(lists, 0, lists.size() - 1);    }    ListNode* merge(vector& lists, int left, int right)    {        if(left > right) // 区间不存在            return nullptr;        if(left == right) // 只有一个链表            return lists[left];                int mid = (left + right) >> 1;        ListNode* list1 = merge(lists, left, mid);        ListNode* list2 = merge(lists, mid+1, right);        // 上面递归得到一个/两个链表        return mergeTwoLists(list1, list2);    }    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2)    {        if(list1 == nullptr)            return list2;        if(list2 == nullptr)            return list1;                if(list1->val val)        {            list1->next = mergeTwoLists(list1->next, list2);            return list1;        }        else        {            list2->next = mergeTwoLists(list2->next, list1);            return list2;        }    }};

          ⑤力扣25. K 个一组翻转链表

          25. K 个一组翻转链表

           难度 困难

          给你链表的头节点 head ,每 k 个节点一组进行翻转,请你返回修改后的链表。

          k 是一个正整数,它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍,那么请将最后剩余的节点保持原有顺序。

          你不能只是单纯的改变节点内部的值,而是需要实际进行节点交换。

          示例 1:

          输入:head = [1,2,3,4,5], k = 2输出:[2,1,4,3,5]

          示例 2:

          输入:head = [1,2,3,4,5], k = 3输出:[3,2,1,4,5]

          提示:

          • 链表中的节点数目为 n
          • 1 next = cur; cur = prevNext; } prev = tmp; } prev->next = cur; cur = newHead->next; delete newHead; return cur; }};

            本篇完。

            下一篇动态规划的类型的路径dp类型的OJ。

            下下篇数据结构类型的是哈希表类型的OJ。

上一篇:服务器怎么将别人踢出?

下一篇:柯南服务器怎么样