- 博客(45)
- 收藏
- 关注
RSS订阅原创 LeetCode102：二叉树的层序遍历（队列与递归）
二叉树的层序遍历1、给一个二叉树，请返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。 /** * 二叉树的层序遍历：队列（先出先进，每次入队一层，出队一层的节点）：广度优先遍历 * 时间复杂度：O(n) * 空间复杂度:O(n) * @param root * @return */ public List<List<Integer>> levelOrder(TreeNode roo
2020-06-29 09:53:15
388
原创 LeetCode145：二叉树的后序遍历（栈与递归）
二叉树的后序遍历给定一个二叉树，返回它的 后序 遍历。List<Integer> retList = new ArrayList<>(); /** * 二叉树的后序遍历:递归 * @param root * @return */ public List<Integer> postorderTraversal(TreeNode root) { if(root != null){
2020-06-28 21:00:46
90
原创 LeetCode94：二叉树的中序遍历（栈与递归）
二叉树的中序遍历给定一个二叉树，返回它的中序 遍历。 List<Integer> retList = new ArrayList<>(); /** * 二叉树的中序遍历:递归 * @param root * @return */ public List<Integer> inorderTraversal(TreeNode root) { if(root != null){ i
2020-06-28 20:50:50
91
原创 LeetCode144：二叉树的前序遍历（栈与递归）
二叉树的前序遍历1、给定一个二叉树，返回它的 前序 遍历。 List<Integer> retList = new ArrayList<>(); /** * 二叉树的前序遍历 * @param root * @return */ public List<Integer> preorderTraversal(TreeNode root) { if(root != null){
2020-06-28 20:41:26
83
原创 LeetCode20：有效的括号（栈）
有效的括号1、给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。2、有效字符串需满足：*左括号必须用相同类型的右括号闭合。*左括号必须以正确的顺序闭合。*注意空字符串可被认为是有效字符串。 /** * 有效的括号:利用栈这种数据结构 * 栈顶元素反映了在嵌套的层次关系中，最近的需要匹配的元素。 * @param s * @return */ public boolean isValid(Str
2020-06-28 19:17:34
76
原创 LeetCode234：回文链表（链表，双指针）
回文链表请判断一个链表是否为回文链表。/** * 回文链表:遍历一次链表，将链表的值存进一个数组里，判断这个数组中的值是否为回文 * 时间复杂度:O(n) * 空间复杂度：O(n) * @param head * @return */ public boolean isPalindrome(ListNode head) { if(head == null){ return true;
2020-06-28 18:53:01
124
原创 LeetCode19：删除链表的倒数第N个节点（链表，双指针）
删除链表的倒数第N个节点给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。 /** * 删除链表的倒数第N个节点：遍历两次链表（再删除链表中节点时， *我们通常需要增加一个虚拟的头结点， * 因为要找到删除节点的前一个节点，第一个节点没有前一个节 点，所以增加一个虚拟头结点来处理边界情况。） * 先遍历一遍计算链表的长度， * 再遍历一遍删除倒数第n个节点（就是正数第l-n+1个节点） * 时间复杂度：O(n)
2020-06-28 16:11:08
135
原创 LeetCode237：删除链表中的节点（链表）
删除链表中的节点1、请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点，你将只被给定要求被删除的节点。2、说明:*链表至少包含两个节点。*链表中所有节点的值都是唯一的。*给定的节点为非末尾节点并且一定是链表中的一个有效节点。*不要从你的函数中返回任何结果。public void deleteNode(ListNode node) { //要删除的节点不为空 if(node == null){ return; }
2020-06-28 15:11:53
154
原创 LeetCode24：两两交换链表中的节点（链表）
两两交换链表中的节点1、给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。2、你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。 /** * 两两交换链表中的节点：定义好指针，进行穿针引线 * 时间复杂度:O(n) * 空间复杂度：O(1) * @param head * @return */ public ListNode swapPairs(ListNode head) { //定义虚拟头结点
2020-06-28 14:33:16
101
原创 LeetCode203：移除链表元素（链表）
移除链表元素删除链表中等于给定值 val 的所有节点。/** * 移除链表元素 * @param head * @param val * @return */ public ListNode removeElements(ListNode head, int val) { //判断链表第一个元素的val是否等于val，等于进行移除， // 可能移除后的链表的第一个元素的val还等于val，需要通过while进行判
2020-06-27 21:54:36
131
原创 LeetCode206：反转链表（链表）
反转链表1、反转一个单链表。 public class ListNode{ int val; ListNode next; ListNode(int x){val = x;} } /** * 反转链表 * @param head * @return */ public ListNode reverseList(ListNode head) { ListNode pre
2020-06-27 20:59:17
116
原创 LeetCode220：存在重复元素II（数组-Set集合，滑动窗口，查找表）
存在重复元素II1、在整数数组 nums 中，是否存在两个下标 i 和 j，使得 nums [i] 和 nums [j] 的差的绝对值小于等于 t ，且满足 i 和 j 的差的绝对值也小于等于 ķ 。2、如果存在则返回 true，不存在返回 false。 /** * 存在重复元素 III: * 时间复杂度O(nlogn) * 空间复杂度O(k) * @param nums * @param k * @param t * @retu
2020-06-27 20:33:52
221
原创 LeetCode219：存在重复元素II（数组-Set集合，滑动窗口，查找表）
存在重复元素II1、给定一个整数数组和一个整数 k，判断数组中是否存在两个不同的索引 i 和 j，使得 nums [i] = nums [j]，并且 i 和 j 的差的 绝对值 至多为 k。 /** * 存在重复元素 II:滑动窗口（大小为k+1）+查找表 * 时间复杂度O(n) * 空间复杂度O(k) * @param nums * @param k * @return */ public boolean contain
2020-06-27 12:38:59
153
原创 LeetCode447：回旋镖的数量（数组-Map集合，查找表）
回旋镖的数量1、给定平面上 n 对不同的点，“回旋镖” 是由点表示的元组 (i, j, k) ，其中 i 和 j 之间的距离和 i 和 k 之间的距离相等（需要考虑元组的顺序）。2、找到所有回旋镖的数量。你可以假设 n 最大为 500，所有点的坐标在闭区间 [-10000, 10000] 中。 /** * 回旋镖的数量:使用Map查找表，key为i到其他点的距离值，value为该距离值对应多少个点 * @param points * @return */
2020-06-27 12:03:10
176
原创 LeetCode454：四数相加II（数组-Map集合，查找表）
四数相加II1、给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ，使得 A[i] + B[j] + C[k] + D[l] = 0。2、为了使问题简单化，所有的 A, B, C, D 具有相同的长度 N，且 0 ≤ N ≤ 500 。所有整数的范围在 -228 到 228 - 1 之间，最终结果不会超过 231 - 1 。 /** * 四数相加 II:将任意的A+B的值存放在Map查找表中，key为A+B的值，value为该值对应的多
2020-06-27 10:53:43
175
原创 LeetCode1：两数之和（数组-Map集合，查找表）
两数之和1、给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。2、你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。3、数组不是有序的。 /** * 两数之和:查找表：nums不是有序数组 * @param nums * @param target * @return */ public int[] twoSum(int[] nums, i
2020-06-27 10:27:51
103
原创 LeetCode350：两个数组的交集（数组-Map集合）
两个数组的交集给定两个数组，编写一个函数来计算它们的交集。/** * 两个数组的交集 II:输出结果中每个元素出现的次数，应与元素在两个数组中出现的次数一致 * 使用Map集合：允许出现相同的元素 * @param nums1 * @param nums2 * @return */ public int[] intersect(int[] nums1, int[] nums2) { Map<Integer,I
2020-06-27 09:09:23
195
原创 LeetCode349：两个数组的交集（数组-Set集合）
两个数组的交集给定两个数组，编写一个函数来计算它们的交集。说明：输出结果中的每个元素一定是唯一的。我们可以不考虑输出结果的顺序。 /** * 两个数组的交集：使用Set集合：不允许出现相同的元素，不区分元素的顺序（其内部存储结构的特点）。 * @param nums1 * @param nums2 * @return */ public int[] intersection(int[] nums1, int[] nums2) {
2020-06-27 08:41:29
122
原创 LeetCode3：无重复字符的最长子串（数组）
无重复字符的最长子串1、给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。2、 /** * 无重复字符的最长子串 * @param s * @return */ public int lengthOfLongestSubstring(String s) { int [] freq= new int[256]; for(int i =0;i<freq.length;i++){ f
2020-06-26 21:55:21
864
原创 LeetCode209：长度最小的子数组（数组）
长度最小的子数组1、给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的连续子数组，并返回其长度。如果不存在符合条件的连续子数组，返回 0。2、/** * 长度最小的子数组:滑动窗口[left...right] * 时间复杂度O(n) * 空间复杂度O(1) * @param s * @param nums * @return */ public int minSubArrayLen
2020-06-26 21:32:42
264
原创 LeetCode167：两数之和II（数组）
两数之和II1、最直接的思考：暴力解法，双层遍历，时间复杂度O(n^2)。 /** * 暴力解法：时间复杂度O(n^2) * @param numbers * @param target * @return */ public int[] twoSum(int[] numbers, int target) { int [] indexs = new int[2]; for(int i=0;i<number
2020-06-26 21:04:14
82
原创 LeetCode75：颜色分类（数组）
颜色分类 /** * 颜色分类：计数排序 * 时间复杂度：O(n) * 空间复杂度:O(1) * @param nums */ public void sortColors(int[] nums) { //存放0,1,2这三个元素的频率 int[] color = {0,0,0}; for(int i=0;i<nums.length;i++){ if(nums[i]
2020-06-26 19:48:22
416
原创 LeetCode27：移除元素（数组）
移除元素1、给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。2、不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。3、元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。 /** * 移除元素:给定数组和val值，移除所有数组中的val值，返回移除后数组的新长度。 * @param nums * @param val * @return *
2020-06-20 21:03:03
71
原创 LeetCode283：移动零（数组）
移动零（数组） /** * 移动零:时间复杂度O（n）,空间复杂度O(1) * @param nums */ public void moveZeroes(int[] nums) { //nums中,[0...k)的元素均为非0元素 int k =0; //进行遍历：遍历到i个元素后，保证[0...i]中的所有非0元素 // 都按照顺序排列在[0...k)中 for(int i =0
2020-06-20 19:35:13
51
原创 二分查找：理解循环不变量的作用
二分查找 /** * 二分查找：对于有序数组(泛型)：明确变量的含义以及循环不变量的维护 * @return */ public<E extends Comparable<E>> int binarySearch(E arr[],int n,E target){ //在[l...r]的范围里寻找target(循环不变量：控制边界) int l=0 ,r =n-1; while(l<
2020-06-20 18:18:01
698
原创 LeetCode455：分发饼干（贪心算法）
分发饼干（贪心算法）1、假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。2、对每个孩子 i ，都有一个胃口值 gi ，这是能让孩子们满足胃口的饼干的最小尺寸；3、并且每块饼干 j ，都有一个尺寸 sj 。4、如果 sj >= gi ，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。5、你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。6、注意：你可以假设胃口值为正，一个小朋友最多只能拥有一块饼干。 /** * 分发
2020-06-18 11:00:08
357
原创 LeetCode70：爬楼梯（动态规划，递归）
爬楼梯1、假设你正在爬楼梯。需要 n 阶你才能到达楼顶。2、每次可以爬 1 或 2 个台阶。有多少种不同的方法可以爬到楼顶呢？3、注意：给定 n 是一个正整数。//使用记忆化搜索(剪枝，存在大量的重叠子问题):memo[i]表示爬i节楼梯有多少种不同的方法可以爬到楼顶 private int[] memo; /** 爬n节楼梯有多少种不同的方法可以爬到楼顶 * @param n * @return */ private int calcWay
2020-06-18 10:28:21
212
原创 LeetCode343：整数拆分（动态规划，递归）
整数拆分1、给定一个正整数 n，将其拆分为至少两个正整数的和，并使这些整数的乘积最大化。 返回可以获得的最大乘积。 //使用记忆化搜索(剪枝):memo[i]表示对i进行分割(至少分割两部分)，可以获得的最大乘积 int[] memo; private int max3(int a,int b,int c){ return Math.max(a,Math.max(b,c)); } /** * 将n进行分割（至少分隔成两部分），可以获得最
2020-06-18 10:00:29
449
原创 LeetCode300：最长上升子序列（动态规划）
最长上升子序列1、给定一个无序的整数数组，找到其中最长上升子序列的长度。2、说明:1.可能会有多种最长上升子序列的组合，只需要输出对应的长度即可。2.算法的时间复杂度应该为 O(n2) 。 /** * 最长上升子序列：动态规划（自底向上） * @param nums * @return */ public int lengthOfLIS(int[] nums) { if(nums.length == 0){
2020-06-18 08:57:17
159
原创 LeetCode416：分割等和子集（动态规划，递归）
分割等和子集1、给定一个只包含正整数的非空数组。是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。 //记忆化搜索：存在重复子问题： //memo[i][c]表示使用索引为[0..i]的这些元素，是否可以完全填充一个容量为c的背包 //-1表示未计算，0表示不可以填充，1表示可以填充 int[][] memo; /** * 使用nums[0...index]所有数字，是否可以完全填充一个容量为sum的背包 * @param nums
2020-06-17 17:32:02
400
原创 01背包问题：递归、动态规划求解
01背包问题：递归、动态规划求解//使用记忆化搜索:（存在重叠子问题：对于index,c这一数据对可能求解多次） int[][] memo; /** * 用[0...index]的物品，填充容积为c的背包的最大价值 * @param w:物体的重量 * @param v：物体的价值 * @param index：当前考虑的物体的index序列号 * @param c：当前所剩容量 * @return */ pri
2020-06-17 15:42:30
1026
原创 LeetCode198：打家劫舍（动态规划）
打家劫舍（动态规划）1、你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。2、给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。//使用记忆化搜索(剪枝):memo[i]表示考虑抢劫num[i...n-1]的房子所能获得的最大收益 int[] memo; /** * 考虑抢劫nums[
2020-06-17 13:51:10
151
原创 LeetCode51：N皇后问题（递归）
N皇后问题1、将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。2、给定一个整数 n，返回所有不同的 n 皇后问题的解决方案。3、每一种解法包含一个明确的 n 皇后问题的棋子放置方案，该方案中 ‘Q’ 和 ‘.’ 分别代表了皇后和空位。4、下图为 8 皇后问题的一种解法。 private List<List<String>> res; //col[]:用来判断竖列是否冲突 private boolean[] col; //
2020-06-15 19:39:47
281
原创 LeetCode200：岛屿数量（递归）
岛屿数量1、一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，计算网格中岛屿的数量。2、岛屿总是被水包围，并且每座岛屿只能由水平方向或竖直方向上相邻的陆地连接形成。3、此外，你可以假设该网格的四条边均被水包围。 //偏移量二维数组:分别为上右下左:顺时针(在二维数组中经常使用) int [][] d = new int[][]{{-1,0},{0,1},{1,0},{0,-1}}; //m,n分别为二维网格的大小 int m,n; //辅助二维数组：访问
2020-06-15 16:49:17
141
原创 LeetCode79：单词搜索（递归）
单词搜索1、给定一个二维网格和一个单词，找出该单词是否存在于网格中。2、单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。 //偏移量二维数组:分别为上右下左(在二维数组中经常使用) int [][] d = new int[][]{{-1,0},{0,1},{1,0},{0,-1}}; //m,n分别为二维网格的大小 int m,n; //辅助二维数组：访问 bool
2020-06-15 16:03:04
377
原创 LeetCode17：电话号码的字母组合（递归）
电话号码的数字组合1、给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。2、给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。 private String letterMap[] = { " ", //0 "", //1 "abc", //2 "def", //3 "ghi", //4 "jkl",
2020-06-15 10:01:59
131
原创 LeetCode235：二叉搜索树的最近公共祖先（二叉树和递归）
二叉搜索树的最近公共祖先给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。说明:1、所有节点的值都是唯一的。2、p、q 为不同节点且均存在于给定的二叉搜索树中。 public class TreeNode { int val; TreeNode left; TreeNode right; TreeNode(int x) { val = x; } } /** * 二叉搜索树的最近公共祖
2020-06-14 10:43:47
105
原创 LeetCode437：路径总和III（二叉树和递归）
路径总和III1、给定一个二叉树，它的每个结点都存放着一个整数值。2、找出路径和等于给定数值的路径总数。3、路径不需要从根节点开始，也不需要在叶子节点结束，但是路径方向必须是向下的（只能从父节点到子节点）。4、二叉树不超过1000个节点，且节点数值范围是 [-1000000,1000000] 的整数。 public class TreeNode { int val; TreeNode left; TreeNode right;
2020-06-14 10:26:44
179
原创 LeetCode257：二叉树的所有路径（二叉树和递归）
二叉树的所有路径给定一个二叉树，返回所有从根节点到叶子节点的路径。 public class TreeNode { int val; TreeNode left; TreeNode right; TreeNode(int x) { val = x; } } /** * 二叉树的所有路径 * @param root * @return */ public List<S
2020-06-14 09:50:15
115
原创 LeetCode112：路径总和（二叉树和递归）
1、给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。说明: 叶子节点是指没有子节点的节点。 public class TreeNode { int val; TreeNode left; TreeNode right; TreeNode(int x) { val = x; } } /** * 给出一棵二叉树及一个sum数字，判断在这棵二叉树上是否存在
2020-06-12 16:58:48
131
空空如也
空空如也
TA创建的收藏夹 TA关注的收藏夹
TA关注的人