自定义博客皮肤VIP专享

*博客头图:

格式为PNG、JPG,宽度*高度大于1920*100像素,不超过2MB,主视觉建议放在右侧,请参照线上博客头图

请上传大于1920*100像素的图片!

博客底图:

图片格式为PNG、JPG,不超过1MB,可上下左右平铺至整个背景

栏目图:

图片格式为PNG、JPG,图片宽度*高度为300*38像素,不超过0.5MB

主标题颜色:

RGB颜色,例如:#AFAFAF

Hover:

RGB颜色,例如:#AFAFAF

副标题颜色:

RGB颜色,例如:#AFAFAF

自定义博客皮肤

-+
  • 博客(59)
  • 收藏
  • 关注

原创 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] %=

2021-09-05 20:59:07 13

原创 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)!=' '){

2021-09-05 20:18:15 17

原创 20. 有效的括号

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

2021-09-05 16:05:23 20

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

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

2021-09-05 16:03:34 15

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

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

2021-09-04 16:03:13 14

转载 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.

2021-09-04 15:58:27 14

转载 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<.

2021-09-04 15:56:27 23

原创 328. 奇偶链表

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

2021-08-29 10:14:56 22

转载 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 =.

2021-08-29 09:51:03 17

转载 求平方根(整数和小数)

一、平方根结果为整数求平方根,返回类型是整数,结果只保留整数的部分,小数部分将被舍去。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<

2021-08-20 09:59:19 447

原创 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

2021-08-16 10:40:25 25

原创 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.

2021-08-15 10:57:49 10

转载 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 =

2021-08-14 21:46:39 74

原创 155. 最小栈

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

2021-08-14 16:06:39 16

转载 232. 用栈实现队列

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

2021-08-14 15:46:50 16

转载 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); //先将要插入的元素加入到辅

2021-08-14 15:42:00 18

转载 300. 最长递增子序列

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

2021-08-14 15:02:10 40

原创 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.

2021-08-14 10:20:16 32

原创 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,然后上边下移一位,如果此时上边大于下边,说明此时已经遍

2021-08-11 10:07:43 29

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

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

2021-08-10 20:20:04 17

原创 JVM整理

2021-08-09 10:41:54 17

原创 java类加载过程

2021-07-29 19:41:13 22

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

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

2021-07-28 21:55:37 12

转载 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;

2021-07-28 21:28:09 22

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

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] 下标

2021-07-19 22:52:40 56 2

原创 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

2021-07-18 21:06:54 24

原创 java内部类

2021-07-18 21:04:45 11

原创 160. 相交链表

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

2021-07-17 22:24:13 18 1

转载 10种排序算法

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

2021-07-17 22:21:25 26

转载 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<>();

2021-07-17 20:56:08 19

转载 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

2021-07-15 22:40:54 8

转载 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

2021-07-15 10:42:31 23

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

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

2021-07-15 09:43:39 24

转载 42. 接雨水

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

2021-07-15 09:10:23 14

转载 32. 最长有效括号

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

2021-07-13 22:12:42 15

转载 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)两个位置

2021-07-12 22:50:10 16

转载 239. 滑动窗口最大值

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

2021-07-12 21:49:07 25

转载 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

2021-07-12 08:35:26 10

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

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

2021-07-11 20:21:47 9

原创 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;

2021-07-11 20:11:13 11

空空如也

空空如也

TA创建的收藏夹 TA关注的收藏夹

TA关注的人

提示
确定要删除当前文章?
取消 删除