Leetcode刷题笔记之 链表

最新推荐文章于 2023-02-08 14:11:14 发布
最新推荐文章于 2023-02-08 14:11:14 发布
阅读量184 收藏 3
点赞数
分类专栏： leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43540151/article/details/119190089
版权
206. 反转链表

难度简单1546

反转一个单链表。

示例:

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

进阶:
你可以迭代或递归地反转链表。你能否用两种方法解决这道题？

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head==nullptr||head->next==nullptr) return head;
        ListNode* pre=nullptr;//注意pre需要初始化为空
        ListNode* cur=head;

        while(cur!=nullptr){
            ListNode* next = cur->next;
            cur->next = pre;
            pre = cur;
            cur = next;
        }
        return pre;
    }
};
92. 反转链表 II

难度中等692

反转从位置 m 到 n 的链表。请使用一趟扫描完成反转。

说明:
1 ≤ m ≤ n ≤ 链表长度。

示例:

输入: 1->2->3->4->5->NULL, m = 2, n = 4
输出: 1->4->3->2->5->NULL

class Solution {
public:
    ListNode* reverseBetween(ListNode* head, int m, int n) {
        ListNode* DumyHead = new ListNode(0);
        DumyHead->next = head;
        ListNode* pre=DumyHead,*cur=head;
        for(int i=0;i<m-1;i++){
            pre = cur;
            cur = cur->next;
        }
        ListNode* beforeReverse = pre;
        pre= pre->next;
        cur = cur->next;
        for(int i=0;i<n-m;i++){
            ListNode* temp;
            pre->next = cur->next;
            cur->next = beforeReverse->next;
            beforeReverse->next = cur;
            cur= pre->next;
        }
        return DumyHead->next;
    }
};
24. 两两交换链表中的节点

难度中等837

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。

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

示例 1：

img

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

示例 2：

输入：head = []
输出：[]

示例 3：

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

提示：

  • 链表中节点的数目在范围 [0, 100] 内
  • 0 <= Node.val <= 100
class Solution {
public:
    ListNode* swapPairs(ListNode* head) {       
        ListNode* cur = head;
        ListNode* next;
        ListNode* Head = new ListNode(0);
        ListNode* pre=Head;
        Head->next = head;
        
        while(cur!= nullptr && cur->next!=nullptr){
            next  = cur->next;
            cur->next = next->next;
            next->next = cur;
            pre->next = next; 
            pre = cur;
            cur = cur->next;
        }
        return Head->next;
    }
};
328. 奇偶链表

难度中等386

给定一个单链表，把所有的奇数节点和偶数节点分别排在一起。请注意，这里的奇数节点和偶数节点指的是节点编号的奇偶性，而不是节点的值的奇偶性。

请尝试使用原地算法完成。你的算法的空间复杂度应为 O(1)，时间复杂度应为 O(nodes)，nodes 为节点总数。

示例 1:

输入: 1->2->3->4->5->NULL
输出: 1->3->5->2->4->NULL

示例 2:

输入: 2->1->3->5->6->4->7->NULL 
输出: 2->3->6->7->1->5->4->NULL

说明:

  • 应当保持奇数节点和偶数节点的相对顺序。
  • 链表的第一个节点视为奇数节点，第二个节点视为偶数节点，以此类推。
class Solution {
public:
    ListNode* oddEvenList(ListNode* head) {
        if(head==nullptr||head->next==nullptr) return head;
        ListNode* odd = head ;
        ListNode* even = head->next;
        ListNode* cur = even->next;
        ListNode* next;
        ListNode DummyHead;
        DummyHead.next = head;
        bool oddFlag = true;

        while(cur!= nullptr){
            if(oddFlag){
                next = cur->next;

                cur->next = odd->next;
                even->next = next;
                odd->next = cur;
                odd = odd->next;
                cur=next;
            }
            else{
                even = cur;
                cur = cur->next;
            }
            oddFlag=!oddFlag;
        }
        return DummyHead.next; 
    }
};
237. 删除链表中的节点

难度简单849

请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点。传入函数的唯一参数为 要被删除的节点 。

现有一个链表 – head = [4,5,1,9]，它可以表示为:

img

示例 1：

输入：head = [4,5,1,9], node = 5
输出：[4,1,9]
解释：给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9.

示例 2：

输入：head = [4,5,1,9], node = 1
输出：[4,5,9]
解释：给定你链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9.

提示：

  • 链表至少包含两个节点。
  • 链表中所有节点的值都是唯一的。
  • 给定的节点为非末尾节点并且一定是链表中的一个有效节点。
  • 不要从你的函数中返回任何结果。
class Solution {
public:
    void deleteNode(ListNode* node) {
        node->val = node->next->val;
        node->next = node->next->next;
        
    }
};
19. 删除链表的倒数第 N 个结点

难度中等1248

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

**进阶：**你能尝试使用一趟扫描实现吗？

示例 1：

img

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

示例 2：

输入：head = [1], n = 1
输出：[]

示例 3：

输入：head = [1,2], n = 1
输出：[1]

提示：

  • 链表中结点的数目为 sz
  • 1 <= sz <= 30
  • 0 <= Node.val <= 100
  • 1 <= n <= sz
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        //if(head->next==nullptr)return nullptr;
        ListNode* DummyHead = new ListNode(0);
        DummyHead->next = head;
        ListNode* Ahead = head;
        ListNode* cur = DummyHead;
        for(int i=0;i<n;i++){
            Ahead = Ahead->next;
        }
        while(Ahead!=nullptr){
            Ahead =Ahead->next;
            cur = cur->next;
        }
        cur->next = cur->next->next;
        return DummyHead->next;
    }
};
21. 合并两个有序链表

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例：

输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4

ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        ListNode* l3 = new ListNode(INT_MIN);
        ListNode* res = l3;        
        while(l1!=nullptr&&l2!=nullptr){//注意是l1!=nullptr，而不是l1->next!=nullptr;
            if(l1->val>=l2->val){
                l3->next = l2;
                l2 = l2->next;
            }
            else{
                l3->next = l1;
                l1= l1->next;
            }
            l3=l3->next;
        }
        l3->next = l1!=nullptr? l1 : l2;//注意是l1!=nullptr，而不是l1->next!=nullptr;
        return res->next;
    }
141. 环形链表

难度简单818收藏分享切换为英文接收动态反馈

给定一个链表，判断链表中是否有环。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

如果链表中存在环，则返回 true 。 否则，返回 false 。

进阶：

你能用 O(1)（即，常量）内存解决此问题吗？

示例 1：

img

输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：

img

输入：head = [1,2], pos = 0
输出：true
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

img

输入：head = [1], pos = -1
输出：false
解释：链表中没有环。

class Solution {
public:
    bool hasCycle(ListNode *head) {

        if(head==nullptr|| head->next==nullptr){
            return false;
        }       
         ListNode * fast = head;
         ListNode * slow = head;
         while(fast->next!= nullptr&&fast->next->next!= nullptr){
             fast = fast->next->next;
             slow = slow->next;
             if( fast == slow) 
             return true;
         }
         return false;
    }
};
160. 相交链表

难度简单877收藏分享切换为英文接收动态反馈

编写一个程序，找到两个单链表相交的起始节点。

如下面的两个链表**：**

img

在节点 c1 开始相交。

示例 1：

img

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Reference of the node with value = 8
输入解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

示例 2：

img

输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Reference of the node with value = 2
输入解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。

示例 3：

img

输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null
输入解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
解释：这两个链表不相交，因此返回 null。

注意：

  • 如果两个链表没有交点，返回 null.
  • 在返回结果后，两个链表仍须保持原有的结构。
  • 可假定整个链表结构中没有循环。
  • 程序尽量满足 O(n) 时间复杂度，且仅用 O(1) 内存。
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* head1 = headA;
        ListNode* head2 = headB;
        while(head1!= head2){
            head1 = head1==nullptr? headB : head1->next;
            head2 = head2==nullptr? headA : head2->next;
        }
        return head1;
    }

一种比较巧妙的方式是，分别为链表A和链表B设置指针A和指针B，然后开始遍历链表，如果遍历完当前链表，则将指针指向另外一个链表的头部继续遍历，直至两个指针相遇。
最终两个指针分别走过的路径为：
指针A :a+c+b
指针B :b+c+a
明显 a+c+b = b+c+a,因而如果两个链表相交，则指针A和指针B必定在相交结点相遇。

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

难度简单72收藏分享切换为英文接收动态反馈

输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。

示例 1：

输入：head = [1,3,2]
输出：[2,3,1]

vector<int> reversePrint(ListNode* head) {
       if(head==nullptr)
       return * new vector<int> ;

        ListNode* Head = head;

        int count=1;
        while(head->next != nullptr){
           count ++;
           head = head->next;
        }
        vector<int> res(count);
        head = Head;
        for(int i= count-1;i>=0;i--){
            res[i] = head->val;
            head = head->next;
        }
        return res;

}

c++

234. 回文链表

难度简单915

请判断一个链表是否为回文链表。

示例 1:

输入: 1->2
输出: false

示例 2:

输入: 1->2->2->1
输出: true

进阶：
你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？

class Solution {
public:
    bool isPalindrome(ListNode* head) {
        ListNode * fast = head;
        ListNode * slow = head;
        //快慢指针判断中间位置
        while(fast->next!=nullptr){          
            if(fast->next->next==nullptr){
                fast = fast->next;
                break;
            }
            else
            fast = fast->next->next;
            slow = slow->next;
        }
        //翻转后半段链表
        if(slow->next!=nullptr && slow->next->next!=nullptr){
            ListNode * pre = slow->next;
            ListNode * cur = slow->next->next;
            while(cur!=nullptr){ 
                pre->next = cur->next;           
                cur->next = slow->next;
                slow->next = cur;
                cur = pre->next;
            }
        }
        //判断后半段翻转后是否与前半段相同
        ListNode * first = head;
        ListNode * second = slow->next;

        while(second!=nullptr){
            if(first->val != second->val){
                return false;
            }
            first = first->next;
            second = second->next;
        }
        return true;
    }
};
143. 重排链表

难度中等555

给定一个单链表 L：L0→L1→…→L**n-1→Ln ，
将其重新排列后变为： L0→L**n→L1→L**n-1→L2→L**n-2→…

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

示例 1:

给定链表 1->2->3->4, 重新排列为 1->4->2->3.

示例 2:

给定链表 1->2->3->4->5, 重新排列为 1->5->2->4->3.

class Solution {
public:
    void reorderList(ListNode* head) {
        ListNode *dummyHead = new ListNode(0,head);
        ListNode * fast= dummyHead;
        ListNode * slow = dummyHead;
        while(fast!=nullptr && fast->next!=nullptr){
            slow = slow->next;
            fast = fast->next->next;
        }

        ListNode * cur = slow->next;
        slow->next = nullptr; //注意：这里将前后两个链表拆开，便于后续的翻转和重排操作
        ListNode * pre = nullptr;

        while(cur!=nullptr){
            ListNode * next = cur->next;
            cur->next = pre;
            pre = cur;
            cur = next;
        }
      
        ListNode * reorder=head;
        while(pre!= nullptr){
            ListNode * backNext = pre->next;
            ListNode * frontNext = reorder->next;
            reorder->next = pre;
            pre->next = frontNext;
            pre = backNext;
            reorder = frontNext;
        }
        return ;
    }
};
142. 环形链表 II

难度中等943

给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意，pos 仅仅是用于标识环的情况，并不会作为参数传递到函数中。

**说明：**不允许修改给定的链表。

进阶：

  • 你是否可以使用 O(1) 空间解决此题？

示例 1：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZFJfXMwF-1627477446687)(链表.assets/image-20210406225450566.png)]

输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BYkl4cYY-1627477446688)(链表.assets/image-20210406001140968.png)]

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode * fast = head;
        ListNode * slow = head;

        while(true){
            if(fast==nullptr||fast->next==nullptr)
            return nullptr;
            slow = slow->next;
            fast = fast->next->next;
            if(slow==fast)break;
        }
        fast= head;
        while(fast!=slow){
            slow = slow->next;
            fast = fast->next;
        }
        return fast;
    }
};
83. 删除排序链表中的重复元素

难度简单553

存在一个按升序排列的链表，给你这个链表的头节点 head ，请你删除所有重复的元素，使每个元素 只出现一次 。

返回同样按升序排列的结果链表。

示例 1：

img

输入：head = [1,1,2]
输出：[1,2]

示例 2：

img

输入：head = [1,1,2,3,3]
输出：[1,2,3]

提示：

  • 链表中节点数目在范围 [0, 300] 内
  • -100 <= Node.val <= 100
  • 题目数据保证链表已经按升序排列
class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        if(head==nullptr) return head;
        ListNode * pre = head;
        ListNode * cur = head->next;
        while(cur!=nullptr){
            if(cur->val == pre->val){
                pre->next = cur->next;
                cur = cur->next;
            }
            else{
                cur = cur->next;
                pre = pre->next;
            }
        }
        return head;
    }
};
203. 移除链表元素

难度简单563

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

示例 1：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MwIBlLl1-1627477446690)(%E9%93%BE%E8%A1%A8.assets/removelinked-list.jpg)]

输入：head = [1,2,6,3,4,5,6], val = 6
输出：[1,2,3,4,5]

示例 2：

输入：head = [], val = 1
输出：[]

示例 3：

输入：head = [7,7,7,7], val = 7
输出：[]

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        if(head==nullptr) return head;
        ListNode * dummyHead = new ListNode(-1,head);
        ListNode * pre = dummyHead;
        ListNode * cur = head;

        while(cur!= nullptr){
            if(cur->val == val){
                pre->next = cur->next;
                cur = cur->next;
            }
            else{
                pre = cur;
                cur=cur->next;
            }
        }
        return dummyHead->next;
    }
};
82. 删除排序链表中的重复元素 II

难度中等597

存在一个按升序排列的链表，给你这个链表的头节点 head ，请你删除链表中所有存在数字重复情况的节点，只保留原始链表中 没有重复出现 的数字。

返回同样按升序排列的结果链表。

示例 1：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LwWfCb0n-1627477446690)(%E9%93%BE%E8%A1%A8.assets/linkedlist1.jpg)]

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

示例 2：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QEcwUBuR-1627477446691)(%E9%93%BE%E8%A1%A8.assets/linkedlist2.jpg)]

输入：head = [1,1,1,2,3]
输出：[2,3]

提示：

  • 链表中节点数目在范围 [0, 300] 内
  • -100 <= Node.val <= 100
  • 题目数据保证链表已经按升序排列
class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        ListNode * dummyHead = new ListNode(-1, head);
        ListNode * pre = dummyHead;
        ListNode * cur = head;

        while(cur!=nullptr&& cur->next!=nullptr){
            ListNode * next = cur->next;
            if(cur->val == next->val){
                while(next!=nullptr && cur->val == next->val){
                    next = next->next;
                }
                pre->next = next;
                cur = next;
            }
            else{
                pre = cur;
                cur = next;
            }
        }
        return dummyHead->next;
    }
};
剑指 Offer 35. 复杂链表的复制

难度中等191

请实现 copyRandomList 函数，复制一个复杂链表。在复杂链表中，每个节点除了有一个 next 指针指向下一个节点，还有一个 random 指针指向链表中的任意节点或者 null。

示例 1：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bLZoiBhd-1627477446691)(%E9%93%BE%E8%A1%A8.assets/e1.png)]

输入：head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
输出：[[7,null],[13,0],[11,4],[10,2],[1,0]]

示例 2：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Kqt57kha-1627477446692)(%E9%93%BE%E8%A1%A8.assets/e2.png)]

输入：head = [[1,1],[2,1]]
输出：[[1,1],[2,1]]

示例 3：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WaZbqp1O-1627477446692)(%E9%93%BE%E8%A1%A8.assets/e3.png)]

输入：head = [[3,null],[3,0],[3,null]]
输出：[[3,null],[3,0],[3,null]]

示例 4：

输入：head = []
输出：[]
解释：给定的链表为空（空指针），因此返回 null。

提示：

  • -10000 <= Node.val <= 10000
  • Node.random 为空（null）或指向链表中的节点。
  • 节点数目不超过 1000 。
class Solution {
public:
    Node* copyRandomList(Node* head) {
        Node  * oldList = new Node(-1);
        oldList->next = head;
        Node * newListDummyhead = new Node(-1);
        Node * newList = newListDummyhead;
        unordered_map<Node* , Node*> nodeMap;
        nodeMap[nullptr] = nullptr;

        while(oldList!=nullptr){
            if(oldList->next==nullptr)
            newList->next = nullptr;
            else{
                newList->next = new Node(oldList->next->val);
            }
            oldList = oldList->next;
            newList = newList->next;
            nodeMap[oldList] = newList;
        }

        oldList = head;
        newList = newListDummyhead->next;

        while(oldList!=nullptr){
            newList->random = nodeMap[oldList->random];
            newList = newList->next;
            oldList = oldList->next;
        }
        return newListDummyhead->next;
    }
};

空（null）或指向链表中的节点。

  • 节点数目不超过 1000 。
class Solution {
public:
    Node* copyRandomList(Node* head) {
        Node  * oldList = new Node(-1);
        oldList->next = head;
        Node * newListDummyhead = new Node(-1);
        Node * newList = newListDummyhead;
        unordered_map<Node* , Node*> nodeMap;
        nodeMap[nullptr] = nullptr;

        while(oldList!=nullptr){
            if(oldList->next==nullptr)
            newList->next = nullptr;
            else{
                newList->next = new Node(oldList->next->val);
            }
            oldList = oldList->next;
            newList = newList->next;
            nodeMap[oldList] = newList;
        }

        oldList = head;
        newList = newListDummyhead->next;

        while(oldList!=nullptr){
            newList->random = nodeMap[oldList->random];
            newList = newList->next;
            oldList = oldList->next;
        }
        return newListDummyhead->next;
    }
};
喝可乐的阿晨
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法刷题 Leetcode 回溯算法
weixin_45781186的博客
03-09 119
Leetcode经典回溯题做题笔记
LeetCode-Python-24. 两两交换链表中的节点class Solution(object): def swapPairs(self, head): """
Keep Coding
06-03 2161
给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。 你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。 示例: 给定 1->2->3->4, 你应该返回 2->1->4->3. 思路： 链表问题上递归。 每次递归就只考虑交换第一个和第二个节点， basecase是如果只有0个或1个节点，那么不用交换，直接返回head， ...
Leetcode刷题：初级算法之树
qq_35574010的博客
03-22 241
目录题目二叉树的最大深度二叉树的层次遍历对称二叉树总结 题目 二叉树的最大深度 给定一个二叉树，找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 说明: 叶子节点是指没有子节点的节点。 示例： 给定二叉树 [3,9,20,null,null,15,7]， 返回它的最大深度 3 刚开始使用了广度优先的算法，虽然是work的，但是时间超出了限制。 更好的方法是使用递归，深度...
代码详解1——class Solution
qq_38120081的博客
03-11 1万+
刚开始学java ,java代码开头的几行都是什么意思?_Java_v_solution的博客-CSDN博客 https://blog.csdn.net/v_solution/article/details/79339161 为什么leetcode等OJ上Cpp的提交都以class solution而不是main函数作为入口? - 知乎 https://www.zhihu.com/que...
c++中的class solution意义及用法
m0_62869178的博客
02-08 7044
c++中class solution的意义及用法
LeetCode刷题笔记.rar
07-05
《LeetCode刷题笔记》是针对LeetCode这个在线编程挑战平台的个人学习心得与总结，主要涵盖数据结构和算法两大核心领域。LeetCode是一个全球知名的编程训练网站，它提供了丰富的编程题目，帮助开发者提升编程技能，...
LeetCode 刷题笔记 with Java.zip
11-23
《LeetCode刷题笔记withJava》是一份专为Java开发者准备的算法实战指南，涵盖了LeetCode网站上前一百道编程挑战题目。这份资料旨在帮助程序员提升算法能力，掌握数据结构和问题解决技巧，对于准备面试或者想要提升...
leetcode刷题笔记之JavaScript
最新发布
11-08
leetcode刷题笔记之JavaScript LeetCode刷题笔记之JavaScript知识分享 在本篇文章中，我们将讨论LeetCode中的二叉树、数组、链表、哈希表、栈、队列、图等数据结构和算法题目，并提供相应的JavaScript解决方案。 ...
LeetCode:LeetCode 刷题笔记(C++, Python 实现)
04-12
LeetCode刷题笔记 ＃ 标题 标签 1个 两次总和 哈希表 2个 加两个数字 链表 3 最长子串，无重复字符 细绳 4 两个排序数组的中位数 大批 5 最长回文子串 细绳 6 之字形转换 细绳 7 反整数 数学 8 字符串到整数 ...
谷歌和阿里大佬的Leetcode刷题笔记.zip
08-10
《谷歌和阿里大佬Leetcode刷题笔记》是一个珍贵的学习资源，专为提升算法能力和准备面试设计。LeetCode是一个在线平台，提供了大量的编程题目，旨在帮助程序员提升算法技能，特别是对于那些希望进入顶级科技公司如...
leetcode不会-LeetCodeSolution:我对LeetCode问题的个人解决方案
06-30
leetcode 不会 Most problem set in interviews are testing your basic knowledge. DO NOT underestimate the importance of basics. Problems about Array To begin with, a simple question: 283 To minimize space complexity to O(1), use an extra index k as pointer. Exercise: 27,26,80 Some classic problems: Quick sort with 3-way partition:75 Exercise: 88(Merge as in Merge Sort), 215 Two pointers: Collider pointer: 167,125,344,345,11 Sliding window: 209,3,438,(76-hard） 对比： 对撞指针： 使用前提：数组，有序。 终止条件：while(l < r)
leetcode算法题主函数如何写-leetcode:leetcode_solution
06-30
leetcode算法题主函数如何写 leetcode 1.Two Sum python中的hashmap用字典实现，可以用get方法获取key对应的value，用is not None判断是否在hashmap中. PS:用in/not in来判断是否在list中。list获取特定元素的索引：nums.index(item) 带索引的迭代： for idx, num in enumerate(nums): 3.Longest Substring Without Repeating Characters 滑动窗口。其实就是一个队列,比如例中的 abcabcbb，进入这个队列（窗口）为 abc 满足题目要求，当再进入 a，队列变成了 abca，这时候不满足要求。所以，滑动这个窗口！那滑到什么位置呢？右指针的位置不变，左指针滑一直到窗口内无重复的字符为止。 5.Longest Palindromic Substring 解决这类 “最优子结构” 问题，可以考虑使用 “动态规划”： 1、定义 “状态”； 2、找到 “状态转移方程”。 记号说明： 下文中，使用记号 s[l, r] 表示原始字符串的
双指针法（leetcode分类解题，C++代码详细注释）
qq_42896106的博客
03-07 845
双指针法前言 前言 双指针主要用于遍历数组，两个指针指向不同的元素，从而协同完成任务。也可以延伸到多个数组的多个指针。 若两个指针指向同一数组，遍历方向相同且不会相交，则也称为滑动窗口（两个指针包围的区域即为当前的窗口），经常用于区间搜索。 若两个指针指向同一数组，但是遍历方向相反，则可以用来进行搜索，待搜索的数组往往是排好序的。 对于 C++ 语言，指针还可以玩出很多新的花样。一些常见的关于指针的操作如下。 指针与常量 int x; int * p1 = &x; // 指针可以被修改，值也可以被修
Leetcode第一题：两数之和（3种语言）
热门推荐
三年研究生能改变多少
12-08 4万+
@](这里写自定义目录标题) Leetcode第一题：两数之和 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的 两个 整数。 你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。 示例: 给定 nums = [2, 7, 11, 15], target = 9 因为 nums[0] + nums1 = 2 + 7 = 9 所以返回 ...
关于第一次在LeetCode上刷题的一点心得
qq_38210187的博客
05-07 7364
虽然是计算机专业的学生，但是之前一直在忙着专业课的学习，没能够真正运用这些好的编程网站提升自己的算法能力，过去了两年的大学生活，在最后的一年时间里，希望自己在出去实习编程能力有所提高，所以今晚开始就决定在今后的日子里在编程网站上刷题，提高自己的能力，没想到第一次在上面刷题就遇到了瓶颈，很简单的一道题目，自己思路想对了，但是代码没能写对，然后在讨论里复制别人的代码过来运行也出现错误，然后一直在网上找...
leetcode上令人拍案叫绝的解法
ScutKevinYzy的博客
03-27 1567
作者：努力的摩羯 链接：https://www.zhihu.com/question/35485418/answer/63609637 来源：知乎 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 1. 279 Perfect Squares 【题意】给定一个数，求其最少能表示成几个完全平方数的和表示。 【思路】用动归解决。 【别人家的小孩】4ms C++
【LeetCode】参照LeetCode上的Solution总结：同类解法
zjajgyy的博客
06-25 779
LeetCode上看到的一类提醒的一种解法总结： A general approach to backtracking questions in Java (Subsets, Permutations, Combination Sum, Palindrome Partioning) 原作者是用Java实现的，这里我因为试验，把第一个改成了C++版。 虽然这种解法不见得效率很高，但是不失为在没有
LeetCode-Python-2. 两数相加class Solution(object): def addTwoNumbers(self, l1, l2): """
Keep Coding
05-30 1万+
给出两个非空的链表用来表示两个非负的整数。其中，它们各自的位数是按照逆序的方式存储的，并且它们的每个节点只能存储一位数字。 如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。 您可以假设除了数字 0 之外，这两个数都不会以 0开头。 示例： 输入：(2 -> 4 -> 3) + (5 -> 6 -> 4) 输出：7 -> 0 -...
LeetCode刷题笔记：JavaScript版深度与广度探索
"这篇资源是关于使用JavaScript解决LeetCode算法题目的刷题笔记，涵盖了二叉树、二分查找、双指针、滑动窗口、矩阵模拟、链表、哈希表、KMP算法、栈与单调栈、二叉树相关、二叉搜索树、回溯算法以及数组解构赋值等多...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值