qq_40147944的博客

思路：DFS。值为1的点是为岛屿，上下左右若有相邻为1的点，算同一个岛屿。DFS遍历，遇到1就算一个岛屿，岛屿总数+1，然后将其变为0，再遍历其相邻的上下左右，若有值为1的点，将其变为0，岛屿总数不变。代码：class Solution { public int numIslands(char[][] grid) { if (grid == null || grid.length == 0) { return 0; } ...

思路：刚开始没看清题目说的是二叉搜索树，以为是普通的二叉树，便想着直接BFS，再排下序，就完了。后来看见是二叉搜索树，便用中序遍历，遍历到第K个结点就是答案。代码：/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeN...

思路：BFS遍历，遍历的时候每行末尾加个null，然后串联起来。代码：/*// Definition for a Node.class Node { public int val; public Node left; public Node right; public Node next; public Node() {} public Node(int _val) { val = _val; } ..

/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.val = val; } * TreeNode(int val, TreeNode left, TreeNode right...

思路：二叉树的层次遍历，遍历的时候用一个Boolean类型的值辨别方向是从左往右还是从右往左。代码：/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.val = val; } * ..

迭代代码：/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.val = val; } * TreeNode(int val, TreeNode left, TreeNo...

思路：双指针，先比较两个链表的长度，使双指针在同一起跑线上，然后同时向后遍历，相遇则说明有交点。代码：/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { * val = x; * next = null; * } * } */p...

思路：通过指针，将奇偶节点分开，创建奇节点链和偶节点链，最后再连起来。代码：/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode() {} * ListNode(int val) { this.val = val; } * ListNode(int val, ListNode next..

思路：很简单，从表头开始对应相加，标记一下是否进位，题目说了每个节点只能是个位数，所以进位只能是1。代码：/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode() {} * ListNode(int val) { this.val = val; } * ListNode(int va...

思路：这个题中的递增三元组的数组下标不是必须要连续的，但必须是递增的，定义两个指针first和second，分别指向数组中的最小值和次小值，初始化为Integer.MAX_VALIUE，遍历数组，首先和first比较，当遍历的值小于等于first时，将其赋给first，继续遍历，当遍历的值大于first小于second时，将其赋给second，继续遍历。只要后边遍历的值大于second，即存在递增三元组，返回true。注意：1.因为second的初始值是Integer.MAX_VALUE，所以...

思路：遍历字符串中的每一个字符，然后以当前字符为中心向两边遍历，得到最长回文子串；注意遍历的时候，把紧挨着的相同的字符看作一个字符，因为紧挨着的相同的字符一定是回文串。代码：class Solution { public String longestPalindrome(String s) { if (s.length() < 2) { return s; } int maxLen = 0; ...

思路：双指针 + HashSet，遍历时记录最大值。这个题只要长度，没要具体的子串，如果要返回具体的字符串的话，好像用HashSet就不好用了，因为HashSet没有get方法。也想过用HashMap,但还是不太会用，不熟练。代码：class Solution { public int lengthOfLongestSubstring(String s) { HashSet Maxset = new HashSet(); int Max_length ...

思路：Map + 排序。因为两个互为字母异位词字符串其字母都是一样的，只是顺序不同。所以先排序，排序后都是一样的，通过排序后的字符串做为Map中的“键”，排序之前的字符串做为”值“。class Solution { public List<List<String>> groupAnagrams(String[] strs) { List<List<String>> lists = new ArrayList (); ..

思路：直接对矩阵进行遍历，遇到0便将其所在的行和列置零，置零前要标记出行列中本身已是0 的位置。代码：class Solution { public void setZeroes(int[][] matrix) { int m = matrix.length;//行 int n = matrix[0].length;//列 boolean [][] b = new boolean[m][n];//标记数组，区分数列中的0是原先就有的还是后..

思路： 先对数组排序，三个数字固定第一个，后边用双指针遍历，找出其和等于固定数字相反数的两个值。同时在遍历的过程中删掉重复值。代码：class Solution { public List<List<Integer>> threeSum(int[] nums) { List <List<Integer>> list = new ArrayList (); int l = nums.length; ...

方法一：纯暴力。每个都比较一下，效率很低：class Solution { public int missingNumber(int[] nums) { int l = nums.length; int temp = 0; for (int i = 0; i <= l; i++) { boolean b = false; for (int j = 0; j < l; j++) ...

思路：这个题是典型的栈的应用。遍历字符串中的所有字符1，如果遇到了左括号，就把对应的右括号压栈。2，如果遇到了右括号1）查看栈是否为空，如果为空，说明不能构成有效的括号，直接返回false。2）如果栈不为空，栈顶元素出栈，然后判断出栈的这个元素是否等于这个右括号，如果不等于，说明不匹配，直接返回false。如果匹配，就继续判断字符串的下一个字符。3，最后如果栈为空，说明是完全匹配，是有效的括号，否则如果栈不为空，说明不完全匹配，不是有效的括号。代码：class ...

思路：可以看到，三角两边值都是1，内部的值s[i][j] = s[i-1][j-1] + s[i-1][j]。所以直接写代码：class Solution { public List<List<Integer>> generate(int n) { List<List<Integer>> list = new ArrayList<>(); for (int i = 0; i < n; i++...

思路：提示中输入是一个长度为32多二进制字符串，因此循环32次，每次循环中把输入的最后一位放到一个新的二进制字符串中。方法是取0作为新的二进制字符串temp，先把temp向左移动一位，然后把输入n的最后一位放到temp的最后一位（其实就是通过或运算使temp的最后一位变成n的最后一位），再把n向右移一位。代码：public class Solution { // you need treat n as an unsigned value public int reverseBits..

思路：先异或再统计结果中1的个数。代码：class Solution { public int hammingDistance(int x, int y) { int count = 0; int z = x^y; for (int i = 0; i < 32; i++) { if (((z>>>i)&1) == 1) { count++; ..

题目提示里说了输入长度是32位的二进制，因此把n右移32次（从0开始），每次都和1进行“与”运算，值为1说明含有1。代码：public class Solution { // you need to treat n as an unsigned value public int hammingWeight(int n) { int count = 0; for (int i = 0; i < 32; i++) { ...

public int romanToInt(String s) { int sum = 0; //前一个数字表示的值 int preNum = getValue(s.charAt(0)); for (int i = 1; i < s.length(); i++) { int num = getValue(s.charAt(i)); //如果前一个数字比现在数字小，说明 ...

暴力：class Solution { public boolean isPowerOfThree(int n) { if (n <= 0) { return false; } while (n %3 == 0) { n /= 3; } if (n == 1) { return true; } else..

代码：借鉴了评论区大佬的代码。class Solution { public int countPrimes(int n) { boolean[] arr = new boolean[n]; int cnt = 0; for(int i = 2; i < n; i++) { if(arr[i]) continue; cnt++; for(int j = i; ...

暴力：class Solution { public List<String> fizzBuzz(int n) { List<String> list = new ArrayList<String>(); for (int i = 1; i <= n; i++) { if (i % 3 == 0 && i % 5 == 0) { list.add..

动态数组，效率不高。class MinStack { private ArrayList <Integer> list = new ArrayList <Integer> (); private int MIN; public MinStack() { } public void push(int val) { list.add(val); } public voi..

思路，这里用到了java中的Random类。第一个初始化的和第二个返回初始状态的函数很好写，只初始化nums和返回nums即可。第三个函数，先克隆一个nums数组s，然后取[0,s.length)之间的随机数temp作为索引，把nums[temp]的值依次赋给s[]，同时用一个boolean数组b判断这个索引有没有重复取。最后返回s。这里没有使用swap 。代码：class Solution { private int [] nums; private Random ran...

动态规划：dp[][0],dp[][1],0表示没做这件事，1表示做了。dp[i][0]表示第i+1家（i从0开始）没偷，那么第i家偷没偷都可以，所以dp[i][0] = Max(dp[i-1][0],dp[i-1][1])。dp[i][1]表示第i+1家偷了，所以上一家肯定没偷，即dp[i][1] = dp[i-1][0] + nums[i];然后取两者最大值。代码：class Solution { public int rob(int[] nums) { i..

动态规划：dp[i] 表示数组索引终点在i处的最大子序和，即前i+1（i从0开始）个值的最大子序和。dp[i]的值与dp[i-1]有关，当dp[i-1]的值比0小时，舍掉dp[i-1]的值，重新开始取，即：dp[i] = Math.max (dp[i - 1],0) + nums[i];然后从dp[]中找出最大值就行了，从头找麻烦，这里就用Max随时记录最大值，最后返回Max就好。代码：class Solution { public int maxSubArray(int[] nums..

双指针：class Solution { public int maxProfit(int[] prices) { int min = prices[0]; int i = 0; int p = 0;//利润 while (i < prices.length) { if (prices[i] < min) { min = prices[i]; ..

当n等于1的时候，走一阶，即f(1)=1当n等于2的时候，可以先走一阶再走一阶，或者直接走两阶，共有2种，记f(2)=2当n等于3的时候，可以从一级台阶上走两步上来，也可以从二级台阶上走一步上来，所以总共有f(3)=f(2)+f(1)；同理当等于n的时候，总共有f(n)=f(n-1)+f(n-2)(这里n>2)种走法。递归太耗时，用的数组。代码：class Solution { public int climbStairs(int n) { if (n &l...

思路：二分查找。要注意int mid= (start- end) / 2 + end;或者int mid= (end- start) / 2 + start;代码：/* The isBadVersion API is defined in the parent class VersionControl. boolean isBadVersion(int version); */public class Solution extends VersionControl...

题目给的是两个已经排好序的数组，很简单：class Solution { public void merge(int[] nums1, int m, int[] nums2, int n) { int [] temp = new int [m]; for (int i = 0; i < m; i++) { temp[i] = nums1[i]; } int i = 0; in...

思路：使用递归的方式，每次取数组中间的值比如m作为当前节点，m前面的值作为他左子树的结点值，m后面的值作为他右子树的节点值,答案不唯一，但题目说了这个结果是正确的。/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * Tr...

BFS/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.val = val; } * TreeNode(int val, TreeNode left, TreeNode ...

大佬真的强！public boolean isSymmetric(TreeNode root) { if (root == null) return true; //从两个子节点开始判断 return isSymmetricHelper(root.left, root.right);}public boolean isSymmetricHelper(TreeNode left, TreeNode right) { //如果左右子节点...

方法1:中序遍历递归 对给定的二叉树进行中序遍历，若始终能保持前一个值比后一个值小，则说明二叉树是一颗二叉搜索树。代码：/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { ...

思路： 比较左子树和右子树的高度，选最大的那个，然后递归。代码：/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.val = val; } * TreeNode(int ...

思路：快慢指针，类似钟表的时针，分针，若存在环，只要fast(快指针)走的步数!=slow(慢指针)走的步数，两者总能相遇。代码：/** * Definition for singly-linked list. * class ListNode { * int val; * ListNode next; * ListNode(int x) { * val = x; * next = null; * } * } ..

思路：先找到链表中点，把中点后边的值用头插法翻转，在拿中点前边的值与后边的比较即可。代码：/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode() {} * ListNode(int val) { this.val = val; } * ListNode(int val, ListNo..