LeetCode刷题

最新推荐文章于 2024-09-16 06:54:08 发布
最新推荐文章于 2024-09-16 06:54:08 发布
阅读量252 收藏 11
点赞数 14
分类专栏： Leetcode 文章标签： leetcode 算法 职场和发展
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77599154/article/details/133307337
版权

一    螺旋矩阵

题目链接：59. 螺旋矩阵 II - 力扣（LeetCode）

题目描述：

给你一个正整数 n ，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。

示例 1：

输入：n = 3
输出：[[1,2,3],[8,9,4],[7,6,5]]

示例 2：

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

解题思路：

我们可以发现这个矩阵是由外围一层一层的包围，数值依次递增。观察发现如下规律：

 结合这个特点，我们可以用4个for循环来对没一条边赋值，当我们对一圈赋完值后，只要对起始和终止位置在修改即可。当n为偶数时，我们可以刚好循环完，当n为奇数时，我们会剩下一个格子。

如图：

所以当n为奇数时我们要进行一个单独赋值的操作。当我们进行赋值时，要统一操作，左开右闭的话每个边都要统一，我们这里就采用左开右闭，就是每条边的最后一个格子不赋值，放到下一条边处理。我们设起始点下标为star=0，循环次数为loop；那么第一次循环开始位置为a[star][star],终止为n-loop;第二次循环开始位置为a[star+1][star+1]；终止位置为n-(loop+1),此时便完成了循环，最后加一个奇数单独赋值的情况即可。

我们这里就要考虑我们循环赋值要进行多少次？

归纳容易发现：

n=2      循环1次；

n=3      循环1次,单独赋值一个格子；

n=4      循环2次；

n=5      循环2次,单独赋值一个格子；

可以发现循环次数为n/2，当n为奇数是，取整数部分。

代码实现：

class Solution {
    public int[][] generateMatrix(int n) {
        int a[][]= new int[n][n];          //创建一个二维数组 
        int start=0;             //起始位置x，起始位置y
        int loop=0;                        //循环的次数 
        int count=1;                       //要进行赋值的数值，初始为1 
        int i,j;
        while(loop++<n/2){                 //当循环次数小于要循环的次数时，这里的loop也同时控制这终止下标
            for( j=start;j<n-loop;j++){    //第一条边：行不变，列递增
                a[start][j]=count++;
            }
            for( i=start;i<n-loop;i++){    //第二条边：列不变，行递增
                a[i][j]=count++;
            }
            for( ;j>start;j--){           //第三条边：行不变，列递减，这里j没初始化是因为，上一个for循环最终j的值就是此循环j的起始值
                a[i][j]=count++;         
            }
            for( ;i>start;i--){          //第四条边：列不变，行递减
                a[i][j]=count++;
            }
            start++;                       //改变下次循环起始位置
            
        }
        if(n%2==1){                         //如果n为奇数 
            a[n/2][n/2]=count;
        }
        return a;

    }
}

 

分析时间复杂度：

  • 外层的 while 循环执行的次数为 n/2 次，每次循环都会覆盖矩阵的一圈元素。
  • 内层的四个 for 循环的迭代次数依次为 n-1，n-1，n-1，n-2，分别表示四条边上的元素个数。
  • 因此，总体的时间复杂度为 O(n × n) = O(n²)。

分析空间复杂度：

  • 代码中创建了一个 n × n 的二维数组，因此占用的额外空间为 O(n²)。

综上所述，该代码的时间复杂度为 O(n²)，空间复杂度为 O(n²)。

二    移除链表中的元素

题目链接：203. 移除链表元素 - 力扣（LeetCode）

题目描述：

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

示例 1：

输入：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
输出：[]

 

解题思路：

解题思路主要分为两种，一种是带虚拟头节点的，另一种是不带虚拟头节点的。

1.不带虚拟头节点的我们要考虑头节点为要删除的值的情况，和非头节点为要删除的的情况。头结点为要删除的值，只需要将头结点移动到下一个结点，让下一个结点为头结点即可。如图：

非头结点为要删除的值，则只需要找到该删除节点的前一个结点，让它直接连接删除结点的后一个结点即可。如图：

2.带虚拟头节点的只需要将所有节点当作非头结点处理即可。如图：


 

代码实现： 

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode removeElements(ListNode head, int val) {
        ListNode dumyhead=new ListNode(-1,head);//创建虚拟头结点
        ListNode per=dumyhead;   //per指针用来寻找要移除的元素
        while(per.next!=null){   //如果头结点不为空
            if(per.next.val==val){   //找到要删除的元素
                per.next=per.next.next;  //直接连接到删除结点的下一个结点
            }else{
                per=per.next;    //没找到指针后移
            }

        }
        return dumyhead.next;
        /*
         *返回值为cur.net,cur是一个辅助节点，per是用来寻找的需要移除的节点
         *cur固定指向头节点
        */

    }
}


//   采用虚拟头结点的方法



class Solution {
    public ListNode removeElements(ListNode head, int val) {
        while(head!=null&&head.val ==val){//如果头结点不为空并且头结点为要删除 的值
            head=head.next;             
        }
        ListNode cur=head;               //移动指针，查找非结点
        while(cur!=null&&cur.next!=null){
            if(cur.next.val==val){
                cur.next=cur.next.next;
            }else{
                cur=cur.next;
            }

        }
        return head;

    }
}

//不用虚拟头结点的方法

复杂度分析：

  • 时间复杂度：遍历链表的过程中，需要检查所有的节点的值，并删除符合条件的节点。因此，代码的时间复杂度是 O(n)，其中 n 是链表中的节点数。
  • 空间复杂度：代码只使用了常数级别的额外空间，所以空间复杂度是 O(1)。

所以两种方法的时间度均为均为O(n)，空间复杂度均为O(1);

三   反转链表

 题目链接：206. 反转链表 - 力扣（LeetCode）​​​​​​

题目描述： 

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
 

示例 1：


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


示例 2：


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

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

解题思路：

采用双指针的方法解题我们可以让一个指针在前，一个指针在后依次改变链表中的连接方向，动态效果如图：

代码实现：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode cur=head;
        ListNode per=null;
        while(cur!=null){
            ListNode temp=cur.next;//这里定义一个临时指针是因为，当我们将链接改变方向时，cur指针的下一个结点就失去了表达方式，所以我们要在改变之前提前存放好该结点。
            cur.next=per;
            per=cur;
            cur=temp;
        }
        return per;
    }
}

 

复杂度分析：

  • 时间复杂度：代码中的 while 循环会遍历整个链表，将每个节点的 next 指针改变指向前一个节点。因此，时间复杂度是 O(n)，其中 n 是链表的节点数。
  • 空间复杂度：代码只使用了常数级别的额外空间，所以空间复杂度是 O(1)。

综上所述，该代码的时间复杂度是 O(n)，空间复杂度是 O(1)。

四   两两交换链表中的节点

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

题目描述：

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

示例 1：


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


示例 2：

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


示例 3：

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

解题思路：

使用虚拟头节点。先定义一个指针，指针每次指向即将操作的节点（1，2）的前一个节点，然后指针指向的节点的下一个节点连接到节点2，在将节点2，连接到节点1，要注意一旦指针指向的节点连接到节点2以后，节点1就失去了表达式，所以节点1要提前存放，同理节点2连接到节点1以后节点3也就失去了表达式，节点3也要提前处理。如图：

代码实现：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode dumyhead = new ListNode(-1);//定义一个虚拟头节点
        dumyhead.next=head;
        ListNode cur=dumyhead;//定义一个移动指针,每次指向要修改的节点的前一个节点
        while(cur.next!=null && cur.next.next!=null){
            ListNode temp,temp1;
            /*定义两个临时指针,都指向要修改的节点的第一个节点，
             *temp指向前两个的第一个，temp2指向修改的后两个的第一个
             *
            */
            temp=cur.next;//节点1为temp
            temp1=cur.next.next.next;//节点3为temp1,这里做处理是因为一旦节点2的下一个链接节点1，便会与节点3断开
            cur.next=cur.next.next;//虚拟头节点的下一个节点为节点2；
            cur.next.next=temp;//链接节点1
            temp.next=temp1;//链接节点3
            cur=cur.next.next;//修改cur到未改变的节点的前一个
        }  
    return dumyhead.next;
    }
}

 

复杂度分析：

  • 时间复杂度：代码中的 while 循环会遍历链表，并在每次循环中交换两个节点。因此，时间复杂度是 O(n)，其中 n 是链表的节点数。
  • 空间复杂度：代码只使用了常数级别的额外空间，所以空间复杂度是 O(1)。

 

参考资料：

代码随想录_百度搜索 (baidu.com)

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

「PlanA」
关注
专栏目录
leetcode刷题
杨跟的博客
08-23 264
1.两数之和 题目描述 给定一个整型数组，要求返回两个数的下标，使得两数之和等于给定的目标值，要求同一个下标不能使用两次。 数据保证有且仅有一组解。 样例 给定数组 nums = [2, 7, 11, 15]，以及目标值 target = 9， 由于 nums[0] + nums[1] = 2 + 7 = 9, 所以 return [0, 1]. #include<iostream...
LeetCode刷题攻略
Jak的博客
08-10 580
分析错误：如果遇到错题，仔细分析错误原因并查找资料进行补充学习。回顾解法：总结解法背后的算法思路及其适用场景，确保知识内化。通过系统性刷题、定期复习、充分利用讨论区和总结错题，可以更有效地提高自己的算法能力和面试准备程度。最重要的是保持持续学习的态度和耐心，不断挑战自我。祝你在 LeetCode 刷题和面试中取得优秀的成绩！如果你还有其他具体问题或需要进一步的帮助，请告诉我！
关于leetcode刷题详细介绍
热门推荐
智者之家
10-01 9万+
  虽然刷题一直饱受诟病，不过不可否认刷题确实能锻炼我们的编程能力，相信每个认真刷题的人都会有体会。现在提供在线编程评测的平台有很多，比较有名的有 hihocoder，LintCode，以及这里我们关注的 LeetCode。 LeetCode收录了许多互联网公司的算法题目，被称为刷题神器，我虽然早有耳闻，不过却一直没有上面玩过。   据了解，LeetCode 是一个非常棒的 OJ（Online J...
leetcode刷题规划
weixin_42986599的博客
12-15 636
leetcode刷题规划、总结、技巧、经验
（C++）LeetCode刷题题解答案
02-20
（C++）LeetCode刷题题解答案
algorithm-learning:leetcode刷题（Java，Python）和算法书籍
03-18
《algorithm-learning: leetcode刷题（Java，Python）和算法书籍》这个压缩包文件主要包含的是关于算法学习的资源，特别是针对LeetCode平台上的题目进行的编程实践，涉及的编程语言主要是Java和Python。LeetCode是一...
LeetCode刷题笔记.rar
07-05
《LeetCode刷题笔记》是针对LeetCode这个在线编程挑战平台的个人学习心得与总结，主要涵盖数据结构和算法两大核心领域。LeetCode是一个全球知名的编程训练网站，它提供了丰富的编程题目，帮助开发者提升编程技能，...
LeetCode 刷题笔记 with Java.zip
11-23
《LeetCode刷题笔记withJava》是一份专为Java开发者准备的算法实战指南，涵盖了LeetCode网站上前一百道编程挑战题目。这份资料旨在帮助程序员提升算法能力，掌握数据结构和问题解决技巧，对于准备面试或者想要提升...
谷歌高畅Leetcode刷题笔记.pdf
08-04
这本书名为《LeetCode101：和你一起你轻松刷题（C++）》的电子书，作者高畅ChangGao，旨在帮助有C++基础但缺乏刷题经验的读者。本文将详细阐述该电子书中提及的IT知识点，覆盖算法与数据结构两大板块，以及十五个...
Python世界：力扣29题两数相除算法实践
来知晓的博客
09-13 464
除法运算本质是减法，从理解原理到真正实现还是有距离，建议初步理解后，不参考任何代码，完全自己复现一遍，体会更深。注意提示：目的就是提醒越界问题：-2^31/-1=2&31，超过了整数表达范围。本问题来自于力扣29题，在做完大数相乘后，顺带也看下两数相除。将两数相除，要求不使用乘法、除法和 mod 运算符。给定两个整数，被除数。
【Hot100】LeetCode—64. 最小路径和
weixin_44382896的博客
09-12 522
64. 最小路径和。
【JavaScript】LeetCode：707设计链表
weixin_45980065的博客
09-14 671
【代码】【JavaScript】LeetCode：707设计链表。
LeetCode 692.前K个高频单词
m0_63816268的博客
09-13 368
首先用map存储该字典，然后放进vector进行排序，注意sort的排序规则与我们想要的规则不一致，所以我们需要写一个伪函数来判断second(value值)，由于该题要求了稳定性，所以我们在伪函数还需要继续判断相等情况的顺序。排完序后用vector将前k个单词存储起来返回。
Leetcode Hot 100刷题记录 -Day16（旋转图像）
weixin_45864705的博客
09-14 266
你必须在原地旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要 使用另一个矩阵来旋转图像。请你将图像顺时针旋转 90 度。
Golang | Leetcode Golang题解之第409题最长回文串
最新发布
weixin_66442839的博客
09-16 482
Golang | Leetcode Golang题解之第409题最长回文串
leetcode-647. 回文子串
曼巴的博客
09-12 442
3）遍历顺序：一定要从下到上，从左到右遍历，这样保证dp[i + 1][j - 1]都是经过计算的。当s[i]与s[j]不相等，那没啥好说的了，dp[i][j]一定是false。整体上是两种，就是s[i]与s[j]相等，s[i]与s[j]不相等这两种。6个回文子串: "a", "a", "a", "aa", "aa", "aaa"当s[i]与s[j]相等时，这就复杂一些了，有如下三种情况。三个回文子串: "a", "b", "c"是字符串中的由连续字符组成的一个序列。是正着读和倒过来读一样的字符串。
leetcode-617. 合并二叉树
曼巴的博客
09-11 269
想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。你需要将这两棵树合并成一棵新二叉树。合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；1）如果没有root1，return root2。2）如果没有root2，return root1。null 的节点将直接作为新二叉树的节点。合并过程必须从两个树的根节点开始。3）根结点处理：两节点值加和。4）遍历两棵树的左节点。5）遍历两棵树的右节点。返回合并后的二叉树。
408算法题leetcode--第一天
weixin_58073817的博客
09-11 445
【代码】408算法题leetcode--第一天。
LeetCode刷题攻略：二分法与双指针模板
"LeetCode刷题模板.pdf" 这篇文档主要涵盖了LeetCode刷题中常见的两种算法模板——二分法和双指针法，并提供了相应的代码模板、关键属性和具体题目的应用示例。以下是对这两种方法的详细解释： 1. 二分法 - 什么...
评论 14
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值