hazy的leetcode刷题笔记(二)

leetcode.222:完全二叉树的节点个数-每日一题
给出一个完全二叉树，求出该树的节点个数。
说明：
完全二叉树的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2h 个节点。
示例:
输入:
1
/
2 3
/ \ /
4 5 6
输出: 6

/*** Definition for a binary tree node.* public class TreeNode {*     int val;*     TreeNode left;*     TreeNode right;*     TreeNode(int x) { val = x; }* }*/
class Solution {public int countNodes(TreeNode root) {/*来自评论区，相对于暴力递归更好的解法：完全二叉树的高度可以直接通过不断地访问左子树就可以获取判断左右子树的高度: 如果相等说明左子树是满二叉树, 然后进一步判断右子树的节点数(最后一层最后出现的节点必然在右子树中)如果不等说明右子树是深度小于左子树的满二叉树, 然后进一步判断左子树的节点数(最后一层最后出现的节点必然在左子树中)*/if(root == null) return 0;//获得左右子树的深度int ld = getDepth(root.left);int rd = getDepth(root.right);// 1(根节点) + (1 << ld)-1(左完全左子树节点数) + 右子树节点数量if(ld == rd) return (1 << ld) + countNodes(root.right);// 1(根节点) + (1 << rd)-1(右完全右子树节点数) + 左子树节点数量else return(1 << rd) + countNodes(root.left);}//获得左右子树的深度private int getDepth(TreeNode root) {int dept = 0;while(root != null) {root = root.left;dept++;}return dept;}
}

leetcode-309:最佳买卖股票时机含冷冻期-hot100
给定一个整数数组，其中第 i 个元素代表了第 i 天的股票价格。
设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:
你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。
示例:
输入: [1,2,3,0,2]
输出: 3
解释: 对应的交易状态为: [买入, 卖出, 冷冻期, 买入, 卖出]

class Solution {public int maxProfit(int[] prices) {/*基本思路：动态规划法：如果今天不持有股票，说明是 昨天也不持有 / 昨天持有今天卖掉如果今天持有股票，说明是 昨天本就持有 / 前天卖掉今天买入只要每次选择两个情况中的较大者即可*///特殊输入判断if(prices.length == 0 || prices.length == 1) return 0;//分别对应昨天不持有 昨天持有 前天的不持有int dp_0_i, dp_1_i, dp_0_i_2;dp_0_i = 0;dp_1_i = - prices[0];dp_0_i_2 = 0;for(int i = 1; i < prices.length; i++) {//记录昨天的不持有，到明天就会变成前天的不持有int temp = dp_0_i;dp_0_i = Math.max(dp_0_i, dp_1_i + prices[i]);dp_1_i = Math.max(dp_1_i, dp_0_i_2 - prices[i]);dp_0_i_2 = temp;}return dp_0_i;}
}

leetcode.454:四数相加II-每日一题
给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ，使得 A[i] + B[j] + C[k] + D[l] = 0。
为了使问题简单化，所有的 A, B, C, D 具有相同的长度 N，且 0 ≤ N ≤ 500 。所有整数的范围在 -228 到 228 - 1 之间，最终结果不会超过 231 - 1 。
例如:
输入:
A = [ 1, 2]
B = [-2,-1]
C = [-1, 2]
D = [ 0, 2]
输出:
2
解释:
两个元组如下:

(0, 0, 0, 1) -> A[0] + B[0] + C[0] + D[1] = 1 + (-2) + (-1) + 2 = 0 4

(1, 1, 0, 0) -> A[1] + B[1] + C[0] + D[0] = 2 + (-1) + (-1) + 0 = 0

class Solution {public int fourSumCount(int[] A, int[] B, int[] C, int[] D) {/*基本思路：如果直接四层循环那肯定复杂度太高了，因此可以拆分成两个n^2的问题：A + B = - (C + D) 利用哈希表求得所有A+B的情况，再求得所有C+D同时和哈希表进行比较，如果存在就加上对应的次数 */if(A.length == 0) return 0;//记录A+B中某种情况出现的次数Map<Integer, Integer> record = new HashMap<Integer, Integer>();//最后的组合结果int result = 0;//求A+B的所有情况，存在map中for(int i = 0; i < A.length; i++) {for(int j = 0; j < A.length; j++) {if(record.get(A[i] + B[j]) == null) record.put(A[i] + B[j], 1);else record.put(A[i] + B[j], record.get(A[i] + B[j]) + 1);}}//求C+D的所有情况并让结果加上对应的次数for(int i = 0; i < A.length; i++) {for(int j = 0; j < A.length; j++) {if(record.get(-(C[i] + D[j])) != null) result += record.get(-(C[i] + D[j]));}}return result;}
}

leetcode.976:三角形的最大周长-每日一题
给定由一些正数（代表长度）组成的数组 A，返回由其中三个长度组成的、面积不为零的三角形的最大周长。
如果不能形成任何面积不为零的三角形，返回 0。
示例 1：
输入：[2,1,2]
输出：5
示例 2：
输入：[1,2,1]
输出：0

class Solution {public int largestPerimeter(int[] A) {/* 基本思路：暴力算法不可取  先进行排序，取前三大的长度，如果前三大长度不符合说明 第二大和第三大加起来没有第一大，因此整体直接往后移一位*/Arrays.sort(A);for(int i = A.length - 1; i >= 2; i--) {if(A[i - 1] + A[i - 2] > A[i]) return A[i - 1] + A[i - 2] + A[i];}return 0;}
}

leetcode.56:合并区间-hot100
给出一个区间的集合，请合并所有重叠的区间。
示例 1:
输入: intervals = [[1,3],[2,6],[8,10],[15,18]]
输出: [[1,6],[8,10],[15,18]]
解释: 区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].
示例 2:
输入: intervals = [[1,4],[4,5]]
输出: [[1,5]]
解释: 区间 [1,4] 和 [4,5] 可被视为重叠区间

class Solution {public int[][] merge(int[][] intervals) {/* 基本思路：按区间的左边进行排序（一开始我以为得用右边进行排序）每次选取最左边的区间，然后进行合并，接下来继续选择生下的区间最左边的进行合并*/if(intervals == null || intervals.length == 0 || intervals.length == 1) return intervals;//对区间左边进行排序Arrays.sort(intervals, (a1, a2) -> a1[0] - a2[0]);//记录当前的位置和总长度int now = 0;int n = intervals.length;ArrayList<int[]> record = new ArrayList<int[]>();while(now < n) {//当前区间的左右范围int left = intervals[now][0];int right = intervals[now][1];//如果接下来有区间在当前区间范围内就进行合并，如果没有就说明当前是一个独立区间while(now < n - 1 && right >= intervals[now + 1][0]) {right = Math.max(right, intervals[now + 1][1]);now++;}record.add(new int[] {left, right});now++;}return record.toArray(new int[record.size()][2]);}
}

leetcode.767:重构字符串-每日一题
给定一个字符串S，检查是否能重新排布其中的字母，使得两相邻的字符不同。
若可行，输出任意可行的结果。若不可行，返回空字符串。
示例 1:
输入: S = “aab”
输出: “aba”
示例 2:
输入: S = “aaab”
输出: “”
注意: S 只包含小写字母并且长度在[1, 500]区间内。

class Solution {public String reorganizeString(String S) {/*基本思路：扫描所有的字符，获得每个字符出现的次数接下来拼接字符串：每次都选取：与上个字符不同且出现次数最多的字符选取完后拼接起来然后次数减一，再标记这个字符为上个字符如果找不到这个字符，说明无法生成最终的字符，直接返回空串*///字符记录次数int[] record = new int[26];Arrays.fill(record, 0);for(int i = 0; i < S.length(); i++) {record[S.charAt(i) - 'a'] += 1;}//拼接字符串StringBuilder result = new StringBuilder();//选取第一个字符int last = -1;int max = 0;for(int i = 0; i < 26; i++) {if(record[i] > max) {max = record[i];last = i;}}result.append((char)('a' + last));record[last]--;while(result.length() < S.length()) {int index = -1;max = 0;//循环，找出下一个要的字符for(int i = 0; i < 26; i++) {if(record[i] > max && i != last) {max = record[i];index = i;} }//如果找到就拼接，找不到就直接返回if(index != -1) {result.append((char)('a' + index));record[index]--;last = index;                }else {return "";}}return result.toString();}
}

leetcode.34:在排序数组中查找元素的第一个和最后一个位置-每天一题
给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。
如果数组中不存在目标值 target，返回 [-1, -1]。
进阶：你可以设计并实现时间复杂度为 O(log n) 的算法解决此问题吗？
示例 1：
输入：nums = [5,7,7,8,8,10], target = 8
输出：[3,4]
示例 2：
输入：nums = [5,7,7,8,8,10], target = 6
输出：[-1,-1]

class Solution {public int[] searchRange(int[] nums, int target) {/*基本思路：时间复杂度为O(log n)那一定是二分查找啦不过其中要有一个找到目标值后，向两端扩散找最左和最右的过程*/int left = 0; int right = nums.length;int[] result = new int[2];Arrays.fill(result, -1);while(left < right) {if(target < nums[(left + right) / 2]) {right = (left + right) / 2;}else if(target > nums[(left + right) / 2]) {left = (left + right) / 2 + 1;}else {result[0] = (left + right) / 2;result[1] = (left + right) / 2;//向两端扩散找最左、最右while(result[0] - 1 >= 0 && nums[result[0] - 1] == target) result[0]--;while(result[1] + 1 < nums.length && nums[result[1] + 1] == target) result[1]++;return result;}}return result;}
}

hazy的leetcode刷题笔记(二)相关推荐

LeetCode刷题笔记2——数组2
LeetCode刷题笔记2--数组2 重塑数组题目在 MATLAB 中,有一个非常有用的函数 reshape ,它可以将一个 m x n 矩阵重塑为另一个大小不同(r x c)的新矩阵,但保留其原 ...
LeetCode刷题笔记汇总
LeetCode刷题笔记汇总第一次刷LeetCode写的一些笔记. 1.两数之和 3.无重复字符的最长子串 15.三数之和 18.四数之和 19.删除链表的倒数第 N 个结点 20.有效的括号 21 ...
leetcode刷题笔记——二分查找
leetcode刷题笔记--二分查找目前完成的贪心相关的leetcode算法题序号: 中等:80,81 困难:4 来源:力扣(LeetCode) 链接:https://leetcode-cn.com ...
LeetCode刷题笔记（算法思想四）
LeetCode刷题笔记(算法思想四) 七.动态规划斐波那契数列 70. 爬楼梯 198. 打家劫舍 213. 打家劫舍 II 信件错排母牛生产矩阵路径 64. 最小路径和 62. 不同路径 ...
卷进大厂系列之LeetCode刷题笔记：二分查找（简单）
LeetCode刷题笔记:二分查找(简单) 学算法,刷力扣,加油卷,进大厂! 题目描述涉及算法题目解答学算法,刷力扣,加油卷,进大厂! 题目描述力扣题目链接给定一个 n 个元素有序的(升序) ...
小何同学的leetcode刷题笔记基础篇（01）整数反转
小何同学的leetcode刷题笔记基础篇(01)整数反转[07] *** [01]数学取余法*** 对数字进行数位操作时,常见的方法便是用取余的方法提取出各位数字,再进行操作操作(1):对10取余 ...
【leetcode刷题笔记】动态规划
#[leetcode刷题笔记]动态规划石子游戏 public boolean stoneGame(int[] piles) {int N = piles.length;// dp[i][j] is ...
LeetCode刷题笔记-动态规划-day4
文章目录 LeetCode刷题笔记-动态规划-day4 55. 跳跃游戏 1.题目 2.解题思路 3.代码 45. 跳跃游戏 II 1.题目 2.解题思路 3.代码 LeetCode刷题笔记-动态规划 ...
LeetCode刷题笔记- 15.三数之和
LeetCode刷题笔记- 15.三数之和 C语言题目注意点 C语言 /*** Return an array of arrays of size *returnSize.* The sizes ...
LeetCode刷题笔记第6题：Z字形变换
LeetCode刷题笔记第6题:Z字形变换想法: 要完成字符串根据给定的行数从上往下,从左到右完成Z字形排列.当只有一行时直接返回原字符串,当行数大于1时,先以行数构建一个行数数值个空字符串的列表, ...

hazy的leetcode刷题笔记(二)

hazy的leetcode刷题笔记(二)相关推荐

最新文章

热门文章