qq_39717513的博客

原创 66. 加一

给定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加一。需要考虑到99，999一类数，数组容纳不下，需要建立新数组class Solution { public int[] plusOne(int[] digits) { int len = digits.length; for(int i = len - 1; i >= 0; i--) { digits[i]++; digits[i] %=

原创 58. 最后一个单词的长度

给你一个字符串 s，由若干单词组成，单词前后用一些空格字符隔开。返回字符串中最后一个单词的长度。单词 是指仅由字母组成、不包含任何空格字符的最大子字符串方法1class Solution { public int lengthOfLastWord(String s) { int len=s.length(); int res=0; for(int i=len-1;i>=0;i--){ if(s.charAt(i)!=' '){

原创 20. 有效的括号

给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串 s ，判断字符串是否有效。有效字符串需满足：左括号必须用相同类型的右括号闭合。左括号必须以正确的顺序闭合。class Solution { public boolean isValid(String s) { int n = s.length(); if (n % 2 == 1) { return false; } HashMap&

原创 26. 删除有序数组中的重复项

给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。class Solution { public int removeDuplicates(int[] nums) { if(nums==null||nums.length==1){ return nums.length; }

原创 144. 二叉树的前序遍历

class Solution { ArrayList<Integer> preOrderReverse(TreeNode root) { ArrayList<Integer> result = new ArrayList<Integer>(); preOrder(root, result); return result; } void preOrder(TreeNode root, ArrayLi.

转载 105. 从前序与中序遍历序列构造二叉树

class Solution { public TreeNode buildTree(int[] preorder, int[] inorder) { return buildTreeFunc(preorder,0,preorder.length,inorder,0,inorder.length); } public TreeNode buildTreeFunc(int []preorder,int p_start,int p_end,int []inorder,in.

转载 102. 二叉树的层序遍历

class Solution { public List<List<Integer>> levelOrder(TreeNode root) {if(root==null){ return new ArrayList<List<Integer>>();}List<List<Integer>>res=new ArrayList<List<Integer>>(); // Deque<.

原创 328. 奇偶链表

给定一个单链表，把所有的奇数节点和偶数节点分别排在一起。请注意，这里的奇数节点和偶数节点指的是节点编号的奇偶性，而不是节点的值的奇偶性class Solution { public ListNode oddEvenList(ListNode head) { // 分别定义奇偶链表的 虚拟头结点 和 尾结点 ListNode oddHead = new ListNode(); ListNode oddTail = oddHead; L

转载 24. 两两交换链表中的节点

1、栈class Solution { public ListNode swapPairs(ListNode head) { if(head==null || head.next==null) { return head; } //用stack保存每次迭代的两个节点 Stack<ListNode> stack = new Stack<ListNode>(); ListNode p = new ListNode(-1); ListNode cur =.

转载 求平方根（整数和小数）

一、平方根结果为整数求平方根，返回类型是整数，结果只保留整数的部分，小数部分将被舍去。class Solution { public int mySqrt(int x) { int l = 0; int r = x; int mid = 0; int res = 0; while(l<=r){ mid = (l+r)/2; if((long)mid*mid<

原创 69. x 的平方根

题目计算并返回 x 的平方根，其中 x 是非负整数。由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。使用(long)类型在 mid 很大的时候，mid * mid 有可能会整型溢出，使用 mid * mid > x 不能通过的测试用例class Solution { public int mySqrt(int x) { int l = 0, r = x, ans = -1; while (l <= r) { i

原创 42. 接雨水

思路：动态规划：int[] maxleft+int[] maxright求每一列的水，我们只需要关注当前列，以及左边最高的墙，右边最高的墙就够了。装水的多少，当然根据木桶效应，我们只需要看左边最高的墙和右边最高的墙中较矮的一个就够了。class Solution { public int trap(int[] height) { if (height.length==0||height==null)return 0;int ans=0;int len=height.le.

转载 146. LRU 缓存机制

例子/* 缓存容量为 2 */LRUCache cache = new LRUCache(2);// 你可以把 cache 理解成一个队列// 假设左边是队头，右边是队尾// 最近使用的排在队头，久未使用的排在队尾// 圆括号表示键值对 (key, val)cache.put(1, 1);// cache = [(1, 1)]cache.put(2, 2);// cache = [(2, 2), (1, 1)]cache.get(1); // 返回 1// cache =

原创 155. 最小栈

设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。push(x) —— 将元素 x 推入栈中。pop() —— 删除栈顶的元素。top() —— 获取栈顶元素。getMin() —— 检索栈中的最小元素。思想很简单：“以空间换时间”import java.util.Stack;public class MinStack { // 数据栈 private Stack<Integer> data; // 辅助栈 p

转载 232. 用栈实现队列

思路将一个栈当作输入栈，用于压入 push 传入的数据；另一个栈当作输出栈，用于 pop 和 peek 操作。class MyQueue { Deque<Integer> inStack; Deque<Integer> outStack; public MyQueue() { inStack = new LinkedList<Integer>(); outStack = new LinkedList<In

转载 225. 用队列实现栈

方法一：双队列用A队列保存栈内的元素，用B队列作为入栈的辅助队列class MyStack { Deque<Integer> A,B; public MyStack() { A = new LinkedList<>(); B = new LinkedList<>(); } public void push(int x) { B.offer(x); //先将要插入的元素加入到辅

转载 300. 最长递增子序列

给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。动态规划1、dp[i] 表示：以 nums[i] 结尾 的「上升子序列」的长度。注意：这个定义中 nums[i] 必须被选取，且必须是这个子序列的最后一个元素；2、如果一个较大的数接在较小的数后面，就会形成一个更长的子序列。只要 nums[i] 严格大于在它位置之前的某个数，那么 nums[i] 就可以接在这个数后面形成一个更长的上升子序列3、初始化：dp[i] = 1，11 个字符显然是长度为 11 的上升子序列。4、 输出：

原创 94. 二叉树的中序遍历

1递归class Solution { public List<Integer> inorderTraversal(TreeNode root) { List<Integer> res = new ArrayList<Integer>(); dfs(res,root); return res; } void dfs(List<Integer> res, TreeNode root) { if(root==null) { re.

原创 54. 螺旋矩阵

给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。m == matrix.lengthn == matrix[i].length1 <= m, n <= 10思路对于这种螺旋遍历的方法，重要的是要确定上下左右四条边的位置，那么初始化的时候，上边up就是0，下边down就是m-1，左边left是0，右边right是n-1。然后我们进行while循环，先遍历上边，将所有元素加入结果res，然后上边下移一位，如果此时上边大于下边，说明此时已经遍

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

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。最近公共祖先的定义为：“对于有根树 T 的两个节点 p、q，最近公共祖先表示为一个节点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”class Solution { public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) { /** 注意p,q必然存在树内, 且所有节

原创 JVM整理

原创 java类加载过程

转载 103. 二叉树的锯齿形层序遍历

给定一个二叉树，返回其节点值的锯齿形层序遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。BFS+flag/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.va

转载 415. 字符串相加

给定两个字符串形式的非负整数 num1 和num2 ，计算它们的和。返回一个字符串类型双指针+StringBuilder+reverse()class Solution { public String addStrings(String num1, String num2) { StringBuilder s = new StringBuilder(); int i = num1.length() - 1, j = num2.length() - 1, carry = 0;

原创 买卖股票问题-动态规划

121. 买卖股票的最佳时机（只能买一次）public class Solution { public int maxProfit(int[] prices) { int len = prices.length; // 特殊判断 if (len < 2) { return 0; } int[][] dp = new int[len][2]; // dp[i][0] 下标

原创 141. 环形链表 142.环形链表二

如果链表中存在环，则返回 true 。 否则，返回 false快慢指针public class Solution { public boolean hasCycle(ListNode head) { ListNode fast=head; ListNode slow=head; while(fast!=null&&fast.next!=null){ fast=fast.next.next;slow=slow

原创 java内部类

原创 160. 相交链表

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。图示两个链表在节点 c1 开始相交：public class Solution { public ListNode getIntersectionNode(ListNode headA, ListNode headB) { ListNode pa=headA,pb=headB; while(pa!=pb){

转载 10种排序算法

LeetCode总结1 选择排序（了解）2 插入排序（熟悉）3 归并排序（重点）https://www.cnblogs.com/chengxiao/p/6129630.html4、快速排序（重点）5、堆排序（堆很重要，堆排序根据个人情况掌握）

转载 15. 三数之和

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。注意：答案中不可以包含重复的三元组。class Solution { public List<List<Integer>> threeSum(int[] nums) { List<List<Integer>>lists=new ArrayList<>();

转载 215. 数组中的第K个最大元素

借助 partition 操作定位到最终排定以后索引为 len - k 的那个元素（特别注意：随机化切分元素）partition（切分）操作，使得：对于某个索引 j，nums[j] 已经排定，即 nums[j] 经过 partition（切分）操作以后会放置在它 “最终应该放置的地方”；nums[left] 到 nums[j - 1] 中的所有元素都不大于 nums[j]；nums[j + 1] 到 nums[right] 中的所有元素都不小于 nums[j]。import java.util.R

转载 206. 反转链表&& 92. 反转链表 II && 25. K 个一组翻转链表

反转链表class Solution { public ListNode reverseList(ListNode head) { ListNode pre=null; ListNode cur=head; while(cur!=null){ ListNode temp=cur.next; cur.next=pre; pre=cur; cur=temp; } return pre

转载 82. 删除排序链表中的重复元素&& 83. 删除排序链表中的重复元素

只保留原始链表中 没有重复出现 的数字思路由于给定的链表是排好序的，因此重复的元素在链表中出现的位置是连续的，因此我们只需要对链表进行一次遍历，就可以删除重复的元素。由于链表的头节点可能会被删除，因此我们需要额外使用一个哑节点（dummy node）指向链表的头节点。具体地，我们从指针 cur 指向链表的哑节点，随后开始对链表进行遍历。如果当前 cur.next 与 cur.next.next 对应的元素相同，那么我们就需要将cur.next 以及所有后面拥有相同元素值的链表节点全部删除。我们记下这

转载 42. 接雨水

给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。思路对于数组中的每个元素，我们找出下雨后水能达到的最高位置，等于两边最大高度的较小值减去当前高度的值。public int trap(int[] height) { if (height == null || height.length == 0) return 0; int ans = 0; int size = height.length; int[]

转载 32. 最长有效括号

给你一个只包含 ‘(’ 和 ‘)’ 的字符串，找出最长有效（格式正确且连续）括号子串的长度思路对于遇到的每个 ‘(’ ，我们将它的下标放入栈中对于遇到的每个‘)’ ，我们先弹出栈顶元素表示匹配了当前右括号：如果栈为空，说明当前的右括号为没有被匹配的右括号，我们将其下标放入栈中来更新我们之前提到的「最后一个没有被匹配的右括号的下标」如果栈不为空，当前右括号的下标减去栈顶元素即为「以该右括号为结尾的最长有效括号的长度」我们从前往后遍历字符串并更新答案即可。需要注意的是，如果一开始栈为空，第一个字

转载 5. 最长回文子串

给你一个字符串 s，找到 s 中最长的回文子串。中心扩散法+动态规划用一个 boolean dp[l][r] 表示字符串从 i 到 j 这段是否为回文。试想如果 dp[l][r]=true，我们要判断 dp[l-1][r+1] 是否为回文。只需要判断字符串在(l-1)和（r+1)两个位置是否为相同的字符，减少了很多重复计算。动态规划关键是找到初始状态和状态转移方程。初始状态，l=r 时，此时 dp[l][r]=true。状态转移方程，dp[l][r]=true 并且(l-1)和（r+1)两个位置

转载 239. 滑动窗口最大值

给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。返回滑动窗口中的最大值。思路遍历数组，将 数 存放在双向队列中，并用 L,R 来标记窗口的左边界和右边界。队列中保存的并不是真的 数，而是该数值对应的数组下标位置，并且数组中的数要从大到小排序。如果当前遍历的数比队尾的值大，则需要弹出队尾值，直到队列重新满足从大到小的要求。刚开始遍历时，L 和 R 都为 0，有一个形成窗口的过程，此过程没有最大

转载 219. 存在重复元素 II

给定一个整数数组和一个整数 k，判断数组中是否存在两个不同的索引 i 和 j，使得 nums [i] = nums [j]，并且 i 和 j 的差的 绝对值 至多为 k。维护一个哈希表，里面始终最多包含 k 个元素，当出现重复值时则说明在 k 距离内存在重复元素每次遍历一个元素则将其加入哈希表中，如果哈希表的大小大于 k，则移除最前面的数字时间复杂度：O(n)O(n)，nn 为数组长度class Solution { public boolean containsNearbyDuplica

转载 209. 长度最小的子数组

给定一个含有 n 个正整数的数组和一个正整数 target 。找出该数组中满足其和 ≥ target 的长度最小的 连续子数组 [numsl, numsl+1, …, numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。我们把数组中的元素不停的入队，直到总和大于等于 s 为止，接着记录下队列中元素的个数，然后再不停的出队，直到队列中元素的和小于 s 为止（如果不小于 s，也要记录下队列中元素的个数，这个个数其实就是不小于 s 的连续子数组长度，我们要记录最小的即可）

原创 3. 无重复字符的最长子串

给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。class Solution { public int lengthOfLongestSubstring(String s) { if (s.length()==0) return 0; HashMap<Character, Integer> map = new HashMap<Character, Integer>(); int max = 0;