leetcode刷题链表

最新推荐文章于 2024-05-31 13:35:03 发布
最新推荐文章于 2024-05-31 13:35:03 发布
阅读量636 收藏
点赞数 1
文章标签： 链表 leetcode 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51080234/article/details/124541340
版权

leetcode刷题链表

反转链表Ⅱ

  • 题目描述将一个节点数为 size 链表 m 位置到 n 位置之间的区间反转，要求时间复杂度 O(n)O(n)，空间复杂度 O(1)O(1)。例如：
    给出的链表为9->7->2->5->4->3->6->NULL , m=3,n=6,
    返回9->7->3->4->5->2->6 ->NULL

    ​ 要求：时间复杂度 O(n)O(n) ，空间复杂度 O(n)O(n)

    ​ 进阶：时间复杂度 O(n)O(n)，空间复杂度 O(1)O(1)

  • 解题方法：穿针引线法，在需要反转的区间里，每遍历到一个节点，让这个新节点来到反转部分的起始位置。

  • 使用三个指针变量 pre、curr、next 来记录反转的过程中需要的变量，它们的意义如下：

    ​ curr：指向待反转区域的第一个节点 left；
    ​ next：永远指向 curr 的下一个节点，循环过程中，curr 变化以后 next 会变化；
    ​ pre：永远指向待反转区域的第一个节点 left 的前一个节点，在循环过程中不变。

    class Solution {
public:
    ListNode *reverseBetween(ListNode *head, int left, int right) {
        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;
    }
};

复杂链表的复制

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

  • 解题方法一：回溯+哈希表

    class Solution {
public:
    unordered_map<Node*, Node*> cachedNode;
    Node* copyRandomList(Node* head) {
        if (head == nullptr) {
            return nullptr;
        }
        if (!cachedNode.count(head)) {
            Node* newHead = new Node(head->val);
            cachedNode[head] = newHead;
            headNew->next = copyRandomList(head->next);
            headNew->random = copyRandomList(head->random);
        }
        return cachedNode[head];
    }
};

  • 解题方法二：迭代 + 节点拆分，复制每一个节点并插入节点之后，每个复制节点的random 指针在前一节点random 指针的下一个指针。

    class Solution {
public:
    Node* copyRandomList(Node* head) {
        if (head == nullptr) {
            return nullptr;
        }
        for (Node* node = head; node != nullptr; node = node->next->next) {
            Node* nodeNew = new Node(node->val);
            nodeNew->next = node->next;
            node->next = nodeNew;
        }
        for (Node* node = head; node != nullptr; node = node->next->next) {
            Node* nodeNew = node->next;
            nodeNew->random = (node->random != nullptr) ? node->random->next : nullptr;
        }
        Node* headNew = head->next;
        for (Node* node = head; node != nullptr; node = node->next) {
            Node* nodeNew = node->next;
            node->next = node->next->next;
            nodeNew->next = (nodeNew->next != nullptr) ? nodeNew->next->next : nullptr;
        }
        return headNew;
    }
};

链表K个一组进行翻转

  • 题目描述：对于给定链表1->2->3->4->5，k=2，反转后返回2->1->4->3->5

  • 解题方法：把链表节点按照 k 个一组分组，所以可以使用一个指针 head 依次指向每组的头节点。这个指针每次向前移动 k 步，直至链表结尾。对于每个分组，我们先判断它的长度是否大于等于 k。若是，我们就翻转这部分链表，否则不需要翻转。

    class Solution {
public:
    // 翻转一个子链表，并且返回新的头与尾
    pair<ListNode*, ListNode*> reverseList(ListNode* head, ListNode* tail) {
        ListNode* prev = tail->next;
        ListNode* cur = head;
        while (prev != tail) {
            ListNode* nex = cur->next;
            cur->next = prev;
            prev = cur;
            cur= 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;   
            auto res = reverseList(head, tail);
            head = res.first;
            tail = res.second;      
            // 把子链表重新接回原链表
            pre->next = head;
            tail->next = nex;
            pre = tail;
            head = tail->next;
        }
        return hair->next;
    }
};

合并k个排序链表

  • 题目描述：合并 k 个升序的链表并将结果作为一个升序的链表返回其头节点。要求：时间复杂度 O(nlogk)

  • 解题方法一：分治法

    class Solution {
public:
     ListNode* mergeTwoLists(ListNode* pHead1, ListNode* pHead2) {
        if(pHead1==NULL) return pHead2;
        if(pHead2==NULL) return pHead1;
        ListNode*dummy= new ListNode(-1); 
        ListNode*temp=dummy;
        while(pHead1 && pHead2){
            if(pHead1->val>pHead2->val){
                temp->next=pHead2;
                pHead2=pHead2->next;
                
            }else{
                temp->next=pHead1;
                pHead1=pHead1->next;
            }
            temp=temp->next;
        }
        if(pHead1){
            temp->next=pHead1;
        }
        if(pHead2){
            temp->next=pHead2;
        }
        return dummy->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) {
        int n=lists.size();
        return merge(lists,0,n-1);
    }
};

  • 解题方法二：使用优先队列去存储所有链表。按照链表头结点值，进行从小到大的排序，最小的头结点的链表在堆顶。

    1. 每次将堆顶的链表取出
    2. 将头结点从取出的链表上去除，并插在所需目标链表的尾部。
    3. 将取出的链表放回堆中。若链表为null，则不放回。
      重复1，2，3过程，直到堆为空，循环终止。
class Solution {
public:
    struct Aux{
        int val;
        ListNode * ptr;
        bool operator <(const Aux& aux) const{
            return val>aux.val;
        }
    };
    priority_queue<Aux> myqueue;
    ListNode *mergeKLists(vector<ListNode *> &lists) {
        int n=lists.size();
        if(n==0) return NULL;
        if(n==1) return lists[0];    
        for(auto node:lists){
            if(node){
                Aux a={node->val,node};
            	myqueue.push(a);     
            }
        }
        ListNode*dummy=new ListNode(-1);
        ListNode * pre=dummy;
        while(!myqueue.empty()){
            Aux aux=myqueue.top();
            myqueue.pop();
            pre->next=aux.ptr;
            pre=pre->next;
            ListNode * nxt=aux.ptr->next;
            if(nxt==NULL) continue;
            myqueue.push({nxt->val,nxt});   
        }
        return dummy->next;
    }
};

删除链表的第N个节点

  • 题目描述：给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

  • 解题方法一：双指针

  • 解题方法二：栈先进后出，在遍历链表的同时将所有节点依次入栈。弹出栈的第 N个节点就是需要删除的节点，并且目前栈顶的节点就是待删除节点的前驱节点。

class Solution {
public: 
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode * dummy=new ListNode(-1);
        dummy->next=head;
        ListNode * cur=dummy;
        stack<ListNode*> stk;
        while(cur){
            stk.push(cur);
            cur=cur->next;
        }
        
        for(int i=0;i<n;++i){
            stk.pop();
        }
        ListNode * pre=stk.top();
        pre->next=pre->next->next;
        return dummy->next;
    }
};

两个链表的第一个公共节点

  • 题目描述：输入两个无环的单向链表L1，L2，找出它们的第一个公共结点，如果没有公共节点则返回空。

  • 解题方法：双指针。两个指针分别指向L1，L2，保证两指针走过的距离相等，当指针走到链表NULL节点（末尾节点的后继），令其等于另一个链表的头节点，直到两个指针相遇为止，如果有公共节点，两个指针将在此节点处相遇，如果没有则会在NULL相遇。

    class Solution {
public:
    ListNode* FindFirstCommonNode( ListNode* pHead1, ListNode* pHead2) {
        ListNode * p1=pHead1;
        ListNode * p2=pHead2;
        while(p1 != p2){
            p1=p1==NULL?pHead2:p1->next;
            p2=p2==NULL?pHead1:p2->next;
        }
        return p1;
    }
};

链表相加Ⅱ

  • 题目描述：假设链表中每一个节点的值都在 0 - 9 之间，那么链表整体就可以代表一个整数，头节点存放整数的高位。给定两个这种链表，请生成代表两个整数相加值的结果链表。例如：链表 1 为 9->3->7，链表 2 为 6->3，最后生成新的结果链表为 1->0->0->0。

  • 解题方法：整数相加由低位到高位，两个链表从末尾节点开始相加，方向与指针方向相反，考虑栈先进后出的特点，利用两个辅助栈，相加后用头插法构造新链表。

    class Solution {
public:
    ListNode* addInList(ListNode* head1, ListNode* head2) {
        // write code here
        
        stack<int> stk1;
        stack<int> stk2;
        while(head1){
            stk1.push(head1->val);
            head1=head1->next;
        }
        while(head2){
            stk2.push(head2->val);
            head2=head2->next;
        }
        int carry=0;
        ListNode * temp=NULL;
        while(!stk1.empty()||!stk2.empty()){
            int s1,s2;
            if(!stk1.empty()){
                s1=stk1.top();
                stk1.pop();
            }else{
                s1=0;
            }
            if(!stk2.empty()){
                s2=stk2.top();
                stk2.pop();
            }else{
                s2=0;
            }
            int sum=s1+s2+carry;
            ListNode* headNew=new ListNode(sum%10);
            carry=sum/10;
            headNew->next=temp;
            temp=head;
        }
        if(carry!=0){
            ListNode* headNew=new ListNode(carry);
            headNew->next=temp;
            temp=head;
        }
        return temp;
    }
};

单链表排序

  • 题目描述：给定一个节点数为n的无序单链表，对其按升序排序。数据范围：0 < <n≤100000；要求：时间复杂度*** O(nlogn)***

  • 解题方法一：自顶向下归并排序。

    1. 找到链表的中点，以中点为分界，将链表拆分成两个子链表。寻找链表的中点可以使用快慢指针的做法，快指针每次移动 2 步，慢指针每次移动 1 步，当快指针到达链表末尾时，慢指针指向的链表节点即为链表的中点。
    2. 对两个子链表分别排序。
    3. 将两个排序后的子链表合并，得到完整的排序后的链表。
    class Solution {
public:
    ListNode* merge(ListNode* head1, ListNode* head2) {
        ListNode* dummyHead = new ListNode(0);
        ListNode* temp = dummyHead;
        while (head1 != NULL && head2 != NULL) {
            if (head1->val <= head2->val) {
                temp->next = head1;
                head1 = head1->next;
            } else {
                temp->next = head2;
                head2 = head2->next;
            }
            temp = temp->next;
        }
        if (head1 != NULL) {
            temp->next = head1;
        } else if (head2 != NULL) {
            temp->next = head2;
        }
        return dummyHead->next;
    }

    ListNode * sortlist(ListNode*head,ListNode*tail){
        if(head==NULL){
            return head;
        }
        if(head->next==tail){  //当链表中只有两个元素时，断开指针并返回第一个元素
            head->next=NULL;
            return head;
        }
        ListNode*fast=head;
        ListNode*slow=head;
        while(fast!=tail){
            fast=fast->next;
            slow=slow->next;
            if(fast!=tail) fast=fast->next;
        }
        ListNode * mid=slow;
        return merge(sortlist(head,mid), sortlist(mid,tail));//左右两半递归均包含mid，当仅剩两个节点时丢弃第二个
    }
    ListNode* sortInList(ListNode* head) {
        return sortlist(head, NULL);
    }
};

  • 解题方法二：自底向上归并排序

    首先求得链表的长度 length，然后将链表拆分成子链表进行合并。具体做法如下。

    1. 用 subLength 表示每次需要排序的子链表的长度，初始时subLength=1。

    2. 每次将链表拆分成若干个长度为 subLength 的子链表（最后一个子链表的长度可以小于subLength），按照每两个子链表一组进行合并，合并后即可得到若干个长度为subLength×2 的有序子链表（最后一个子链表的长度可以小于 subLength×2）。合并两个子链表仍然使用合并两个有序链表的做法。

    3. 将subLength 的值加倍，重复第 2 步，对更长的有序子链表进行合并操作，直到有序子链表的长度大于或等于 length，整个链表排序完毕。

    class Solution {
public:
    ListNode* merge(ListNode* head1, ListNode* head2) {
        ListNode* dummyHead = new ListNode(0);
        ListNode* temp = dummyHead, *temp1 = head1, *temp2 = head2;
        while (temp1 != NULL && temp2 != NULL) {
            if (temp1->val <= temp2->val) {
                temp->next = temp1;
                temp1 = temp1->next;
            } else {
                temp->next = temp2;
                temp2 = temp2->next;
            }
            temp = temp->next;
        }
        if (temp1 != NULL) {
            temp->next = temp1;
        } else if (temp2 != NULL) {
            temp->next = temp2;
        }
        return dummyHead->next;
    }

    ListNode* sortInList(ListNode* head) {
        if(head == NULL || head->next == NULL)
            return head;
        int nodeNum=0;
        ListNode * temp1=head;
        while(temp1){
            nodeNum++;
            temp1=temp1->next;
        }
        ListNode*dummy=new ListNode(0);
        dummy->next=head;
        for(int sublength=1;sublength<nodeNum;sublength<<=1){
            ListNode*pre=dummy;
            ListNode*cur=dummy->next;  
            while(cur!=NULL){
                ListNode*head1=cur;
                for(int i=1;i<sublength&&cur->next != NULL;++i){
                     cur=cur->next;
                }
                ListNode*head2=cur->next;
                cur->next=NULL;
                cur=head2;
                for(int i=1;i<sublength&&cur!=NULL&&cur->next != NULL;++i){
                    cur=cur->next;
                }
                if(cur!=NULL){
                    nxt=cur->next;
                    cur->next=NULL;
                }
                ListNode* merged=merge(head1,head2);
                pre->next=merged;
                while(pre->next!=NULL){
                    pre=pre->next;
                }
                cur=nxt;
            }
            
        }
        return dummy->NULL;
    }
};

判断一个链表是否为回文结构

  • 题目描述：给定一个链表，请判断该链表是否为回文结构。回文是指该字符串正序逆序完全一致。

  • 解题方法一：将链表转化为数组

  • 解题方法二：快慢指针。初始化fast与slow指向头节点，fast移动速度是slow的两倍，fast到链表末尾时，slow到达中心位置；翻转后半部分的链表，与前半部分进行比较。

    class Solution {
public:
    ListNode* reservelist(ListNode*head){
        ListNode* pre=NULL;
        while(head){
            ListNode * nxt=head->next;
            head->next=pre;
            pre=head;
            head=nxt;
        }
        return pre;   
    }
    bool isPail(ListNode* head) {
        ListNode * fast=head,*slow=head;
        while(fast&& fast->next ){
            fast=fast->next->next;
            slow=slow->next;
        }
        if(fast!=NULL){         //当fast不为NULL时，链表节点个数为奇数，此时slow为中心节点
            slow=slow->next;
        }
        fast=head;              //fast重新指向头节点
        slow=reservelist(slow); //翻转后半链表
        while(slow){
            if(fast->val!=slow->val) return false;
            fast=fast->next;
            slow=slow->next;
        }
        return true;
    }
};

链表的奇偶重排

  • 题目描述：给定一个单链表，请设定一个函数，将链表的奇数位节点和偶数位节点分别放在一起，重排后输出。

    注意是节点的编号而非节点的数值。

  • 解题方法：双指针，第一个指针为奇数位，第二个指针位偶数位，奇数位在前，偶数位在后

    class Solution {
public:
    ListNode* oddEvenList(ListNode* head) {
        //如果链表为空，不用重排
        if(head == NULL) 
            return head;
        //even开头指向第二个节点，可能为空
        ListNode* even = head->next; 
        //odd开头指向第一个节点
        ListNode* odd = head; 
        //指向even开头
        ListNode* evenhead = even; 
        while(even != NULL && even->next != NULL){ 
            //odd连接even的后一个，即奇数位
            odd->next = even->next; 
            //odd进入后一个奇数位
            odd = odd->next; 
            //even连接后一个奇数的后一位，即偶数位
            even->next = odd->next; 
            //even进入后一个偶数位
            even = even->next; 
        } 
        //even整体接在odd后面
        odd->next = evenhead; 
        return head;
    }
};

删除链表中的重复元素Ⅰ

  • 题目描述：删除给出链表中的重复元素（链表中元素从小到大有序），使链表中的所有元素都只出现一次例如：给出的链表为1->1->2,返回1-> 2。

  • 解题方法：遇到连续相同的元素，保留第一个

  • class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        // write code here
        if(!head) return NULL;
        ListNode * cur=head;
        while(cur&&cur->next){
            ListNode *nxt=cur->next;
            if(cur->val==nxt->val){    //相邻元素相同，跳过下一位，之后的元素继续与上一位比较
                cur->next=nxt->next;
            }else{
                 cur=cur->next;        //相邻元素不同，正常遍历
            }
        }
        return head;
    }
};

删除链表中重复元素Ⅱ

  • 题目描述：给出一个升序排序的链表，删除链表中的所有重复出现的元素，只保留原链表中只出现一次的元素。给出的链表为1->1->1->2->3，返回2->3。
  • 解题方法：这是一个升序链表，重复的节点都连在一起，我们就可以很轻易地比较到重复的节点，然后将所有的连续相同的节点都跳过，连接不相同的第一个节点。注意添加一个虚拟的头节点，以便于删除第一个节点。
    1. 链表前加虚拟的头节点。
    2. 遍历链表，从虚拟节点的后继节点开始每次比较相邻两个节点，如果遇到了两个相邻节点相同，则新开内循环将这一段所有的相同都遍历过去。
    3. 在2中这一连串相同的节点前的节点直接连上后续第一个不相同值的节点。
    4. 返回时去掉添加的表头。
class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        if(!head) return NULL;
        ListNode * dummy=new ListNode(0);
        dummy->next=head;
        ListNode * cur=dummy;
        while(cur->next && cur->next->next){
            if(cur->next->val==cur->next->next->val){
                int num=cur->next->val;
                while(cur->next!=NULL&&cur->next->val==num){
                    cur->next=cur->next->next;
                }
            }else{
                cur=cur->next;
            }          
        }
        return dummy->next;
    }
};

返回时去掉添加的表头。

class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        if(!head) return NULL;
        ListNode * dummy=new ListNode(0);
        dummy->next=head;
        ListNode * cur=dummy;
        while(cur->next && cur->next->next){
            if(cur->next->val==cur->next->next->val){
                int num=cur->next->val;
                while(cur->next!=NULL&&cur->next->val==num){
                    cur->next=cur->next->next;
                }
            }else{
                cur=cur->next;
            }          
        }
        return dummy->next;
    }
};
Bug修复机
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Leetcode刷题方法总结---链表全解
修行的凡人的博客
08-24 1004
Leetcode刷题方法总结---链表全解
LeetCode刷题攻略
Redemption___的博客
06-13 6442
应届生面试算法就考个数组 链表 二叉树 矩阵 数组变着法子考你排序 查询 指针 位运算 链表变着法子考你指针 最多再考个哈希 二叉树变着法子考用递归和栈前中后遍历 最多加上回溯 矩阵的话就是知道起点的路径查询和不知道起点的路径查询 掌握了这些 面大厂就比较轻松了 其实和学历技术关系也不大 大部分人先死到想都不敢想上了。 据了解，LeetCode 是一个非常棒的 OJ（Online Judge）平台，收集了许多公司的面试题目。相对其他 OJ 平台而言，有着下面的几个优点： 题目全部来自业内大公司的真.
关于leetcode刷题详细介绍
热门推荐
智者之家
10-01 8万+
  虽然刷题一直饱受诟病，不过不可否认刷题确实能锻炼我们的编程能力，相信每个认真刷题的人都会有体会。现在提供在线编程评测的平台有很多，比较有名的有 hihocoder，LintCode，以及这里我们关注的 LeetCode。 LeetCode收录了许多互联网公司的算法题目，被称为刷题神器，我虽然早有耳闻，不过却一直没有上面玩过。   据了解，LeetCode 是一个非常棒的 OJ（Online J...
Leetcode刷题——链表
weixin_47156261的博客
01-14 397
Leetcode刷题-链表一、链表定义一、Leetcode题目1.移除链表元素 一、链表定义 c++链表节点定义方式： // 单链表 struct ListNode { int val; // 节点上存储的元素 ListNode *next; // 指向下一个节点的指针 ListNode(int x) : val(x), next(NULL) {} // 节点的构造函数 }; 自己定义构造函数初始化节点： ListNode *head=new ListNode(5) 使用默
leetcode 刷题指南 & 刷题顺序
qijingpei的博客
07-01 5191
leetcode 刷题指南
LeetCode 刷题之链表【Python实现】
hj1993的博客
02-16 315
将两个升序链表合并为一个新的链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。题解：哨兵节点的作用是方便得到最后的链表，即一个虚拟的头节点参考：https://blog.csdn.net/weixin_43466639/article/details/124000412。
leetcode刷题方法&路径
weixin_44163570的博客
05-28 598
一开始刷题的时候不能够随便找个题就来做，应该一段时间专门突击某个专题，如“链表”、“二叉树”等。在刷题的过程中应该自己首先想一想，不要一没有思路就去网上找（这样刷题没有效果），自己思考半天试了一试还是做不出来就去百度。做过的题应该做笔记，反复看就跟高中做题一样，有错题本，反复看才有效果。
leetcode刷题之反转链表
Event_Key的博客
01-16 300
抽象上述行为：从头结点循环将当前结点定义为：cur；反转后被指向的结点定为：pre，初始设为NULL，之后跟着cur改变；需要保存的结点定为临时结点：tmp。这个题目其实挺简单的，为了节省内存空间不创建新的链表，在原链表内通过改变指向关系达到反转的目的。如上图所示，结点1原本指向2，反转后指向NULL，但是在进行翻转操作前需要保存结点2；将上述的步骤循环，循环结束的标志是当前结点为NULL时，此时pre为头结点。同理，结点2，反转后指向结点1，并且反转前需要保存结点3；
LeetCode刷题指南
qq_63215420的博客
07-10 1720
你是否在刷LeetCode的时候不知道怎么正确的提交代码？不管怎样提交都不对，可是在自己的编译器上却是能运行成功并且答案正确，又或是你不知道刷题顺序，一来就倒在了第一题两数之和面前了。看来你和最初的我一样，也遇到了这样的问题，那么可以看看我的这篇文章能否帮助到你，有什么不对的地方敬请大家批评改正。
LeetCode刷题模板.pdf
04-05
1.4. LeetCode中二分查找题目 29 2. 双指针 30 2.1. 快慢指针 31 2.1.1. 什么是快慢指针 31 2.1.2. 快慢指针模板 31 2.1.3. 快慢指针相关题目 32 2.1.3.1. LC-141:链表是否有环 32 2.1.3.2. LC-142:环形链表入口 34 ...
LeetCode刷题手册
01-16
《LeetCode刷题手册》可能是一本指导如何有效刷题和提升算法编程能力的书籍。以下是可能包含在这本书中的主题： LeetCode介绍： 对LeetCode平台的简要介绍，包括网站功能、题目分类和评估系统。 算法基础： 提供...
leetcode:leetcode刷题记录与总结
04-05
leetcode刷题记录与总结 斑点与矩阵 详细说明 双指针 快慢指针 左右指针 二分查找 滑动窗口 初步和 分治 排序 链表 链表摘要批量操作 单年度查找/操作 树 二叉树前，后，层序等 二叉搜索树中序遍历，二分法等 字典树...
leetcode-python:leetcode刷题记录
04-12
排序类 ，引申：自然数组排序 重载python sort规则 查找类 （利用部分信息）二分查找，(利用所有... 链表中倒数第k个节点 链表双指针 剑指Offer 24. 反转链表 链表指针 剑指Offer 54. 二叉搜索树的第k大节点 二叉搜
LeetCode:LeetCode 刷题笔记(C++, Python 实现)
04-12
LeetCode刷题笔记 ＃ 标题 标签 1个 两次总和 哈希表 2个 加两个数字 链表 3 最长子串，无重复字符 细绳 4 两个排序数组的中位数 大批 5 最长回文子串 细绳 6 之字形转换 细绳 7 反整数 数学 8 字符串到整数 ...
代码随想录训练营Day56：Leetcode647、516
最新发布
maybeyaluokenai的博客
05-31 137
Leetcode647、516
159.二叉树：二叉树的层平均值（力扣）
weixin_63779802的博客
05-31 129
代码同样使用了广度优先搜索（BFS）的方法。主要思路是使用一个队列来进行层次遍历，在每一层遍历的时候，计算所有节点的值的总和以及节点的数量，然后用总和除以节点数量得到平均值。这个算法的时间复杂度是 O(n)，因为每个节点都会被访问一次，其中 n 是树中节点的数量。空间复杂度也是 O(n)，因为需要存储整个树的节点。代码是解决“二叉树的层平均值”问题的C++代码，这个问题要求计算二叉树中每一层的节点值的平均值，并返回一个包含这些平均值的列表。
Golang | Leetcode Golang题解之第122题买卖股票的最佳时机II
weixin_66442839的博客
05-31 202
Golang | Leetcode Golang题解之第122题买卖股票的最佳时机II
两数之和-力扣
why_12134的博客
05-28 262
另一种方法是使用哈希表来实现，使用一个map记录每个元素出现的下标，这样遍历到一个元素，只需向map查询是否存在 target - nums[i] 是否存在即可，从而减少了一个for循环，打打降低了时间复杂度。
leetcode刷题顺序
07-27
根据引用\[1\]和引用\[2\]的内容，推荐的LeetCode刷题顺序是按照题目类型刷题，优先选择树、链表、二分查找、DFS、BFS、动态规划等常见类型的题目。可以先做2~4道简单题，然后再做中等难度的题目。在选择题目时，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值