LeetCode 刷题 -- Day 2

已于 2024-06-14 23:02:33 修改
阅读量2.1k 收藏 40
点赞数 58
分类专栏： LeetCode 文章标签： leetcode 算法 笔记 学习
于 2024-03-24 00:21:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_83694336/article/details/136978495
版权
本文介绍了多个LeetCode链表相关题目，包括移除指定元素、设计链表结构、反转链表、两两交换节点、删除倒数第N个节点、链表相交以及环形链表的判断，展示了解决这些问题的代码思路和优化技巧。
摘要由CSDN通过智能技术生成

今日题目

题目难度备注
203. 移除链表元素 - 力扣（LeetCode）简单没有头结点创造头结点
707. 设计链表 - 力扣（LeetCode）中等单链表知识查漏补缺处
206. 反转链表 - 力扣（LeetCode）简单
24. 两两交换链表中的节点 - 力扣（LeetCode）中等成就感 + 0.5 （思维欠缺一丢丢）
19. 删除链表的倒数第 N 个结点 - 力扣（LeetCode）中等成就感 + 1
面试题 02.07. 链表相交 - 力扣（LeetCode）简单有更好的方法
142. 环形链表 II - 力扣（LeetCode）中等♥♥♥

链表篇

题目：203. 移除链表元素

203. 移除链表元素 - 力扣（LeetCode）

一、源代码

 ListNode* removeElements(ListNode* head, int val) {
        ListNode* pre = new ListNode(0,head);   
        ListNode* p = pre;
        while(p->next != NULL){
            if(p->next->val == val){
                p->next = p->next->next;
            }else{
                p = p->next;
            }
        }
        return pre->next;
    }

二、代码思路

没有头结点就创造头结点，虚假头结点最好用 dummyHead 来定义，比 pre 有更好的可读性

题目：707. 设计链表

707. 设计链表 - 力扣（LeetCode）

一、源代码

private:
    struct ListNode{
        int val;
        ListNode* next;
        ListNode():val(0),next(NULL){}
        ListNode(int val):val(val),next(NULL){}
        ListNode(int val,ListNode* next):val(val),next(NULL){}
    };
    int len;
    ListNode* dummyhead; //链表虚拟头结点

public:
    MyLinkedList() {
        len = 0;
        dummyhead = new ListNode();
    }
    
    int get(int index) {
        if(index<0||index>len-1) return -1;
        ListNode* p = dummyhead->next;
        while(index--){
            p = p ->next;
        }
        return p->val;
    }
    
    void addAtHead(int val) {
        ListNode* p = new ListNode(val);
        p->next = dummyhead->next;
        dummyhead->next = p;
        len++;
    }
    
    void addAtTail(int val) {
        ListNode* p = new ListNode(val),*cur=dummyhead;
        while(cur->next) cur = cur->next;
        cur->next = p;
        len++;
    }
    
    void addAtIndex(int index, int val) {
        if(index<=0) addAtHead(val);
        else if(index==len) addAtTail(val);
        else{
            ListNode* p = new ListNode(val),*pre = dummyhead;
            while(index--) pre = pre->next;
            p->next = pre->next;
            pre->next = p;
            len++;
        }
    }
    
    void deleteAtIndex(int index) {
        if(index<0||index>len-1) return;
        ListNode* pre = dummyhead,*p = NULL;
        while(index--) pre = pre->next;
        p = pre->next;
        pre->next = p->next;
        delete p;
        len--;
    }
};

二、补充

    // 创建单链表
    ListNode *head = new ListNode,*p = head;
	for(int i=1;i<=n;i++){
		scanf("%d",&v);
		p->next = new ListNode(v);
		p = p->next;
	}

   //头插法
   p = q ->next;
   q->next = H->next;
   H->next = q;
   q = p;

   //尾插法
   ListNode *rear = H->next;
   while(){
    q = new ListNode(v);
    rear->next = q;
    rear = q;
   }
   rear->next = NULL;

题目：206. 反转链表

206. 反转链表 - 力扣（LeetCode）

ListNode* H = new ListNode(),*cur = head,*temp =NULL;
        while(cur!=NULL){
            temp = cur->next;
            cur->next = H->next;
            H->next = cur;
            cur = temp;
        }
        return H->next;

题目：24. 两两交换链表中的节点

24. 两两交换链表中的节点 - 力扣（LeetCode）

一、源代码

ListNode* swapPairs(ListNode* head) {
        if(head==NULL ||head->next==NULL) return head;
        ListNode *newHead = head->next,*q,*p = head;
        while(p->next!=NULL){
            q = p->next;        
            p->next = q->next;
            q->next = p;
            p = p->next;     
        }
        return newHead;

报错

Line 4: Char 18: runtime error: member access within null pointer of type 'ListNode' (solution.cpp)
SUMMARY: UndefinedBehaviorSanitizer: undefined-behavior prog_joined.cpp:25:18

二、错误原因

1、语法错误，类似数组越界

当 p == NULL 的时候，还会去访问 p->next；如当while循环中的最后一句，p = p ->next = NULL时，下一次循环开始会访问 p->next;

2、逻辑错误

只考虑两两交换每队链表，没考虑把链表连起来，这样虽然链表两两交换了，当在逻辑上却被拆成很多段了

解决方法：用pre指针搭桥，连接各端

三、修改

ListNode* swapPairs(ListNode* head) {
        if(head==NULL ||head->next==NULL) return head;
        ListNode *newHead = head->next,*q,*p = head,*pre = new ListNode(0,head);
        while(p->next!=NULL){
            q = p->next;     //p，q 实现每队两两交换
            p->next = q->next;
            q->next = p;
            pre->next = q;   //pre用于链接各队
            pre = p;
            p = p->next;
            if(p==NULL){
                break;
            }
        }
        return newHead;
    }

题目：19. 删除链表的倒数第 N 个结点

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

一、源代码

 ListNode* removeNthFromEnd(ListNode* head, int n) {
        if(head->next == NULL)      //长度为1，直接返回NULL
            return NULL;
        ListNode *p = head, *q = head->next;
        int cnt = 1;
        while(q->next!=NULL){  //p一次走一步，q一次走两步，这样q到终点时，只走了一半，原本遍历链表O(n)，现在O(n/2)
            cnt++;
            p = p->next;
            q = q->next->next;
            if(q==NULL){
                break;
            }
        }
        int len = (q==NULL)? cnt*2-1 :cnt*2;
        if(n < cnt){  //要删除的结点在p后面
             int k = len - cnt - n + 1;   //p要移动的次数
             ListNode *pre = p;
             while(k--){
                pre = p;
                p = p->next;
             }
             pre->next = p->next;
             delete p;
        }else{
            int k = len - n;
            ListNode *p = head,*pre = p;
            while(k--){
                pre = p;
                p = p->next;
            }
            if(n==len){   //删除表头
                return head->next;
            }
            pre->next = p->next;
             delete p;
        }
        return head;
    }

二、代码思路

1、若使用两趟扫描解决问题，固然简单，一趟得出链表长度，再把倒数第n个换算成正数第k个再扫描一次就行了

2、进阶难度是怎么仅使用一趟实现呢？想了很久，发现一种比两趟好一点的方法：用一趟是为了代码跑得快，那我定义两个指针 *fast 和 *slow，fast一次走两步，slow每次走一步，这样fast到底终点后，slow只走了一半。这样只用花一半的时间就能得到链表的长度len了，此时slow还在链表的中间，若 n < len 的话，slow 继续向前next，找到要删除的结点删除就行，这不就一趟实现了。若 n > len，那就把倒数第n 转换成 正数第k 个查找删除就行，最多也只用扫描半趟。

最后提交发现执行时间还是挺少的，但是代码肯定可以优化，写的太差了

tmp2EE6

三、代码优化

1、用 *fast 和 *slow 指针快速得到单链表长度，

源代码

        ListNode *p = head, *q = head->next;
        int cnt = 1;
        while(q->next!=NULL){ 
            cnt++;
            p = p->next;
            q = q->next->next;
            if(q==NULL){
                break;
            }
        }
        int len = (q==NULL)? cnt*2-1 :cnt*2;

修改代码

        ListNode *slow = head, *fast = head->next,;   //用fast、slow 更有可读性
        int cnt = 1;
        while(true){  
            if(fast==NULL || fast->next==NULL) break;  //把循环结束条件写一起好点
            cnt++;
            fast = fast->next->next;
            slow = slow->next;
        }
        int len = (fast == NULL)? cnt*2-1 : cnt*2;

2、代码能共用则 共用

源代码

        if(n < cnt){  //要删除的结点在p后面
             int k = len - cnt - n + 1;   //p要移动的次数
             ListNode *pre = p;
             while(k--){
                pre = p;
                p = p->next;
             }
             pre->next = p->next;
             delete p;
        }else{
            int k = len - n;
            p = head,*pre = p;
            while(k--){
                pre = p;
                p = p->next;
            }
            pre->next = p->next;
             delete p;
        }

修改代码

            if(n == len){   //删除表头
                return head->next;
            }
            if(n > cnt) p = head;
            int k = (n < cnt)? len-cnt-n+1 : len - n;
            ListNode *pre = p;
            while(k--){
                pre = p;
                p = p->next;
             }
             pre->next = p->next;
             delete p;

题目：面试题 02.07. 链表相交

面试题 02.07. 链表相交 - 力扣（LeetCode）

一、源代码

ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        int lenA = 0,lenB = 0;
        ListNode *pa = headA,*pb = headB;
        while(pa!=NULL){   //求长度
            lenA++;
            pa = pa->next;
        }
        while(pb!=NULL){
            lenB++;
            pb = pb->next;
        }
        pa = headA;
        pb = headB;
        if(lenA < lenB){      //右对齐
            int k = lenB - lenA;
            while(k--){
                pb = pb ->next;
            }
        }else{
            int k = lenA - lenB;
            while(k--){
                pa = pa ->next;
            }
        }
        while(pa){   //返回第一个相同结点
            if(pa ==pb){
                return pa;
            }else{
                pa = pa->next;
                pb = pb->next;
            }
        }
        return NULL;
    }

二、优化思路

因为是公共结点，即找到第一个相同结点就行，那就可以用vector这类的容器存储链表A中的结点，再从头遍历链表B，在容器中出现的第一个b结点就是答案。但是vector不能用 find() 方法，可以用无序容器unordered_set 来实现

三、优化代码

ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        unordered_set<ListNode *> visited;
        ListNode *temp = headA;
        while (temp != nullptr) {
            visited.insert(temp);
            temp = temp->next;
        }
        temp = headB;
        while (temp != nullptr) {
            if (visited.count(temp)) { //  count返回元素在集合中出现的次数
                return temp;
            }
            temp = temp->next;
        }
        return nullptr;
    }

题目：142. 环形链表 II

142. 环形链表 II - 力扣（LeetCode）

一、思维缺陷

知道用 *fast 和 *slow 指针来判断是否有环，但是不知道怎么找出环入口结点

其实就是数学问题，找关系

tmp8867

设链表共有a+b个结点，a是链表头部到环入口之间的结点数，b是环中的结点数

fast 走的步数是 slow 步数的 2 倍，即 f=2s ①
fast 比 slow 多走了 n 个环的长度，即 f=s+nb ②

所以 ① - ② 得 s = nb，f = 2nb；

再令fast 重新指向头部结点，此时 f = 0，s = nb
fast 和 slow 每轮各走一步
则 当 fast 走了 a 步时，f = a，s = nb + a，两者相遇，并同时指向链表入口

二、参考答案

ListNode *detectCycle(ListNode *head) {
        if(head==NULL || head->next==NULL) return NULL;
        int flag = 0;
        ListNode *fast = head, *slow = head;
        while(true){   //跑圈圈，q每次多走一步，有环必能追上
            if(fast==NULL || fast->next==NULL) return NULL;
            fast = fast->next->next;
            slow = slow->next;
            if(fast == slow) break;
        }
        fast = head;
        while(slow !=fast){
            slow = slow->next;
            fast = fast->next;
        }
        return fast;
    }
不要停止思考
关注
  • 58
    点赞
  • 踩
  • 40
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode卡-LeetCode-solution:LeetCode刷题打卡
07-06
LeetCode刷题打卡—监督自己！不懂的代码Debug一遍 Day1: 2021年5月31日 Day2: 2021年6月1日 Day3: 2021年6月2日 Day4: 2021年6月3日 Day5: 2021年6月4日 Day6: 2021年6月5日 Day7: 2021年6月6日 Day8: 2021年6月7日...
Leetcode扑克-LeetCodeJava:leetcode刷题java
06-30
Leetcode扑克 LeetCodeJava LeetCode部分习题Java版，包括多种解法，时间复杂度和空间复杂度自行分析。 Day01 逆波兰表达式求值 Day02 合并两个有序链表 Day03 合并K个排序链表 Day04 验证二叉搜索树 Day05 二叉树中...
LeetCode 刷题 -- Day 3
2401_83694336的博客
03-28 2293
因为使用 sort() 后，nums1 和nums2 中元素都从小到大排列，所以用双指针遍历时 push_back到 ans 的数也是按从小到大的顺序，即下一个要 push_back 到 ans 的数，要么比ans中所有的数都大，要么等于ans.back()。所以值不会越来越大的，那就只有 ①、② 两种情况，那这题就简单了，循环计算各个位置平方和，若得到的值出现过，则说明进入循环了，break；所以这题其实不是用哈希表法，而是用动态规划的知识，动态规划以后再来探讨吧，先学基础的。
LeetCode 刷题 -- Day 6
2401_83694336的博客
04-24 1065
在遍历队列的过程中，利用while(q.size()–) 实现遍历每一层，将遍历的元素出队，并将下一层压入队列，最后就得到了各层结点值了。在遍历队列的过程中，利用while(q.size()–) 实现遍历每一层，将遍历的元素出队，并将下一层压入队列，最后就得到了各层结点值了。DFS 遍历树，且每下一层高度 h+1，当访问到叶子结点时，就得出了一条从根节点到最近叶子结点的路径长度了（为当前h+1），记录最小的路径长度即为答案。② root 不为空，则找它的左右孩子的高度，并返回较大的高度 h。
LeetCode 刷题 -- Day 8
2401_83694336的博客
04-26 1099
​ 先序遍历树，利用 mostDeepHight 记录遍历过程中遇到的最大深度，mostDeepVal 记录遍历过程中遇到的最大深度的结点值。这样可得到最底层的结点。​ 而利用先序遍历，先访问当前结点的左子树，再访问右子树，再加上 叶子结点的深度大于mostDeepHight 才更新（并非大于等于）这样就保证了对同一层结点，只记录最左边的结点值，即为答案。​ ② 中序序列以 x 为中心，x 左侧的元素为 x 的左子树， x 右侧的元素为 x 的右子树。
LeetCode 刷题 -- Day 4
2401_83694336的博客
04-20 752
有性质：将 s 中第一个（或前k个） s‘ 移去，再 s 末尾加入一个 （或k个）s’ ，则 s 不变。s’ ，将 s 的首尾拼接（ss）后，中间会出现 s。i += 2 * k) ，i 为观察区第一个元素下标，则 ① 为 reverse(s.begin() + i, s.begin() + i + k);从1开始计数，在计数开始前或每数到 2k 时都进行判断处理一次 ①数到2k的倍数则反转前k个，②剩余字符少于k个则全部反转并结束，③ 如果剩余字符少于2k个 但大于等于 k 个则反转前k个并结束。
LeetCode 刷题 -- Day 7
2401_83694336的博客
04-25 832
​ 先是vector ans 数组存各路径的结点，然后遍历ans 数组取出各结点形成路径，这太麻烦了。所以只需判断当前节点引导的子树是不是满二叉树，是的话直接返回子树的结点，不是的话就往下遍历。​ 自顶向下递归，因此对于同一个节点，函数 getHight 会被重复调用，导致时间复杂度较高。​ 自顶向下遍历树的各结点（先序遍历），对每一结点，判断左右子树的高度差是否小于等于 1。② 如果 root1 和 root2 一个为空，一个不为空，则不对称。
LeetCode 刷题 -- Day 5
2401_83694336的博客
04-22 902
c++11 新标准引入了三个新成员------- emplace_front，emplace 和 emplace_back，这些操作构造而不是拷贝元素，因此相比push_back 等函数能更好地避免内存的拷贝与移动，使容器插入元素的性能得到进一步提升。② 对于push 操作的实现，直接push存入q，对于pop 操作，先把q 中的非队尾元素按序存入 temp，q 的队尾即为要pop的元素，把队尾元素pop后，再将temp中的元素按序存入q。定义优先级队列，自动排序，队首元素即为最大值。
LeetCode 刷题 -- Day 1
2401_83694336的博客
03-22 644
2、为了使用双指针不停移动来更新ans，选择了从两端往中间移动，先让 j = nums.size() - 1，若a[i] [j] > target 再分别讨论 a[i+1] [j] 和 a[i] [j-1] 这两种情况，这样则要么使用DFS，要么用二维数组或结构体（发现没有，其实可以不用数组）定义sum为连续子数组值的和，sum < target 当然是 ++j，sum > target 那 j 不动，sum - nums[i] 后 i++，是不是比 i，j 从两端开始往中间移动好一点。
LeetCode刷题计划---day2
小豆包的博客
02-15 350
LeetCode刷题计划--day2
leetcode刷题-Day2-数组
smallmaolv的博客
01-12 139
leetcode刷题Day2，#代码随想录
leetcode刷题算法总结-LeetCode-31-day-May-2020-Challenge:包含我在31天-LeetCodeMay'2
06-30
leetcode刷题算法总结我与病毒式 LeetCode 月刊的冒险 - Code Everyday Challenge - 20 年 5 月版 所以在一个晴朗的日子（2020 年4 月 30 日），我随便打开了 LinkedIn ，我的订阅源中充斥着来自完成了LeetCode 4 月...
leetcode题库-Leetcode-Summary:Leetcode刷题总结（Java版）——更新中
06-29
day） 栈（stack_items）   用两个栈实现队列（Implement_queue_with_two_stacks.java）   滑动窗口的最大值（Maximum_value_of_sliding_window.java）   包含min函数的栈（The_stack_containing_the_min_...
最低加油次数leetcode-LeetCode:LeetCode刷题笔记
06-30
LeetCode刷题笔记 Day1 1. 两数之和 知识点：哈希表，键为元素值，值为索引。边遍历边判断差值是否存在于哈希表 2. 两数相加 知识点：链表遍历 53. 最大子序和 知识点：动态规划或者贪心算法 983. 最低票价 知识点：...
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
weixin_65180740的博客
07-24 844
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
LeetCode707 设计链表
daishabby2486的博客
07-25 576
LeetCode707 设计链表的解题记录。
Leetcode—769. 最多能完成排序的块【中等】
Atticus的博客
07-25 320
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
力扣202.快乐数
最新发布
gyj215500的博客
07-25 229
主要是用到了鸽巢原理，最后他们一定会重合，我们只需要判断类似，链表的成环相遇的时候是不是1就行了。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值