qq_29494693的博客

题目题源题目码源class Solution { public int reversePairs(int[] nums) { int len = nums.length; if (len < 2) return 0; int[] copy = new int[len]; for (int i = 0; i < len; i++) { copy[i] = nums[i];

题目题源代码class Solution { public int mySqrt(int x) { // return (int)Math.sqrt(x); int left = 0, right = x, ans = -1; while(left <= right) { int mid = left + (right - left) / 2; if ((long)mid * mid &lt

题目题源代码对比下图理解：码源class Trie { private Trie[] children; // isEnd用于表示该节点是否为字符串的结尾 private boolean isEnd; /** Initialize your data structure here. */ public Trie() { children = new Trie[26]; isEnd = false; }

题目题源代码class Solution { public String longestPalindrome(String s) { if (s == null || s.length() < 1) return ""; int start = 0, end = 0; for (int i = 0; i < s.length(); i++) { int len1 = expandAroundCenter(s,

代码代码方法1，标准方法class Solution { public boolean isPowerOfTwo(int n) { // 方法1，标准方法 if(n <= 0) return false; // 判断是否为 2 的幂 return (n & (n-1)) == 0; }}方法2，暴力法class Solution { public boolean is

题目题源代码码源class Solution { public int findKthNumber(int n, int k) { long cur = 1; k -= 1; while(k > 0){ int nodes = getNodes(n, cur); // 当前节点的总数小于要查找的第k位，则右移 if(k >= nodes){

题目代码class Solution { public int carFleet(int target, int[] position, int[] speed) { int N = position.length; Car[] cars = new Car[N]; for (int i = 0; i < N; i++) // 计算的不考虑其他车时的到达target的时间 cars[i] =

题目题源代码码源class Solution { public String minNumber(int[] nums) { String[] strs = new String[nums.length]; for (int i = 0; i < nums.length; i++) strs[i] = String.valueOf(nums[i]); Arrays.sort(strs,(x ,

题目题源代码class Solution { // 方法1，时间复杂度O（n） public int search1(int[] nums, int target) { for (int i = 0; i < nums.length; i++) { if (target == nums[i]) { return i; } } return -1;

题目题源代码码源class Solution { public int minDistance(String word1, String word2) { int n = word1.length(); int m = word2.length(); // 有一个字符串为空串 if (n * m == 0) { return n + m; } // DP 数组

题目题源代码class Solution { public int lengthOfLongestSubstring(String s) { Set<Character> set = new HashSet<>(); int n = s.length(); // rk保存上一次遍历的末尾位置，这个rk指针不会回退，因为i + 1到rk这个位置一定不会重复，直接考虑rk + 1的位置即可

题目题源代码码源class Solution { List<String> res = new LinkedList<>(); char[] c; public String[] permutation(String s) { c = s.toCharArray(); dfs(0); return res.toArray(new String[res.size()]); } v

题目题源代码码源class Solution { public int lengthOfLIS(int[] nums) { int len = 1, n = nums.length; if (n == 0) { return 0; } int[] d = new int[n + 1]; d[len] = nums[0]; for (int i = 1; i < n;

题目题源代码class Solution { public ListNode reverseList(ListNode head) { ListNode pre = null; ListNode cur = head; while (cur != null) { ListNode nextNode = cur.next; cur.next = pre; pre = cur;

题目链接：https://leetcode-cn.com/problems/invert-binary-tree/代码class Solution { public TreeNode invertTree(TreeNode root) { if (root == null) return null; TreeNode right = invertTree(root.right); TreeNode left = inve

题目代码class Solution { public int climbStairs(int n) { if (n == 1) return 1; int[] dp = new int[n + 1]; dp[1] = 1; dp[2] = 2; for (int i = 3; i <= n; i++) { dp[i] = dp[i - 1] + dp[i -

题目代码先排序 + 前后双指针class Solution { public List<List<Integer>> threeSum(int[] nums) { int n = nums.length; Arrays.sort(nums); List<List<Integer>> ans = new ArrayList<List<Integer>>();

题目代码码源class Solution { public int maxProduct(int[] nums) { int maxF = nums[0], minF = nums[0], ans = nums[0]; int length = nums.length; for (int i = 1; i < length; ++i) { int mx = maxF, mn = minF;

题目代码方法1，进阶法，hash：码源class Solution { //方法1 public int firstMissingPositive(int[] nums) { int n = nums.length; for (int i = 0; i < n; i++) { if (nums[i] <= 0) { nums[i] = n + 1; }

题目代码beforeNumMax 表示前一个数的最大连续子数组，当前num的最大连续子数组仅仅跟当前数的前一个数的最大连续子数组相关。class Solution { public int maxSubArray(int[] nums) { int maxSum = nums[0]; int beforeNumMax = 0; for (int num : nums) { beforeNumMax = Math.max(

题目代码码源class Solution { public List<List<Integer>> combinationSum(int[] candidates, int target) { int len = candidates.length; List<List<Integer>> la = new ArrayList<>(); if (len == 0)

题目代码方法1，简单易想法：有序的合并成一个数组，取其中位数即可。class Solution { public double findMedianSortedArrays(int[] nums1, int[] nums2) { int[] nums; int m = nums1.length; int n = nums2.length; nums = new int[m + n]; if

题目代码码源动态规划法class Solution { public int coinChange(int[] coins, int amount) { int max = amount + 1; int[] dp = new int[amount + 1]; Arrays.fill(dp,max); dp[0] = 0; for (int i = 1; i <= amount; i++)

题目代码双指针法:左边，以左指针遍历过的最大高度记为left_max，然后左指针向右走下一格，如果高度大于left_max则更新left_max，否则计算接水量，计算方式为left_max - 左指针所在当前位置的高度即为这个位置接到的水量；右侧，同理；class Solution { public int trap(int[] height) { int left = 0; int right = height.length-1; int

题目代码使用两个堆，一个是大顶堆，一个是小顶堆。大顶堆中最大的数小于等于小顶堆中最小的数；保证这两个堆中的元素个数的差不超过 1。若数据总数为偶数，当这两个堆建好之后，中位数就是这两个堆顶元素的平均值。当数据总数为奇数时，根据两个堆的大小，中位数一定在数据多的堆的堆顶。class MedianFinder { private PriorityQueue<Integer> maxHeap; private PriorityQueue<Integer> min

题目代码class Solution { // 方法1 暴力法 public int[] twoSum(int[] nums, int target) { for (int i = 0; i < nums.length; i++) { for (int j = i+1; j < nums.length; j++) { if (target - nums[i] == nums[j])

题目代码class Solution { public int findRepeatNumber(int[] nums) { Set<Integer> set = new HashSet<>(); int repeat = -1; for (int num: nums) { if (!set.add(num)) { repeat = num;

题目解析码源代码class Solution { public int singleNumber(int[] nums) { int single = 0; for (int num : nums) { single ^= num; } return single; }}

题目代码方法1，实现最简单的方法// 方法1，思路最简单排序public int[] getLeastNumbers(int[] arr, int k) { Arrays.sort(arr); int[] result = new int[k]; for (int i = 0; i< k; i++) { result[i] = arr[i]; } return result;}方法2，堆排序码源// 方法2，堆排序，Prior

题目代码方法1，广度优先法： // 方法1，广度优先遍历class Solution { public List<String> binaryTreePaths(TreeNode root) { List<String> paths = new ArrayList<>(); if (root == null) return paths; Queue&lt

题目代码class Solution { int ans = 1; public int diameterOfBinaryTree(TreeNode root) { depth(root); return ans-1; } public int depth(TreeNode node) { if (node == null) return 0; // 获取左孩子为根的树的深度 int le

题目题源样例1：输入：LRUCache(2)set(2, 1)set(1, 1)get(2)set(4, 1)get(1)get(2)输出：[1,-1,1]解释：cache上限为2，set(2,1)，set(1, 1)，get(2) 然后返回 1，set(4,1) 然后 delete (1,1)，因为 （1,1）最少使用，get(1) 然后返回 -1，get(2) 然后返回 1样例2：输入：LRUCache(1)set(2, 1)get(2)set(3, 2)ge

代码public class Solution { /** * @param root: A Tree * @return: Preorder in ArrayList which contains node values. */ private List<Integer> list = new ArrayList<Integer>(); public List<Integer> preorderTraversa.

题目代码 //方法1，递归方法public boolean isValidBST(TreeNode root) { if (root == null || (root.left == null && root.right == null)) return true; return helper(root,Long.MIN_VALUE,Long.MAX_VALUE);}public boolean helper(TreeNode node, long minVa

题目代码思路如果二叉树B是二叉树A的子树，A树中必然存在B树的根节点。所以，先比较A树的根节点与B树的根节点，如果相同，则采用递归方法比较A树的左子树和B树的左子树以及比较A树的右子树和B树的右子树。如果不相同，则用A树根节点的左孩子与B树的跟节点比较，这里调用的是isSubStructure方法而不是helper方法是因为A树根节点的左孩子不一定存在。如果还不相同，同理用A树根节点的右孩子与B树的跟节点比较。class Solution { public boolean isSubSt

题目代码官方代码public ListNode reverseKGroup(ListNode head, int k) { ListNode hair = new ListNode(0); hair.next = head; ListNode pre = hair; while (head != null) { ListNode tail = pre; // 查看剩余部分长度是否大于等于 k for (int i

题目代码思路维护两个栈，一个是主栈，一个是最小栈。1、每次push操作，将元素插入主栈栈顶时，同步判断是否小于等于最小栈的栈顶元素，如果是则同步插入最小栈。2、每次pop操作，主栈栈顶元素如果等于最小栈栈顶元素，则同步出栈。class MinStack { private Stack<Integer> stack; private Stack<Integer> miniStack; /** initialize your data struct

题目代码思路从左至右扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算（次顶元素和栈顶元素），并将结果入栈;重复上述过程直到表达式最右端，最后运算得出的值即为表达式的结果。注意：弹出的第一个数是操作的第二个数，弹出的第二个数是操作的第一个数。 public int evalRPN(String[] tokens) { Stack<String> stack = new Stack<>(); for

题目代码思路双栈实现，一个只负责入，另一个只负责出。class CQueue { Stack<Integer> stackIn = null; Stack<Integer> stackOut =null; public CQueue() { stackIn = new Stack<>(); stackOut = new Stack<>(); } publ

题目代码思路 遇到右括号一定要在栈顶中取到对应的左括号，否则返回false。 public boolean isValid(String s) { int n = s.length(); // 奇数个括号直接返回false if (n % 2 == 1) { return false; } // 将各种括号存入HashMap中，右括号为key左括号为value Map<Character, Character>