Leetcode总结 链表专题

最新推荐文章于 2022-06-19 19:20:15 发布
最新推荐文章于 2022-06-19 19:20:15 发布
阅读量121 收藏 1
点赞数 1
分类专栏： LeetCode刷题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42549254/article/details/105200468
版权

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode* dummy = new ListNode(-1);
        ListNode* pre = dummy;
        int carry = 0;
        while(l1 || l2)
        {
            int res = carry;
            int a = l1 ? l1->val : 0;
            int b = l2 ? l2->val : 0;
            res += a + b;
            carry = res / 10;
            int t = res % 10;
            pre->next = new ListNode(t);
            pre = pre->next;
            if(l1) l1 = l1->next;
            if(l2) l2 = l2->next; 
        }
        if(carry) pre->next = new ListNode(1);
        return dummy->next;
    }
};

在这里插入图片描述

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

在这里插入图片描述

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

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        if(lists.size() == 0) return NULL;
        if(lists.size() == 1) return lists[0];
        if(lists.size() == 2) return mergeTwoLists(lists[0], lists[1]);
        int mid = lists.size() / 2;
        vector<ListNode*> sub1_lists;
        vector<ListNode*> sub2_lists;
        for(int i = 0; i < mid; i ++)        
            sub1_lists.push_back(lists[i]);        
        for(int i = mid; i < lists.size(); i ++)
            sub2_lists.push_back(lists[i]);
        ListNode* l1 = mergeKLists(sub1_lists);
        ListNode* l2 = mergeKLists(sub2_lists);
        return mergeTwoLists(l1, l2);
    }

    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2)
    {
        ListNode* dummy = new ListNode(-1);
        ListNode* head = dummy;
        while(l1 && l2)
        {
            if(l1->val <= l2->val)
            {
                head->next = l1;
                l1 = l1->next;
            }
            else
            {
                head->next = l2;
                l2 = l2->next;
            }
            head = head->next;
        }
        head->next = (l1 == NULL) ? l2 : l1;
        return dummy->next;
    }
};

在这里插入图片描述

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

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        ListNode* pre = NULL; //头
        ListNode* next = NULL; //尾
        ListNode* cur = head;
        ListNode* check = head; //检查链表长度够不够翻转
        int count = 0, len = 0;
        while(len < k && check)
        {
            check = check->next;
            len ++;
        }
        if(len == k)
        {
            while(count < k && cur)
            {
                next = cur->next;
                cur->next = pre;
                pre = cur;
                cur = next;
                count ++;
            }
            if(next)
                head->next = reverseKGroup(next, k);
            return pre;
        }
        else return head;
    }
};

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* rotateRight(ListNode* head, int k) {
        if(head == NULL) return head;
        ListNode* tail;
        ListNode*a = head;
        int n = 0;
        for(auto p = head; p; p = p->next)
        {
            n ++;
            tail = p;
        }
        k %= n;
        if(!k) return head;
        for(int i = 0; i < n - 1 - k; i ++) a = a->next;
        ListNode* next = a->next;
        tail->next = head;
        a->next = NULL;
        return next;
    }
};

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        ListNode*dummy = new ListNode(-1);
        dummy->next = head;
        ListNode*p = dummy;
        while(p->next)
        {
            ListNode* q = p->next;
            while(q && q->val == p->next->val)
                q = q->next;
            if(p->next->next == q) p = p->next;
            else p->next = q;
        }
        return dummy->next;
    }
};

在这里插入图片描述

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

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

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

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* partition(ListNode* head, int x) {
        ListNode* before = new ListNode(-1);
        ListNode* after = new ListNode(-1);
        ListNode* pb = before, *pa = after;
        for(ListNode* p = head; p; p = p->next)
        {
            if(p->val < x)
            {
                pb->next = p;
                pb = p;
            }
            else{
                pa->next = p;
                pa = p;
            }            
        }
        pb->next = after->next;
        pa->next = NULL;
        return before->next; 
    }
};

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseBetween(ListNode* head, int m, int n) {
        if(m == n) return head;
        if(!head) return 0;
        ListNode* dummy = new ListNode(-1);
        dummy->next = head;
        ListNode* a = dummy;
        for(int i = 0; i < m - 1; i ++) a = a->next;
        ListNode* b = a;
        b = b->next;
        ListNode* c = b->next;
        for(int i = 0; i < n - m; i ++)
        {
            ListNode* next = c->next;
            c->next = b;
            b = c;
            c = next;
        }
        ListNode* an = a->next;
        a->next = b;
        an->next = c;
        return dummy->next;
    }
};

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* sortedListToBST(ListNode* head) {
        if(!head) return 0;
        return dfs(head, 0);
    }

    TreeNode* dfs(ListNode* head, ListNode* tail)
    {
        if(head == tail) return 0;
        ListNode* slow = head;
        ListNode* fast = head;
        while(fast != tail && fast->next != tail)
        {
            slow = slow->next;
            fast = fast->next->next;
        }
        TreeNode* root = new TreeNode(slow->val);
        root->left = dfs(head, slow);
        root->right = dfs(slow->next, tail);
        return root;
    }
};

在这里插入图片描述

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* next;
    Node* random;
    
    Node(int _val) {
        val = _val;
        next = NULL;
        random = NULL;
    }
};
*/

class Solution {
public:
    Node* copyRandomList(Node* head) {
        if(!head) return head;
        Node* p = head, *tempP;
        while(p)
        {
            tempP = new Node(p->val, p->next, p->random);
            tempP->next = p->next;
            p->next = tempP;
            p = p->next->next;
        }
        p = head;
        while(p)
        {
            if(p->random)
            {
                p->next->random = p->random->next;
            }
            else p->next->random = NULL;
            p = p->next->next;
        }
        p = head;
        Node* copyHead = p->next;
        while(p)
        {
            tempP = p->next;
            p->next = p->next->next;
            if(tempP->next)
                tempP->next = tempP->next->next;
            p = p->next;
        }
        return copyHead;
    }
};

在这里插入图片描述

/**
 * 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) {
        if(!head || !head->next) return 0;
        ListNode* a = head, *b = head->next;
        while(a && b)
        {
            if(a == b) return true;
            a = a->next;
            b = b->next;
            if(b) b = b->next;
        }
        return false;
    }
};

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        if(!head) return head;
        ListNode* a = head, *b = head;
        while(a && b)
        {
            a = a->next;
            b = b->next;
            if(b) b = b->next;
            else return 0;
            if(a == b)
            {
                a = head;
                while(a != b)
                {
                    a = a->next;
                    b = b->next;
                }
                return b;
            }
        }
        return 0;
    }
};

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    void reorderList(ListNode* head) {
        if(!head) return;
        int n = 0;
        for(auto p = head; p; p = p->next) n ++;
        if(n <= 2) return;
        ListNode* mid = head;
        for(int i = 0; i < (n + 1) / 2 - 1; i ++) mid = mid->next;
        ListNode* a = mid->next;
        mid->next = NULL;
        ListNode* b = a->next;
        a->next = NULL;
        while(b)
        {
            ListNode* next = b->next;
            b->next = a;
            a = b;
            b = next;
        }
        b = head;
        while(a)
        {
            ListNode* next = a->next;
            a->next = b->next;
            b->next = a;
            a = next;
            b = b->next->next;
        }
    }
};

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* insertionSortList(ListNode* head) {
        ListNode *dummy = new ListNode(-1);
        while(head)
        {
            ListNode*p = dummy;
            while(p->next && p->next->val <= head->val) p = p->next;
            ListNode* next = head->next;
            head->next = p->next;
            p->next = head;
            head = next;
        }
        return dummy->next;
    }
};

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* sortList(ListNode* head) {
        return head == NULL ? NULL : mergeSort(head);
    }

    ListNode* mergeSort(ListNode* node)
    {
        if(!node->next) return node;
        ListNode* a = node, *b = node;
        ListNode* breakN = node;
        while(a && a->next)
        {
            a = a->next->next;
            breakN = b;
            b = b->next; //b为中点
        }
        breakN->next = NULL;
        ListNode*l = mergeSort(node);
        ListNode*r = mergeSort(b);
        return mergeTwoList(l, r);
    }

    ListNode* mergeTwoList(ListNode*l1, ListNode*l2)
    {
        ListNode*dummy = new ListNode(-1);
        ListNode*cur = dummy;
        while(l1 && l2)
        {
            if(l1->val <= l2->val)
            {
                cur->next = l1;
                l1 = l1->next;
            }
            else
            {
                cur->next = l2;
                l2 = l2->next;
            }
            cur = cur->next;
        }
        cur->next = (l1 == NULL ? l2 : l1);
        return dummy->next;
    }
};

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* a = headA, *b = headB;
        while(a != b)
        {
            if(!a) a = headB;
            else a = a->next;
            if(!b) b = headA;
            else b = b->next;
        } //如果不想交 走a + b 后都为NULL
        return a;
    }
};

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode *dummy = new ListNode(-1);
        dummy->next = head;
        for(ListNode *p = dummy; p; )
        {
            if(p->next && p->next->val == val)
                p->next = p->next->next;
            else
                p = p->next;
        }
        return dummy->next;
    }
};

在这里插入图片描述

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

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

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool isPalindrome(ListNode* head) {
        ListNode *fast = head, *slow = head, *pre = NULL;
        while(fast)
        {
            slow = slow->next;
            fast = fast->next ? fast->next->next : fast->next;
        }
        while(slow)
        {
            ListNode *next = slow->next;
            slow->next = pre;
            pre = slow;
            slow = next;
        }
        while(head && pre)
        {
            if(head->val != pre->val)
                return false;
            head = head->next;
            pre = pre->next;
        }
        return true;
    }
};

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    void deleteNode(ListNode* node) {
        node->val = node->next->val;
        node->next = node->next->next;
    }
};

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* oddEvenList(ListNode* head) {
        if(head == NULL || head->next == NULL)
            return head;
        ListNode *o = head;
        ListNode *e = head->next;
        ListNode *p = e;
        while(o->next && e->next)
        {
            o->next = e->next;
            o = o->next;
            e->next = o->next;
            e = e->next;
        }
        o->next = p;
        return head;
    }
};
WMXNLFD
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【LeetCode系列】【链表专题】
qq_36417014的博客
10-24 500
目录 专题二：链表 LeetCode 19 删除链表的倒数第N个节点 1、分析 2、 代码 LeetCode 237 删除链表中的节点 1、分析 2、代码 LeetCode 83 删除排序链表中的重复元素 1、分析 2、代码 LeetCode 61 旋转链表 1、分析 2、代码 LeetCode 24 两两交换链表中的节点 1、分析 2、代码 LeetCode 2...
【LeetCode 总结】Leetcode 题型分类总结、索引与常用接口函数
只能说希望每日一更
08-07 3134
文章目录零. Java 常用接口函数集合类数学类字符串一. 动态规划知识点题目二. 链表知识点题目三. 哈希表知识点题目四. 滑动窗口知识点题目五. 字符串知识点题目六. DFS、BFS知识点题目七. 二分法知识点题目八. 偏数学、过目不忘 and 原地算法等知识点题目 前言： 是时候开一个对于我的 LeetCode 专栏的总结索引了= = 虽然说大概只刷了150道左右，不过应该也可以简单总结一下了呢～ 题型主要是 LeetCode hot100 + 剑指Offer，也有其他的一些高频题 零. Java
Leetcode链表总结
wonner_的博客
04-07 2035
    由于最近开始面临保研找实习，所以打算刷波leetcode，之前一直想做这件事，巩固一下自己的基础，但总是被各种事情耽搁，由此写下这篇博客作为督促。在这期间偶然间看到同学的博客，他也打算刷leetcode，但刚做了一题就拿到了滴滴的offer，而且那一题跟我做的第一道题一样，让人感叹的巧合。希望我也能像他一样得到满意的结果。    本篇文章不会包含代码的讲解，只是做题目的一点思路心得，相关答...
【LeetCode】链表专题
Arthur的博客
06-19 162
LeetCode链表专题
leetcode求链表中点-algorithms:白板式编码问题及解决方案
07-06
leetcode求链表中点算法 编码问题和解决方案的说明。 对于这里列出的每个问题，您可以点击链接找到我的解决方案。 感谢 Leet code、Code Wars 和 Cracking the Coding Interview 提供的出色算法。 算法专题 树木 ...
leetcode:leetcode专题算法总结golang
03-20
时间复杂度：O（n），其中n是链表的长度。需要遍历链表一次。 空间复杂度：O（1）。 方法二：递归 func reverseList ( head * ListNode ) * ListNode { if head == nil || head . Next == nil { return head } ...
Facebook面试题
WMXNLFD的博客
06-13 877
LeetCode 125. Valid Palindrome 给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。 说明：本题中，我们将空字符串定义为有效的回文串。 示例 1: 输入: “A man, a plan, a canal: Panama” 输出: true 示例 2: 输入: “race a car” 输出: false class Solution { p...
模拟算法专题
WMXNLFD的博客
06-09 639
LeetCode 263. Ugly Number 编写一个程序判断给定的数是否为丑数。 丑数就是只包含质因数 2, 3, 5 的正整数。 示例 1: 输入: 6 输出: true 解释: 6 = 2 × 3 示例 2: 输入: 8 输出: true 解释: 8 = 2 × 2 × 2 示例 3: 输入: 14 输出: false 解释: 14 不是丑数，因为它包含了另外一个质因数 7。 说明： ...
从零开始的刷LeetCode生活 第17期 171-180
WMXNLFD的博客
01-17 478
class Solution { public: int titleToNumber(string s) { int num = 0; for(int i = 0; i < s.size(); i ++) { num = num * 26 + (s[i] - 'A' + 1); } ...
LeetCode(六)二分与单调队列_栈专题
WMXNLFD的博客
05-30 463
LeetCode 69. Sqrt(x) 实现 int sqrt(int x) 函数。 计算并返回 x 的平方根，其中 x 是非负整数。 由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。 示例 1: 输入: 4 输出: 2 示例 2: 输入: 8 输出: 2 说明: 8 的平方根是 2.82842…, 由于返回类型是整数，小数部分将被舍去。 class Solution { publi...
LeetCode(五)字符串处理专题
WMXNLFD的博客
05-29 400
LeetCode 38. Count and Say 报数序列是一个整数序列，按照其中的整数的顺序进行报数，得到下一个数。其前五项如下： 1. 1 2. 11 3. 21 4. 1211 5. 111221 1 被读作 “one 1” (“一个一”) , 即 11。 11 被读作 “two 1s” (“两个一”）, 即 21。 21 被读作 “one ...
Google面试题
WMXNLFD的博客
06-12 395
LeetCode 14. Longest Common Prefix 编写一个函数来查找字符串数组中的最长公共前缀。 如果不存在公共前缀，返回空字符串 “”。 示例 1: 输入: [“flower”,“flow”,“flight”] 输出: “fl” 示例 2: 输入: [“dog”,“racecar”,“car”] 输出: “” 解释: 输入不存在公共前缀。 说明: 所有输入只包含小写字母 a-...
LeetCode(八)动态规划专题(II)
WMXNLFD的博客
06-02 329
LeetCode 120. Triangle 给定一个三角形，找出自顶向下的最小路径和。每一步只能移动到下一行中相邻的结点上。 例如，给定三角形： [ [2], [3,4], [6,5,7], [4,1,8,3] ] 自顶向下的最小路径和为 11（即，2 + 3 + 5 + 1 = 11）。 说明： 如果你可以只使用 O(n) 的额外空间（n 为三角形的总行数）来解决这个问题，那么你的算法会很加分...
数学专题
WMXNLFD的博客
06-11 320
LeetCode 268. Missing Number 给定一个包含 0, 1, 2, …, n 中 n 个数的序列，找出 0 … n 中没有出现在序列中的那个数。 示例 1: 输入: [3,0,1] 输出: 2 示例 2: 输入: [9,6,4,2,3,5,7,0,1] 输出: 8 说明: 你的算法应具有线性时间复杂度。你能否仅使用额外常数空间来实现? class Solution { pub...
时间复杂度分析
WMXNLFD的博客
06-04 284
复杂度 O(n^2): 动态规划 DP 两重循环 O(nlogn): 排序 set map O(n): 哈希表 双指针扫描 数据范围： 十万->nlogn 1e^9->logn 一般ACM或者笔试题的时间限制是1秒或2秒。 在这种情况下，C++代码中的操作次数控制在 10^7为最佳。 下面给出在不同数据范围下，代码的时间复杂度和算法该如何选择： 1.n≤30, 指数级别, dfs+剪枝...
从零开始的刷LeetCode生活 第19期 191-200
WMXNLFD的博客
01-19 275
class Solution { public: int hammingWeight(uint32_t n) { int res = 0; for(int i = 0; i < 32; i ++) if(n >> i & 1) res ++; return ...
从零开始的刷LeetCode生活 第15期 151-160
WMXNLFD的博客
01-15 269
class Solution { public: string reverseWords(string s) { int k = 0; for(int i = 0; i < s.size(); ) { int j = i; while(j < s.size() &&...
贪心算法专题
WMXNLFD的博客
06-05 262
LeetCode 860. Lemonade Change 在柠檬水摊上，每一杯柠檬水的售价为 5 美元。 顾客排队购买你的产品，（按账单 bills 支付的顺序）一次购买一杯。 每位顾客只买一杯柠檬水，然后向你付 5 美元、10 美元或 20 美元。你必须给每个顾客正确找零，也就是说净交易是每位顾客向你支付 5 美元。 注意，一开始你手头没有任何零钱。 如果你能给每位顾客正确找零，返回 true...
【ML&DL学习】8 tf keras regression customized loss layers
WMXNLFD的博客
03-07 258
自定义损失函数 之前使用的损失函数 def customized_mse(y_true, y_pred): return tf.reduce_mean(tf.square(y_pred - y_true)) model = keras.models.Sequential([ keras.layers.Dense(30, activation='relu', ...
LeetCode链表专题：高效反转策略与递归解法
"LeetCode算法数据结构专训笔记，涵盖了链表、栈、递归等常见数据结构和算法，旨在提升编程能力与解决问题的技巧。笔记详细解释了如何使用不同方法，如头插法和栈，来解决链表反转问题，并通过递归深入理解反转逻辑...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值