LeetCode高频题刷题笔记（二）链表

已于 2023-05-24 18:16:18 修改
阅读量232 收藏
点赞数
分类专栏： LeetCode刷题专栏 文章标签： leetcode 算法 链表
于 2023-03-17 15:02:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29355253/article/details/127226175
版权
本文介绍了LeetCode中涉及链表操作的多个问题，包括寻找链表中间节点、排序链表、重排链表、旋转链表、两两交换节点、合并K个升序链表、删除重复元素、环形链表检测、回文链表判断、相交链表查找、奇偶链表重组、K个一组翻转链表、反转链表II以及复制带随机指针的链表。解题策略涵盖迭代、递归、哈希表和双指针等技巧。
摘要由CSDN通过智能技术生成

题目

1.链表的中间结点（ LeetCode 876 ）

难度： 简单
题目表述：
给定一个头结点为 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。
代码（C++）：

class Solution {
public:
    ListNode* middleNode(ListNode* head) {
        ListNode* slow = head;
        ListNode* fast = head;
        while (fast != nullptr && fast->next != nullptr) {
            slow = slow->next;
            fast = fast->next->next;
        }
        return slow;
    }
};

题解： 快慢指针

2.排序链表（ LeetCode 148 ）

难度： 中等
题目表述：
给你链表的头结点 head ，请将其按 升序 排列并返回 排序后的链表 。
代码（C++）：

class Solution {
public:
    ListNode* sortList(ListNode* head) {
        if (head == nullptr) return nullptr;
        ListNode* p = head;
        int length = 0;
        while (p != nullptr) {
            p = p->next;
            length++;
        }
        ListNode* dummyHead = new ListNode(0, head);
        for (int sublength = 1; sublength < length; sublength <<= 1) {
            ListNode* prev = dummyHead;
            ListNode* curr = dummyHead->next;
            while (curr != nullptr) {
                ListNode* head1 = curr;
                for (int i = 1; i < sublength && curr->next != nullptr; i++) {
                    curr = curr->next;
                }
                ListNode* head2 = curr->next;
                curr->next = nullptr;
                curr = head2;
                for (int i = 1; i < sublength && curr !=nullptr && curr->next != nullptr; i++) {
                    curr = curr->next;
                }
                ListNode* next = nullptr;
                if (curr != nullptr) {
                    next = curr->next;
                    curr->next = nullptr;
                }
                prev->next = merge(head1, head2);
                while (prev->next != nullptr) {
                    prev= prev->next;
                }
                curr = next;
            }
        }
        return dummyHead->next;
    }
    ListNode* merge(ListNode* head1, ListNode* head2) {
        ListNode* dummyHead = new ListNode();
        ListNode* tmp =dummyHead;
        ListNode* tmp1 = head1;
        ListNode* tmp2 = head2;
        while (tmp1 != nullptr && tmp2 != nullptr) {
            if (tmp1->val < tmp2->val) {
                tmp->next = tmp1;
                tmp1 = tmp1->next;
            } else {
                tmp->next = tmp2;
                tmp2 = tmp2->next;
            }
            tmp = tmp->next;
        }
        if (tmp1 != nullptr) {
            tmp->next = tmp1;
        } else if (tmp2 != nullptr) {
            tmp->next = tmp2;
        }
        return dummyHead->next;
    }
};

题解：
时间复杂度是O(nlogn) 的排序算法包括 归并排序、堆排序 和 快速排序（快速排序的最差时间复杂度是 O(n^2)），其中最适合链表的排序算法是归并排序。
使用自底向上的方法实现归并排序，则可以达到 O(1) 的空间复杂度。

⭐3.重排链表（ LeetCode 143 ）

难度： 中等
题目表述：
L0 → Ln → L1 → Ln - 1 → L2 → Ln - 2 → …
代码（C++）：

class Solution {
public:
    void reorderList(ListNode* head) {
        if (head == nullptr) return;
        ListNode* mid = middleNode(head);
        ListNode* head2 = reverseList(mid->next);
        mid->next = nullptr;
        mergeList(head, head2);
    }
    ListNode* middleNode(ListNode* head) {
        ListNode* slow = head;
        ListNode* fast = head;
        while (fast->next != nullptr && fast->next->next != nullptr) {
            slow = slow->next;
            fast = fast->next->next;
        }
        return slow;
    }
    ListNode* reverseList(ListNode* head) {
        ListNode* pre = nullptr;
        ListNode* cur = head;
        while (cur != nullptr) {
            ListNode* next = cur->next;
            cur->next = pre;
            pre = cur;
            cur = next;
        }
        return pre;
    }
    void mergeList(ListNode* head1, ListNode* head2) {
        ListNode* p1 = head1;
        ListNode* p2 = head2;
        while (p1 != nullptr && p2 != nullptr) {
            ListNode* tmp_p1 = p1->next;
            ListNode* tmp_p2 = p2->next;
            p1->next = p2;
            p1 = tmp_p1;
            p2->next = p1;
            p2 = tmp_p2;
        }
    }
};

题解：
寻找链表中点 + 链表逆序 + 合并链表
寻找链表中点：若是偶数个节点，则
fast->next != nullptr && fast->next->next != nullptr找的是前半段的尾
fast != nullptr && fast->next != nullptr找的是后半段的首

4.旋转链表（ LeetCode 61 ）

难度： 中等
题目表述：
给你一个链表的头节点 head ，旋转链表，将链表每个节点向右移动 k 个位置。
代码（C++）：

class Solution {
public:
    ListNode* rotateRight(ListNode* head, int k) {
        if (head == nullptr || head->next == nullptr || k == 0) return head;
        int length = 1;
        ListNode* tail = head;
        while (tail->next != nullptr) {
            tail = tail->next;
            length++;
        }
        int add = length - (k % length);
        if (add == length) return head;
        tail->next = head;
        while (add--) {
            tail = tail->next;
        }
        head = tail->next;
        tail->next = nullptr;
        return head;
    }
};

题解：
闭合为环

5.两两交换链表中的节点（ LeetCode 24 ）

难度： 中等
题目表述：
给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。
代码（C++）：

class Solution {
public:
	// 迭代
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummyHead = new ListNode(0, head);
        ListNode* pre = dummyHead;
        while (pre->next && pre->next->next) {
            ListNode* node1 = pre->next;
            ListNode* node2 = pre->next->next;
            node1->next = node2->next;
            node2->next = node1;
            pre->next = node2;
            pre = node1;
        }
        return dummyHead->next;
    }
    // 递归
    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;
    }
};

题解： 迭代 / 递归

⭐6.合并K个升序链表（ LeetCode 23 ）

难度： 困难
题目表述：
给你一个链表数组，每个链表都已经按升序排列。请你将所有链表合并到一个升序链表中，返回合并后的链表。
代码（C++）：

class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        if (lists.size() == 0) return nullptr;
        return merge(lists, 0, lists.size() - 1);
    }
    ListNode* merge(vector<ListNode*>& lists, int l, int r) {
        if (l == r) {
            return lists[l];
        }
        int mid = (l + r) >> 1;
        return mergeTwoLists(merge(lists, l, mid), merge(lists, mid + 1, r));
    }
    ListNode* mergeTwoLists(ListNode* head1, ListNode* head2) {
        ListNode* dummyHead = new ListNode();
        ListNode *p = dummyHead, *p1 = head1, *p2 = head2;
        while (p1 != nullptr && p2 != nullptr ) {
            if (p1->val < p2->val) {
                p->next = p1;
                p1 = p1->next;
            } else {
                p->next = p2;
                p2 = p2->next;
            }
            p = p->next;
        }
        p->next = p1 ? p1 : p2;
        return dummyHead->next;
    }
};

题解： 分支合并

7.删除排序链表中的重复元素 II（ LeetCode 82 ）

难度： 中等
题目表述：
给定一个已排序的链表的头 head ， 删除原始链表中所有重复数字的节点，只留下不同的数字 。返回 已排序的链表 。
代码（C++）：

class Solution {
public:
	// 迭代
    ListNode* deleteDuplicates(ListNode* head) {
        if (!head) return head;
        ListNode* node = head;
        ListNode* dummyHead = new ListNode(0, head);
        ListNode* pre = dummyHead;
        while (pre->next && pre->next->next) {
            if (pre->next->val == pre->next->next->val) {
                int x = pre->next->val;
                while (pre->next && pre->next->val == x) {
                    pre->next = pre->next->next;
                }
            } else {
                pre = pre->next;
            }
        }
        return dummyHead->next;
    }
    // 递归
    ListNode* deleteDuplicates(ListNode* head) {
        if (!head || !head->next) return head;
        if (head->val == head->next->val) {
            int x = head->val;
            while (head && head->val == x) {
                head = head->next;
            }
            head = deleteDuplicates(head);
        } else {
            head->next = deleteDuplicates(head->next);
        }
        return head;
    }
};

题解： 头节点不一定会保留
链表和树的问题，一般都可以有递归和迭代两种写法。

8.删除排序链表中的重复元素（ LeetCode 83 ）

难度： 简单
题目表述：
给定一个已排序的链表的头 head ， 删除所有重复的元素，使每个元素只出现一次 。返回 已排序的链表 。
代码（C++）：

class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        if (!head) {
            return head;
        }
        ListNode* cur = head;
        while (cur->next) {
            if (cur->val == cur->next->val) {
                cur->next = cur->next->next;
            }
            else {
                cur = cur->next;
            }
        }
        return head;
    }
};

题解： 头节点一定会保留

⭐9.环形链表 II （ LeetCode 142 ）

难度： 中等
题目描述：
给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
代码（C++）：

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode *fast = head;
        ListNode *slow = head;
        while (fast != NULL && fast->next != NULL) {
            slow = slow->next;
            fast = fast->next->next;
            if(slow == fast) {
                ListNode *p = head;
                while (p != slow){
                    slow = slow->next;
                    p = p->next;
                }
                return p;
            }
        }
        return NULL;
    }
};

题解： 快慢指针
fast += 2， slow += 1，fast 和 slow 相差一步最合理 ，fast 跑的越慢，越能在环中少跑几圈等到还在外面直线跑的 slow
外循环结束条件：fast != NULL && fast->next != NULL
慢指针第一圈走不完一定会和快指针相遇。设链表中环外部分的长度为 a，slow 指针进入环后，又走了 b 的距离与 fast 相遇，此时，fast 指针已经走完了环的 n 圈。任意时刻，fast 指针走过的距离都为slow 指针的 2 倍，故可得
a + n(b + c) + b = 2(a + b) ⟹ a = c + (n - 1)(b + c)
在这里插入图片描述

10.回文链表（ LeetCode 234 ）

难度： 简单
题目描述：
给你一个单链表的头节点 head ，请你判断该链表是否为回文链表，如 [1,2,2,1]
代码（C++）：

/** 快慢指针
1.找到前半部分链表的尾节点。
2.反转后半部分链表。
3.判断是否回文。
4.恢复链表。
5.返回结果。
**/
class Solution {
public:
    bool isPalindrome(ListNode* head) {
        ListNode* lEnd = getMiddleNode(head);
        ListNode* reverseRHead = reverseList(lEnd->next);
        ListNode* p1 = head, *p2 = reverseRHead;
        bool res = true;
        while (res && p2 != nullptr) {
            if (p1->val != p2->val) {
                res = false;
            }
            p1 = p1->next;
            p2 = p2->next;
        }
        lEnd->next= reverseList(reverseRHead);
        return res;
    }
    ListNode* getMiddleNode(ListNode* head) {
       ListNode* slow = head;
       ListNode* fast = head; 
       while (fast->next && fast->next->next) {
           slow = slow->next;
           fast = fast->next->next;
       }
       return slow;
    }
    ListNode* reverseList(ListNode* head) {
        ListNode *pre = nullptr, *cur = head;
        while (cur) {
            ListNode* next = cur->next;
            cur->next = pre;
            pre = cur;
            cur = next;
        }
        return pre;
    }
};
// 利用递归的特性：从后往前
class Solution {
    ListNode* firstNode;
public:
    bool isPalindrome(ListNode* head) {
        firstNode = head;
        return recursivelyCheck(head);
    }
    bool recursivelyCheck(ListNode* currentNode) {
        if (currentNode != nullptr) {
            if (!recursivelyCheck(currentNode->next)) {
                return false;
            }
            if (currentNode->val != firstNode->val) {
                return false;
            }
            firstNode = firstNode->next;
        } 
        return true;
    }
};

题解： 快慢指针 / 递归

11.相交链表（ LeetCode 160 ）

难度： 简单
代码（C++）：

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        if (headA == NULL || headB == NULL)
            return NULL;
        ListNode *pA = headA;
        ListNode *pB = headB;
        while (pA != pB){
            if (pA == NULL)
                pA = headB; 
            else
                pA = pA->next;
            if (pB == NULL)
                pB = headA;
            else
                pB = pB->next;
            
        }
        return pA;
    }
};

题解： 双指针交叉循环遍历
无论 A、B 两个链表是否有相交点，最终都会指向一个相同的节点，要么是它们的公共尾部，要么是 NULL。

12.奇偶链表（ LeetCode 328 ）

难度： 中等
代码（C++）：

class Solution {
public:
    ListNode* oddEvenList(ListNode* head) {
        if (!head) return head;
        ListNode* oddP = head;
        ListNode* evenHead = head->next;
        ListNode* evenP = evenHead;
        while (evenP && evenP->next) {
            oddP->next = evenP->next;
            oddP = oddP->next;
            evenP->next = oddP->next;
            evenP = evenP->next;
        }
        oddP->next = evenHead;
        return head;
    }
};

题解： 分离后合并

13.K 个一组翻转链表（ LeetCode 25 ）

难度： 困难
题目描述：
给你链表的头节点 head ，每 k 个节点一组进行翻转，请你返回修改后的链表。
代码（C++）：

class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        ListNode* dummyHead = new ListNode(0, head);
        ListNode* pre = dummyHead;
        while (pre->next) {
            ListNode* h = pre->next;
            ListNode* t = h;
            int i = 1;
            while (i++ < k && t) {
                t = t->next;
            }
            if (t) {
                ListNode* next = t->next;
                t->next = nullptr;
                pre->next = reverseList(h);
                h->next = next;
                pre = h;
            } else {
                break;
            }
        }
        return dummyHead->next;
    }
    ListNode* reverseList(ListNode* head) {
        ListNode* pre = nullptr;
        ListNode* cur = head;
        while (cur) {
            ListNode* next = cur->next;
            cur->next = pre;
            pre = cur;
            cur = next;
        }
        return pre;
    }
};

题解： 反转链表

14.反转链表 II （ LeetCode 92 ）

难度： 中等
题目表述：
给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点，返回反转后的链表 。
代码（C++）：

class Solution {
public:
	// 递归 O(n) O(n)
    ListNode* reverseList(ListNode* head) {
        if (head == NULL || head->next == NULL) {
            return head;
        }
        ListNode* ret = reverseList(head->next);
        head->next->next = head;
        head->next = NULL;
        return ret;
    }
    // 迭代 O(n) O(1)
    void reverseList(ListNode* head) {
        ListNode *pre = nullptr;
        ListNode *cur = head;
        while (cur != nullptr) {
            ListNode *next = cur->next;
            cur->next = pre;
            pre = cur;
            cur = next;
        }
        head = pre;
    }
    ListNode* reverseBetween(ListNode* head, int left, int right) {
        ListNode *dummyNode = new ListNode();
        dummyNode->next = head;
        ListNode *pre = dummyNode;
        for (int i = 1; i < left; i++) {
            pre = pre->next;
        }
        ListNode *leftNode = pre->next;
        ListNode *rightNode = pre;
        for (int i = 0; i < right - left + 1; i++) {
            rightNode = rightNode->next;
        }
        ListNode *tail = rightNode->next;
        pre->next = nullptr;
        rightNode->next = nullptr;
        reverseList(leftNode);
        leftNode->next = tail;
        pre->next = rightNode;
        return dummyNode->next;
    }
};

题解：
因为头节点有可能发生变化，使用虚拟头节点dummyNode可以避免复杂的分类讨论

⭐15.复制带随机指针的链表（ LeetCode 138 ）

难度： 中等
题目表述：
请实现 copyRandomList 函数，复制一个复杂链表。在复杂链表中，每个节点除了有一个 next 指针指向下一个节点，还有一个 random 指针指向链表中的任意节点或者 null。
代码（C++）：

class Solution {
private:
    unordered_map<Node*, Node*> map;
public:
    Node* copyRandomList(Node* head) {
        if (head == NULL) {
            return head;
        }
        if (map.count(head) == 0) {
            Node* newNode = new Node(head->val);
            map[head] = newNode;
            newNode->next = copyRandomList(head->next);
            newNode->random = copyRandomList(head->random);
        }
        return map[head];
    }
};

题解： 回溯 + 哈希表 / 迭代 + 节点拆分
利用回溯的方式，让每个节点的拷贝操作相互独立

16.删除链表的倒数第 N 个结点（ LeetCode 19 ）

难度： 中等
题目表述：
给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
代码（C++）：

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyNode = new ListNode(0, head);
        ListNode* fast = head, *slow = dummyNode;
        for (int i = 0; i < n; i++) {
            fast = fast->next;
        }
        while (fast) {
            fast = fast->next;
            slow = slow->next;
        }
        ListNode* tmp = slow->next;
        slow->next = slow->next->next;
        delete tmp;
        return dummyNode->next;
    }
};

题解： 快慢指针

小结

迭代、递归、哈希表、双指针、快慢指针

参考链接

玩转 LeetCode 高频 100 题
LeetCode 刷题攻略

123冲鸭
关注
专栏目录
五道LeetCode《中等难度》的单链表题
xiaoyubuhuiqiche的博客
12-08 2655
图文并茂，五道单链表题，看明白并且能独自实现，你就初步掌握链表了
LeetCode Java刷题笔记—143. 重排链表
终生学习践行者
01-05 793
LeetCode Java刷题笔记—143. 重排链表
链表排序
思维缜密的博客
12-09 4730
下面的排序只针对无头结点的单链表，当然有头节点稍微改改就可以了 选择排序 选择排序就是每次选一个最小的，放到前面 为了方便操作，创造一个头结点 /** * Definition of singly-linked-list: * class ListNode { * public: * int val; * ListNode *next; * ListNode(int val) { * this->val = val; * t
链表OJ题（二）
想要上进的coder的博客
11-01 371
一、分割两个链表 思路：我们可以创建两个新的链表，原链表用一个指针cur去遍历比较，小于x的结点放在less链表中，大于x的放在greater链表中，最后再将两个链表链接起来即可 动画演示： 为了方便操作找尾，开两个哨兵位头结点，方便尾插操作，我们两个链表分别定义lessHead，lessTail和greaterHead，greaterTail指针 注意在最后的时候，greaterTali还链接这lessTail，这样会形成带环结构，这样就会造成程序超过内存限制，要将grea..
LeetCode高频题刷题笔记（五）哈希表
qq_29355253的博客
03-28 429
13：模拟行走机器人、串联所有单词的子串、数组的度、子域名访问计数、字母异位词分组、有效的字母异位词、查找共用字符、两个数组的交集、快乐数、三数之和、四数之和、四数相加 II、赎金信
LeetCode高频题刷题笔记（九）二分查找
qq_29355253的博客
04-07 119
4：第一个错误的版本、搜索插入位置、搜索二维矩阵、寻找两个正序数组的中位数
LeetCode高频题刷题笔记（七）双指针
qq_29355253的博客
03-31 203
10：寻找重复数、验证回文串、x 的平方根、移除元素、反转字符串、翻转字符串里的单词、最接近的三数之和、三数之和、四数之和、两数之和
Leetcode刷题笔记—链表篇
qq_42898642的博客
09-21 194
本文主要介绍了大厂面试中关于链表的相关考点，希望能在面试准备中帮助到大家，一起加油呀，祝大家都能找到心仪的offer，冲鸭~
Leetcode刷题笔记--链表
qq_45795134的博客
04-03 890
链表相对于二叉树简单多了，它可以看成只有左子树或者右子树的二叉树。复习一下之前做过的链表题目，放松一下心情。。对于链表的相关习题先写到这，还有很多有关链表的进阶题目，需要不断的练习，才能熟能生巧！
字节工程师总结的LeetCode刷题笔记提供下载，太优秀了
javaAnPou的博客
02-24 483
字节工程师总结的LeetCode刷题笔记提供下载，太优秀了
独家 | Google 资深软件工程师 LeetCode 刷题笔记首次公开
墨鱼菜鸡
09-09 188
有人说写代码就像我们平时开车，仅凭经验你就可以将车开走；但当有一天，这辆车出问题跑不起来的时候，你不懂汽车的运行机制，你要怎么排除和解决问题？所以拥有扎实的数据结构和算法，才能开好编程这辆车。 作为程序员立身之根本，算法更是面试必不可少的环节。像 Google、Facebook、Apple、Nvidia 等等这些硅谷公司，都会把数据结构和算法作为...
leetcode高频题笔记之双指针专题
clonechen
03-25 869
在许多数组和链表的题中，都需要用到双指针的思想来优化，本文总结归纳了几种常见的双指针和对应的应用案例，通过针对的性的刷题希望能熟练的掌握双指针的运用 文章目录167.两数之和II-输入有序数组（头尾指针）633.平方数之和（头尾指针）345.反转字符串中的元音字母（头尾指针）680.验证回文字符串Ⅱ（头尾指针）88.合并两个有序数组（异步指针）21.合并两个有序链表（异步指针）141.环形链表（快...
华为工程师总结的LeetCode刷题笔记提供下载，太优秀了
程序员小天
10-21 3851
前言： 最近又有不少老铁在后台留言说，想进大厂，但是算法不好。最近我整理了一份刷题实录，这份刷题实录，也让我进了心仪的大厂。现在开放分享给大家。希望对大家有所帮助。 任何的算法题，如同写作文一样，都有一些模板可以套用的。比如面试常考的DP（动态规划），难的是一些关键点是否能想清楚。比如你能写出动态转移方程，这题基本上就可以AC了。 整个刷题实录内容，包括 双子针、动态规划、二分查找、贪心算法、深度优先搜索、字符串、递归、字典树、排序、链表等相关专题内容。图文并茂，附有刷题答案源码。 第一部分必读系列： 学
leetcode高频题笔记之二叉树的递归
clonechen
03-27 401
文章目录普通二叉树104.二叉树的最大深度111.二叉树的最小深度110.平衡二叉树543.二叉树的直径（两节点最大路径）687.最长同值路径226.翻转二叉树101.对称二叉树617.合并二叉树112.路径总和437.路径总和III572.另一个树的子树404.左叶子之和337.打家劫舍III671.二叉树中第二小的节点BST669.修剪二叉搜索树230.二叉搜索树中第K小的元素538.把二叉搜...
Python世界：力扣29题两数相除算法实践
来知晓的博客
09-13 549
除法运算本质是减法，从理解原理到真正实现还是有距离，建议初步理解后，不参考任何代码，完全自己复现一遍，体会更深。注意提示：目的就是提醒越界问题：-2^31/-1=2&31，超过了整数表达范围。本问题来自于力扣29题，在做完大数相乘后，顺带也看下两数相除。将两数相除，要求不使用乘法、除法和 mod 运算符。给定两个整数，被除数。
C++速通LeetCode中等第3题-盛最多水的容器
最新发布
lyx的博客
09-18 240
双指针法：两个指针分别指向左右边界，记录最大面积，由于面积由短板决定，两个指针中较短的短指针向内移动一格，再次记录最大面积，直到两指针相遇，得出答案。
力扣 16.最接近的三数之和
qq_51352130的博客
09-16 334
设 s=nums[i]+nums[j]+nums[k]，为了判断 s 是不是与 target 最近的数，我们还需要用一个变量 minDiff 维护 ∣s−target∣ 的最小值。分类讨论：如果 s=target，那么答案就是 s，直接返回 s。如果 s>target，那么如果 s−target<minDiff，说明找到了一个与 target 更近的数，更新 minDiff 为 s−target，更新答案为 s。然后和三数之和一样，把 k 减一。
【JavaScript】LeetCode：707设计链表
weixin_45980065的博客
09-14 724
【代码】【JavaScript】LeetCode：707设计链表。
LeetCode链表算法刷题笔记：移除元素、设计链表、反转链表
本文是关于LeetCode中三道与链表相关的算法题目的刷题笔记，包括203.移除链表元素、707.设计链表和206.反转链表。主要讨论了解题思路和Java语言的解决方案。 ### 203. 移除链表元素 这道题目要求从链表中删除所有值...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值