LeetCode 高频题复盘（2）

已于 2024-08-28 13:20:19 修改
阅读量500 收藏 3
点赞数 4
分类专栏： LeetCode 文章标签： 数据结构 算法
于 2024-04-28 17:16:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hu_wei123/article/details/138225854
版权

目录

102. 二叉树的层序遍历


题目链接

Python

方法一

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        if not root:
            return []
        res=[]
        queue=[root]
        while queue:
            level_value=[]
            for _ in range(len(queue)):
                node=queue.pop(0)
                level_value.append(node.val)
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            res.append(level_value)
        return res

方法二

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        if not root:
            return []
        res=[]
        queue=[root]
        while queue:
            level_node=[]
            level_value=[]
            for node in queue:
                if node:
                    level_value.append(node.val)
                if node.left:
                    level_node.append(node.left)
                if node.right:
                    level_node.append(node.right)
            res.append(level_value)
            queue=level_node
        return res

Java

方法一

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);

        while (!queue.isEmpty()) {
            List<Integer> levelValue = new ArrayList<>();
            int levelSize = queue.size();
            for (int i = 0; i < levelSize; i++) {
                TreeNode node = queue.poll(); 
                levelValue.add(node.val);
                if (node.left != null) {
                    queue.add(node.left);
                }
                if (node.right != null) {
                    queue.add(node.right);
                }
            }
            res.add(levelValue);
        }
        return res;
    }
}

方法二

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        
        Queue<TreeNode> currentLevel = new LinkedList<>();
        currentLevel.add(root);

        while (!currentLevel.isEmpty()) {
            List<Integer> levelValues = new ArrayList<>();
            Queue<TreeNode> nextLevel = new LinkedList<>();

            while (!currentLevel.isEmpty()) {
                TreeNode node = currentLevel.poll();
                levelValues.add(node.val);
                if (node.left != null) {
                    nextLevel.add(node.left);
                }
                if (node.right != null) {
                    nextLevel.add(node.right);
                }
            }

            res.add(levelValues);
            currentLevel = nextLevel;
        }
        return res;
    }
}

33. 搜索旋转排序数组


题目链接

Python

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        l,r=0,len(nums)-1
        while l<=r:
            mid=(l+r)//2
            if target==nums[mid]:
                return mid
            if nums[l]<=nums[mid]: # 左半部分有序
                if nums[l]<=target<nums[mid]:
                    r=mid-1
                else:
                    l=mid+1
            else: # 右半部分有序
                if nums[mid]<target<=nums[r]:
                    l=mid+1
                else:
                    r=mid-1
        return -1

Java

public class Solution {
    public int search(int[] nums, int target) {
        int l = 0, r = nums.length - 1;
        
        while (l <= r) {
            int mid = l + (r - l) / 2;
            if (nums[mid] == target) {
                return mid;
            }

            if (nums[l] <= nums[mid]) {
                if (nums[l] <= target && target < nums[mid]) {
                    r = mid - 1;
                } else {
                    l = mid + 1;
                }
            } 
            else {
                if (nums[mid] < target && target <= nums[r]) {
                    l = mid + 1;
                } else {
                    r = mid - 1;
                }
            }
        }
        return -1; 
    }
}

121. 买卖股票的最佳时机


题目链接

Python

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        # 每一天的股票都有两种状态：dp[i][0]不持有,dp[i][1]持有
        dp=[[0,0] for _ in range(len(prices))]
        dp[0][1]=-prices[0]
        for i in range(1,len(prices)):
            dp[i][0]=max(dp[i-1][0],dp[i-1][1]+prices[i]) # 不持有
            dp[i][1]=max(dp[i-1][1],-prices[i]) # 持有
        return dp[len(prices)-1][0]

Java

public class Solution {
    public int maxProfit(int[] prices) {
        int n = prices.length;
        int[][] dp = new int[n][2];
        dp[0][1] = -prices[0];  
        for (int i = 1; i < n; i++) {
            dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] + prices[i]); // 不持有
            dp[i][1] = Math.max(dp[i - 1][1], -prices[i]);              // 持有
        }
        // 最后一天不持有股票的情况即为最大利润
        return dp[n - 1][0];
    }
}

200. 岛屿数量


题目链接

Python

DFS 解法

class Solution:
    def numIslands(self, grid: List[List[str]]) -> int:
        def dfs(x,y):
            visited[x][y]=True # 核心
            for d in dirs:
                nx=x+d[0]
                ny=y+d[1]
                if 0<=nx<m and 0<=ny<n and not visited[nx][ny] and grid[x][y]=='1':
                    dfs(nx,ny)
        m,n=len(grid),len(grid[0])
        visited=[[False]*n for _ in range(m)]
        dirs=[(-1,0),(1,0),(0,-1),(0,1)] # 上下左右
        res=0
        for i in range(m):
            for j in range(n):
                if not visited[i][j] and grid[i][j]=='1':
                    res+=1
                    dfs(i,j) # 将自身与其连接的陆地都标记为True（已经访问过）
        return res

BFS 解法

class Solution:
    from collections import deque
    def numIslands(self, grid: List[List[str]]) -> int:
        def bfs(x,y):
            q=deque()
            q.append((x,y))
            visited[x][y]=True
            while q:
                x,y=q.popleft()
                for d in dirs:
                    nx,ny=x+d[0],y+d[1]
                    if 0<=nx<m and 0<=ny<n and not visited[nx][ny] and grid[x][y]=='1':
                        q.append((nx,ny))
                        visited[nx][ny]=True
        m,n=len(grid),len(grid[0])
        visited=[[False]*n for _ in range(m)]
        dirs=[(-1,0),(1,0),(0,-1),(0,1)] # 上下左右
        res=0
        for i in range(m):
            for j in range(n):
                if not visited[i][j] and grid[i][j]=='1':
                    res+=1
                    bfs(i,j) # 将与其连接的陆地都标记为True（已经访问过）
        return res

Java

DFS 解法

public class Solution {
    public int numIslands(char[][] grid) {
        int m = grid.length;
        int n = grid[0].length;
        boolean[][] visited = new boolean[m][n];
        int[][] dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}}; // 上下左右
        int res = 0;

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (!visited[i][j] && grid[i][j] == '1') {
                    res++;
                    dfs(grid, visited, i, j, dirs);
                }
            }
        }
        return res;
    }

    private void dfs(char[][] grid, boolean[][] visited, int x, int y, int[][] dirs) {
        visited[x][y] = true;
        int m = grid.length;
        int n = grid[0].length;

        for (int[] d : dirs) {
            int nx = x + d[0];
            int ny = y + d[1];
            if (0 <= nx && nx < m && 0 <= ny && ny < n && !visited[nx][ny] && grid[nx][ny] == '1') {
                dfs(grid, visited, nx, ny, dirs);
            }
        }
    }
}

BFS 解法

public class Solution {
    public int numIslands(char[][] grid) {

        int m = grid.length;
        int n = grid[0].length;
        boolean[][] visited = new boolean[m][n];
        int[][] dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}}; // 上下左右
        int res = 0;

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (!visited[i][j] && grid[i][j] == '1') {
                    res++;
                    bfs(grid, visited, i, j, dirs);
                }
            }
        }
        return res;
    }

    private void bfs(char[][] grid, boolean[][] visited, int x, int y, int[][] dirs) {
        int m = grid.length;
        int n = grid[0].length;

        Queue<int[]> queue = new LinkedList<>();
        queue.add(new int[]{x, y});
        visited[x][y] = true;

        while (!queue.isEmpty()) {
            int[] point = queue.poll();
            int curX = point[0];
            int curY = point[1];

            for (int[] d : dirs) {
                int nx = curX + d[0];
                int ny = curY + d[1];
                if (0 <= nx && nx < m && 0 <= ny && ny < n && !visited[nx][ny] && grid[nx][ny] == '1') {
                    queue.add(new int[]{nx, ny});
                    visited[nx][ny] = true;
                }
            }
        }
    }
}

20. 有效的括号


题目链接

class Solution:
    def isValid(self, s: str) -> bool:
        if len(s)%2!=0:
            return False
        dic={
            ")":"(",
            "}":"{",
            "]":"["
        }
        stack=[]
        for c in s:
            # 右括号都看栈里面是否有相应的左括号
            if c in dic:
                # 栈里面没有对应的左括号
                if not stack or stack[-1]!=dic[c]:
                    return False
                # 栈里面有对应的左括号，成对的左右括号相消
                else:
                    stack.pop()
            # 左括号都入栈
            else:
                stack.append(c)
        return not stack

Java

class Solution {
    public boolean isValid(String s) {
        if (s.length()%2!=0){
            return false;
        }
        HashMap<Character,Character> hashmap=new HashMap<>();
        hashmap.put(')','(');
        hashmap.put('}','{');
        hashmap.put(']','[');
        Stack<Character> stack=new Stack<>();
        for (char c:s.toCharArray()){
            if (hashmap.containsKey(c)){
                if (stack.isEmpty() || stack.peek()!=hashmap.get(c)){
                    return false;
                }else{
                    stack.pop();
                }
            }else{
                stack.push(c);
            }
        }
        return stack.isEmpty();
    }
}

88. 合并两个有序数组


题目链接

Python

class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        """
        Do not return anything, modify nums1 in-place instead.
        """
        p1,p2=m-1,n-1
        tail=m+n-1
        while p1>=0 or p2>=0:
            if p1==-1:
                nums1[tail]=nums2[p2]
                p2-=1
            elif p2==-1:
                nums1[tail]=nums1[p1]
                p1-=1
            elif nums1[p1]<=nums2[p2]:
                nums1[tail]=nums2[p2]
                p2-=1
            else:
                nums1[tail]=nums1[p1]
                p1-=1
            tail-=1

Java

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        int p1=m-1;
        int p2=n-1;
        int tail=m+n-1;
        while (p1>=0 || p2>=0){
            if (p1==-1){
                nums1[tail]=nums2[p2];
                p2-=1;
            }else if (p2==-1){
                nums1[tail]=nums1[p1];
                p1-=1;
            }else if (nums1[p1]<=nums2[p2]){
                nums1[tail]=nums2[p2];
                p2-=1;
            }else{
                nums1[tail]=nums2[p1];
                p1-=1;
            }
        tail-=1;
        }
    }
}

141. 环形链表


题目链接

Python

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def hasCycle(self, head: Optional[ListNode]) -> bool:
        slow,fast=head,head
        while fast and fast.next:
            slow=slow.next
            fast=fast.next.next
            if slow==fast:
                return True
        return False

Java

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        ListNode slow=head;
        ListNode fast=head;
        while (fast!=null && fast.next!=null){
            fast=fast.next.next;
            slow=slow.next;
            if(slow==fast){
                return true;
            }
        }
        return false;
    }
}

注意：在Java中，while (fast != null && fast.next != null)不能写成 while (fast && fast.next) 这种语法。Java 对布尔表达式的要求是明确且严格的，它要求表达式明确地返回一个布尔值。

46. 全排列


题目链接

Python

class Solution:
    def permute(self, nums: List[int]) -> List[List[int]]:
        path=[]
        res=[]
        def backtracing(nums,used):
            if len(path)==len(nums):
                res.append(path[:])
            for i in range(len(nums)):
                if not used[i]:
                    path.append(nums[i])
                    used[i]=True
                    backtracing(nums,used)
                    used[i]=False
                    path.pop()
        used=[False]*(len(nums))
        backtracing(nums,used)
        return res

Java

class Solution {
    public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        List<Integer> path = new ArrayList<>();
        boolean[] used =new boolean[nums.length];
        backtracking(nums,used,path,res);
        return res;
    }
    public void backtracking(int[] nums,boolean[] used, List<Integer> path,List<List<Integer>> res){
        if (path.size()==nums.length){
            res.add(new ArrayList<>(path));
        }
        for(int i=0;i<nums.length;i++){
            if (!used[i]){
                path.add(nums[i]);
                used[i]=true;
                backtracking(nums,used,path,res);
                used[i]=false;
                path.remove(path.size()-1);
            }
        }
    }
}

注意：Java写法中 path.remove(path.size()-1);不能写成 path.remove(nums[i]);。因为nums[i]是基本类型，Java 实际上会将 nums[i] 视为一个整数，并尝试将其作为索引来移除 path 列表中对应索引处的元素。如果确实需要根据值来移除元素，并且该值是一个对象（这里是 Integer）path.remove(Integer.valueOf(nums[i])); // 创建一个Integer对象，并尝试移除这个对象

236. 二叉树的最近公共祖先


题目链接

Python

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        if not root or p==root or q==root:
            return root
        # 后序遍历
        left=self.lowestCommonAncestor(root.left,p,q)
        right=self.lowestCommonAncestor(root.right,p,q)
        if left and right:
            return root
        elif not left and right:
            return right
        elif not right and left:
            return left
        else:
            return

Java

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if (root==null || p==root || q==root){
            return root;
        }
        TreeNode left = lowestCommonAncestor(root.left,p,q);
        TreeNode right = lowestCommonAncestor(root.right,p,q);
        if (left!=null && right!=null){
            return root;
        }else if (left!=null && right==null){
            return left;
        }else if (left==null && right!=null){
            return right;
        }else{
            return null;
        }
    }
}

注意：在Java中，不能使用 and 和 or 这样的关键字来表示逻辑运算。Java使用符号 &&（逻辑与）和 ||（逻辑或）来执行逻辑运算。

夏木夕
关注
  • 4
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode 高频题复盘（1）
hu_wei123的博客
04-26 452
用到的数据结构：哈希表+双向链表。
LeetCode 高频题复盘（3）
hu_wei123的博客
04-30 367
【代码】2024.4.28 —— LeetCode 高频题复盘。
LeetCode 高频题复盘（4）
hu_wei123的博客
04-30 285
【代码】2024.4.29 —— LeetCode 高频题复盘。
2024.5.9 —— LeetCode 高频题复盘
hu_wei123的博客
05-10 499
本题是判断子结构，只要包含这一部分就行，不管这一部分下面是否还有节点，而子树是包含该子树，该子树下面不能包含其他的节点，否则就不是包含该子树。有个小小的区别就是，n / num 的取值能不能为0。
2024.5.5 —— LeetCode 高频题复盘
hu_wei123的博客
05-08 426
问题，完全背包和01背包问题唯一不同的地方就是，每种物品有无限件。核心代码中两层for循环是可以完全颠倒的，先遍历背包后遍历物品，先遍历物品再遍历背包都是可以的。哔哩哔哩暑期实习考过这题。在做该题之前建议先做。
2024.5.6 —— LeetCode 高频题复盘
hu_wei123的博客
05-08 504
【代码】2024.5.6 —— LeetCode 高频题复盘。
2024.5.4 —— LeetCode 高频题复盘
hu_wei123的博客
05-08 443
返回一个元组的迭代器，其中的第 i 个元组包含来自每个参数序列或可迭代对象的第 i 个元素。如果已知有一个 x,x+1,x+2,⋯ ,x+y 的连续序列，而我们却重新从 x+1，x+2或者是 x+y 处开始尝试匹配，那么得到的结果肯定不会优于枚举 x为起点的答案，因此我们在外层循环的时候碰到这种情况跳过即可。由于我们要枚举的数 x 一定是在数组中不存在前驱数 x−1 的，不然按照上面的分析我们会从x−1 开始尝试匹配，因此我们每次在哈希表中检查是否存在x−1 即能判断是否需要跳过了。
2024.5.7 —— LeetCode 高频题复盘
hu_wei123的博客
05-08 395
核心思想： 一个数被另一个数异或两次，该数本身不变。对角线上横纵坐标和为定值 k。在做该题之前建议先做。
2024.5.2 —— LeetCode 高频题复盘
hu_wei123的博客
05-09 372
【代码】2024.5.2 —— LeetCode 高频题复盘。
「高频面试题」消息队列 和 事件循环系统（内附思维导图）
超逸の学习技术博客
12-06 1360
前言 最近又和女友，咳咳…（说出来可能又会被打s）学习事件循环，这不，学会（废）了之后，赶紧写一篇博客复盘总结一下~ 接上一期「数组方法」写给女友的一系列 JS 数组操作（建议收藏 | 内附思维导图） 文章发出去之后，有些小伙伴还真发给自己女友了，不知道“感动”了没有哈（手动滑稽）。 那么，这次女友直接说明白了，那么我就从“头”开始讲讲事件循环系统，通过一篇文章搞定这一块知识点。 事件循环非常底层且非常重要，学会它能让你理解页面到底是如何运行的。 话说女友会点开这篇文章么？ 我“啪”地一下就醒过来了.
面试复盘整理
你知道的越多，你不知道的越多
01-28 3293
面试复盘 总结： ​ 面试了将近一个月，大厂基本上都面过了，大厂技术栈基本上都是springcloud+mysql+redis+kafka，一面基本上都是自我介绍，问问kafka问问redis问问mysql问问并发。问题基本上都很简单，虽然说都是八股文背一背就行了，不过最好还是有自己的理解，不然稍微厉害的面试官会考察你的思路根据你的理解出场景题，如果只是背诵问两个问题就能发现你根本不理解。简历上写的技术一定要重点准备。 ​ 面试碰到不会的场景题目没关系，跟面试官表达出自己的思考过程，面试官一般也会提点下。
字节三面 + 微信四面 +PayPal 四面, 逆袭之路，大厂面试复盘
SharingOfficer的博客
10-21 408
面试本质是一个自我优势展示的过程，不要把面试变成面试官问一句自己回答一句，主动抛出一些可能的点等面试官来问，比如我基本都被问到了DB和缓存之间怎么保证数据的一致性，其实都是我自己刻意往上引的，比如面试官说，你用过Redis吗，你可以说，
如何高效刷题？算法考察难度怎样的？面试官主要考察哪些素质？
小可爱的博客
03-19 354
应该如何高效刷算法题，到什么程度就可以去面试了呢？不同岗位对算法题的要求是怎样的？通过算法题考查候选人哪些能力呢？
2020校招复盘——秋招不易，致敬每一位追梦者（含网易、京东等19家互联网公司后台/Server端面经）
热门推荐
ZY-JIMMY
10-18 3万+
秋招经历、秋招心得、C++后台/Server端方向校招准备、面经整理、面经题库
【数据结构-二维前缀和】【列维护优化】力扣3212. 统计 X 和 Y 频数相等的子矩阵数量
sjsjs11的博客
09-02 632
我觉得列优化的核心思路是，由于在计算前缀和中，之前的列字符数都会被用到，也就是说在遍历不同行的时候，列的字符数是在前一行的列的字符数加上目前行的字符数得来的。所以在每一行遍历的时候，置s1和s2为0，然后逐渐累加，可以看作这个前缀和矩阵，随着列的遍历，一条条竖下来的元素铺成一个前缀和矩阵，最后进行统计X和Y相等的频数。输入： grid = [[“X”,“Y”,“.”],[“Y”,“.”,“.”]]输入： grid = [[“X”,“X”],[“X”,“Y”]]‘X’ 和 ‘Y’ 的频数相等。
C语言-数据结构 并查集
BamBoo_Bean的博客
09-05 149
C语言-数据结构 并查集
C++笔记16•数据结构:关联式容器map和set•
qq_64446190的博客
09-02 842
数据结构:关联式容器map和set
经典数据结构-栈计算逆波兰表达式
最新发布
一个好学的低级程序猿
09-05 131
栈计算逆波兰表达式
小浩算法图解：105道LeetCode高频题详解
"《和小浩学算法》是一本由作者在疫情期间编撰的图解算法题典，针对的是105道高频面试算法题目。它特别适合初学者和中级水平的读者，所有题目均基于LeetCode平台测试通过。教程的特点在于其漫画形式，旨在降低学习...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值