daqin_yinshi的博客

原创 LeetCode：面试题 04.04. 检查平衡性

深度优先搜索树，得到左子树高度和右子树高度，如果两个高度差超过1，则不是平衡树public class MyTest1 { private boolean isBalance = true; public boolean isBalanced(TreeNode root) { dfs(root); return isBalance; } /** * 深度优先，遍历树，返回树的高度 * @param root * @return */ private int ..

原创 Mybatis层次架构图

原创 LeetCode：37.解数独

思路一：普通回溯法从左到右，从上到下的遍历顺序遍历二维数组，如果发现单元格内容为'.'，则尝试填入1~9，如果填入的值合法，则下探下一个单元格，也尝试填入1~9，如果不合法，则回溯，同时要把下探过的值恢复为'.'判断填入的值是否合法有三种情况一、所在的行没有和当前填入的值相同的值出现二、所在的列没有和当前填入的值相同的值出现三、所在的子数独中没有和当前填入的值相同的值出现假设当前尝试填入的单元格为board[row][col]；则上面三种情况分别为：i从0到8，一、没有boa..

原创 LeetCode：5.最长回文子串

思路一：动态规划状态空间设置：设p(i, j)为字符串的下标i到j的子串，包含i和j；如果是回文串，则p(i, j)==true则有：p(i, j)的递推方程为当p(i, j)长度为1时： p(i, j) = p(i, i) = true当p(i, j)长度为2时：p(i, j) = p(i, i+1) = (S[i]==s[j])当p(i, j)长度大于2时：p(i, j) = ( p(i+1, j-1) && (s[i]==s[j]) )由上面的状态空间表达式..

原创 LeetCode：14.最长公共前缀

思路一：直接思路，每次查看每个字符串元素的对应下标字符是否相同，相同加入结果集中，不同则退出public class Test14 { public static void main(String[] args) { // ["flower","flow","flight"] String[] strs = { "flower", "flow", "flight" }; System.out.println(longestCommonPrefix(strs)); } publ..

原创 LeetCode：387.字符串中的第一个唯一字符

字符串中的唯一字符就是字符出现次数为1的思路：首先一次遍历，统计出每个字符的出现次数，再遍历字符，如果字符出现个数是1，则当前字符对应的小标就是要返回的值public class Test387 { public static void main(String[] args) { System.out.println(firstUniqChar("loveleetcode")); } public static int firstUniqChar(String s) { i..

原创 LeetCode:146.LRU缓存机制

LRU：最近最少使用标准的做法是使用双向链表+哈希表，这恰好是LinkedHashMap的底层实现双向链表一端是最近使用的，新访问的值会放在这一端，如果访问的值原来就存在缓存中，会从原来的位置取出来，放在最近这一端哈希表中是实际的存储注意LinkedHashMap的构造方法参数accessOrder：accessOrder为false，只有insert操作会改变双向链表节点位置accessOrder为true，访问双向链表的节点，就会改变位置，get，put都可以世界使用..

原创 LeetCode：231.2的幂

小于0的不是2的幂大于零的，如果对应的二进制只有1个1，就是属于2的幂public class Test231 { @Test public void test() { System.out.println(hammingWeight(16)); } public boolean isPowerOfTwo(int n) { return n < 0 ? false : hammingWeight(n); } public boolean hammingWeigh..

原创 LeetCode：191.位1的个数

位运算的一些要点总结如下：其中：0s 表示全是0， 1s表示全是1异或操作特点： x ^ 0 = x x ^ 1s = ~x x ^ (~x) = 1s x ^ x = 0; a^b^c = a^(b^c) = (a^b)^c c = a ^ b => a ^ c = b, b ^ c = a; (由上面几条规律可以推导出，可以用于交换两个数)指定位置的位运算：1、将x最右边的n位清零：x & (~0<<...

原创 实现最大堆和堆排序

最大堆：最大堆：堆中某个节点的值总是不大于其父节点的值，可以使用数组实现：按层，从上到下，从左到有，为节点序号i往堆中增加元素的操作：往数组末尾增加，如果比父节点大，则交换，同理，一直到根节点；该操作称为siftUp去除最大堆根元素的操作：将根元素去除，将最后一个元素放在根元素的位置，比较根元素左右子节点，如果左右子节点最大值大于根元素，则和最大的子节点交换所以依次取出最大堆的根元素，对应的就是降序排列完整代码如下：/** * 最大堆：堆中某个节点的值总是不大于其父节点的值 *..

原创 排序算法：快速排序，归并排序

快速排序和归并排序都是nlogn时间复杂度的排序算法1、快速排序思路： 数组取标杆pivot，将比pivot小的元素放在pivot左边，大于pivot的元素放在pivot右边 依次对左边和右边的子数组快排 最终达到整个数组有序public class QuickSort { @Test public void test() { int[] nums = {2,1,5,3,4}; sort(nums); System.out.println(Ar...

原创 排序算法：冒泡排序，选择排序，插入排序

冒泡排序，选择排序，插入排序都是n平方的时间复杂度下面使用Java代码实现这三种排序1、冒泡排序思路：嵌套循环，每次查看相邻的元素如果逆序，则交换public class BubbleSort { @Test public void test() { int[] nums = {2,1,5,3,4}; sort(nums); System.out.println(Arrays.toString(nums)); } /** * 冒泡排序，升序 * 嵌套循..

原创 LeetCode：36.有效的数独

数独只要每个单元格所在行，列，子数组中没有与其没有冲突即数独合法只需要遍历单元格(i ,j)的时候记录下第i行有了board[i][j],第j列有了board[i][j]，第k个子数独有了board[i][j]其中k=(i / 3) * 3 + j / 3因为数字范围是1-9，所以可以用二维数组来存储遍历过的数字，其中board[i][j]-'1'为对应的相应下标public class Test36 { @Test public void test() { // 1 ...

原创 LeetCode：198.打家劫舍

设dp(i) 为第i家必偷的金额，有如下递推公式dp(i) = Math.max( dp(i-1), dp(i-2)+nums[]i ) i>=2dp(0) = nums[0];dp(1) = Math.max( nums[0], nums[1]);public class Test213 { @Test public void test() { int[] nums1 = new int[]{1,2,3,1}; int[] nums2 = new int[]{1..

原创 LeetCode：322.零钱兑换

设dp[i] 为金额i所需的最小硬币个数，如果值是amount+1，表示没有任何一种硬币组合能组成金额i递推公式为：dp[i] = Math.min( dp[i], dp(i-k)+1 ); k in coins, i>=k初始值，dp所有元素为amount+1,即没有组合方式自下向上的动态规划解法如下：public class Test323_2 { @Test public void test() { System.out.println(coinChange(n..

原创 LeetCode：152.乘积最大子数组

类似于前面的53题：最大子序和设max(i) 为(0, i] 的最大子序乘积，由于该最大自序乘积有三种可能，max(i-1)可能是正数，负数；nums[i]也可能是正数，负数如果是负数，要用(0, i]的最小值相乘所以还需要设置一个函数：min(i)为(0, i]的最小子序乘积可以得出如下的递推公式：max(i) = Math.max( max(i-1)*nums[i], Math.max(min(i-1)*nums[i], nums[i]) ); i>=1min(i) ...

原创 LeetCode：53.最大子序和

寻找重复子问题，自相似性如果从头部没有太好的思路，就从尾部思考设函数f(i)为从(0, i]的最大和的连续子数组，是闭区间，包含i容易得出如下递推公式：f(i) = max( f(i-1), 0) + nums[i] i>=1时间f(0) = nums[0]根据递推公式写入如下代码：public class Test53 { @Test public void test() { int[] nums = new int[]{-2,1,-3,4,-...

原创 LeetCode：120.三角形最小路径和

如果是从顶部开始，使用DFS+递归，每次有两个分支，每次都无法知道哪个分支是全局最优的，需要把所有分支走完，才知道最小的路径和如果从底部往上走，每次走到上一层只有两种可能，可以确定最小的路径设f(i, j) 为从底部走到当前(i, j)位置的最小路径和最后一层：f(i, j) = triangle.get(i).get(j)其他层：f(i, j) = min ( f(i+1, j), f(i+1, j+1) ) + triangle.get(i).get(j)由此状态数组和递推公式可..

原创 LeetCode：1143.最长公共子序列

尝试寻找重复子问题，一般针对两个字符串问题，都是通过转换成二维，来得出状态数组和递推公式上面text1="ABAZDC", text2="BACBAD"设dp[i][j] 为字符串text1的子串(0,j]与字符串text2子串(0,i]的最长公共子序列长度从上图可以得出递推公式如下： 当text1[j] == text2[i] ：dp[i][j] = dp[i-1][j-1] + 1; 当text1[j] != text2[i] ：dp[i][j] = Math....

原创 LeetCode：63.不同路径2

和62题类似，增加了障碍物递推方程变为： 当(i, j) 为障碍物时：DP(i, j) = 0; 当(i, j)不是障碍物时：DP(i, j) = DP(i-1, j) + DP(i, j-1);注意第一列和第一行初始化的处理；比如第一行，只要前面有障碍物，后面的所有走法都是0解法如下public int uniquePathsWithObstacles(int[][] obstacleGrid) { int[][] dp = new int[obstacleG...

原创 LeetCode：62.不同路径

寻找重复子问题：每个位置可以由上面和左边的方块走过来，只要知道上面的方块的走法和左边的方块的走法，即可得定义状态数组：设DP(i, j)为从start到(i, j)位置的所有走法得出递推公式：DP(i , j) = DP(i-1, j) + DP(i, j-1)解法如下：public int uniquePaths(int m, int n) { int[][] dp = new int[m][n]; for(int j=0; j<n; j++) { dp[0][j]..

原创 LeetCode：547.朋友圈

该问题与前面的200题岛屿数量类似，可以使用深度优先搜索，广度优先搜索，并查集解决并查集的实现代码入下：public class UnionFind { private int count; private int[] parent; public UnionFind(int n) { count = n; parent = new int[n]; for(int i=0; i<n; i++) { parent[i] = i; } } /** ..

原创 LeetCode：208.实现Trie（前缀树）

字典树的结构图：字典树有三个特点：1、根节点不包含字符，除根节点外每一个节点都只包含一个字符2、 从根节点到某一节点，路径上经过的字符连接起来，为该节点对应的字符串3、每个节点的所有子节点包含的字符都不相同首先定义字典树的节点：Class Node { boolean isWord; Map<Character, Node> next;}isWord标识从根节点到当前节点组成的字符串是不是一个单词每个节点维护了一个Map，根据字符可以...

原创 LeetCode：69.x的平方根；367.有效的完全平方数

使用二分法：public class Test69 { @Test public void test() { System.out.println(mySqrt(0)); System.out.println(mySqrt(1)); System.out.println(mySqrt(4)); System.out.println(mySqrt(15)); System.out.println(mySqrt(16)); System.out.println(mySqr..

原创 LeetCode：55.跳跃游戏

贪心算法，每一步都记录下能到达的最远位置，如果最远位置大于等于了数组最后一个位置即可到达public class Test55 { @Test public void test() { System.out.println(canJump(new int[] { 2, 3, 1, 1, 4 })); System.out.println(canJump(new int[] { 3, 2, 1, 0, 4 })); } // [2,3,1,1,4] public boolean..

原创 LeetCode：122.买卖股票的最佳时机2

只要第一天买入，第二天卖出可以获得利润就可以买入，每一步的最优解合起来刚好就是全局最优解，即贪心算法public class Test122 { @Test public void test() { System.out.println(maxProfit(new int[] { 7, 1, 5, 3, 6, 4 })); System.out.println(maxProfit(new int[] { 1, 2, 3, 4, 5 })); System.out.println(..

原创 LeetCode：455.分发饼干

分发的策略是：每次使用能满足孩子胃口的最小饼干，优先满足胃口最小的孩子每一步的选择都是当下情况最优解，从而得到了全局最优。即贪心算法public class Test455 { @Test public void test() { System.out.println(findContentChildren(new int[]{1, 1, 1}, new int[]{1, 2, 3})); } //g孩子，s饼干 public int findContentChildren..

原创 LeetCode：200.岛屿数量

每个为1的可以向上下左右扩张，如果上下左右为1的，会继续扩张每个位置的扩展开来就是一个树可以每次遍历每个位置值是1（岛屿的），碰到边界或者0停止，一次遍历就是一个岛屿，所有遍历次数和就是岛屿数量遍历的方式有深度优先搜索和广度优先搜索深度优先搜索代码如下：public class Test200_2 { @Test public void test() { char[][] grid = {{'1','1','0','0','0'},{'1','1','0','0','0'}..

原创 LeetCode：102.二叉树的层序遍历

借助队列来实现，先将root存入队列，然后取出root，将root的左右子节点加入队列，每次取值要把队列内的数据全部取完就代表这一层遍历完了，将每个节点的左右子节点加入队列中public class Test102 { class TreeNode { int val; TreeNode left; TreeNode right; TreeNode(int x) { val = x; } } public List<List<Integer&g..

原创 LeetCode：51.N皇后

典型的回溯法思路：从第一行开始，取第一个列，判断是否可以填Q，可以的话，进入第二层，依次选列，如果可以填Q，则下探到下一层，如果不可以，则回溯。关键：如何判断是否可以填Q，即当前(row, col)是否合法，可以从数学坐标斜率上发现如下规律：row+col = 常数 副对角线的标识col-row = 常数 主对角线的标识用三个set集合存储前面填入了Q之后，那些列，主副对角线的特征值注意回溯之后，要对相应的set集合溢出下一层填入的值@Testpublic void tes...

原创 LeetCode：17.电话号码的字母组合

使用map存储数字和字母的对应关系和之前的括号组合，子集问题思路类似public List<String> letterCombinations(String digits) { map.put("2", "abc"); map.put("3", "def"); map.put("4", "ghi"); map.put("5", "jkl"); map.put("6", "mno"); map.put("7", "pqrs"); map.put("8", "tuv..

原创 LeetCode：78.子集

一个整数数组的子集，每个元素都有选中还是不选中两中可能，如果都不选中就是[]所有可能画出来就是一颗树，每一层就是相应的那层元素选中还是不选中可以使用递归：public List<List<Integer>> subsets(int[] nums) { recursion(nums, 0, new ArrayList<>()); return result;}List<List<Integer>> result = ne..

原创 LeetCode：50.Pow(x,n)

x的n次方即n个x相乘，解法一就直接相乘比如计算2的4次方，2*2*2*2，相当于计算2个2*2，如果计算出了2*2，就没必要再计算一次注意下n为负数的情况分治的思路，代码如下public double myPow(double x, int n) { if(n<0) { return 1/pow(x, -n); } return pow(x, n);}public double pow(double x, int n) { if(n==0) { ret..

原创 LeetCode：104.二叉树的最大深度

递归解法：设方法int getMaxDepth(TreeNode root);定义为给一个root节点，返回改节点的树的最大高度要求root节点最大高度只需要左子树最大高度与右子树最大高度两个的最大值加1即可public int maxDepth(TreeNode root) { return getMaxDepth(root);}private int getMaxDepth(TreeNode root) { if(root==null) { return 0; } in..

原创 LeetCode：98.验证二叉搜索树

二叉搜索树的判断：可以根据二叉搜索树的定义，递归定义：左子树<当前节点<右子树或者根据二叉搜索树的中序遍历是递增的根据二叉树的中序遍历递增的解法boolean flag = true; public boolean isValidBST(TreeNode root) { Stack<Integer> stack = new Stack<>(); inOrder(root, stack); return flag;}private void..

原创 LeetCode：22.括号生成

思路：n表示有n个"("和n个")"；第一个可以为"("，第二个可以为"("或者")",当第二个为"("，第三个可以为"("或者”)“，如果第二个为")"，第三个不能为")"；。。。所有情况列出来，就是一棵树。具体到某一层的时候我们其实是可以判断这层符不符合要求（即括号组合是否有效），如果不符合要求就可以不用往下一层走，直接回到上一层往下（另一个分支走），这就是回溯法三个要素：出口，递归函数定义（参数，记录数据，可以用于当前层的判断，中间值的存储），处理逻辑（判断，什么情况可以往下走）@Tes..

原创 LeetCode：49.字母异位词分组

对比下242题对单词排序后判断是否是字母异位词，用map来记录；map的key为排序之后的单词，value为list数组public List<List<String>> groupAnagrams(String[] strs) { if(strs==null || strs.length==0) { return new ArrayList<List<String>>(); } //判断两个元素是否是字母异位次，排序之后判断O(..

原创 LeetCode：94.二叉树的中序遍历， 144.二叉树的前序遍历， 145.二叉树的后序遍历

二叉树的中序遍历：先中序遍历左子树，然后当前节点，再中序遍历右子树设方法void inorderTree(TreeNode root, List<Integer> result) 为中序遍历root为根的二叉树，将遍历的结果存储在result参数中。那么中序遍历左子树应该为inorderTree(root.left, result);中序遍历右子树则为inorderTree(root.right, result);递归解法如下：//中序遍历public List&lt..

原创 LeetCode：242.有效的字母异位词

先理解下什么是字母异位词。如果两个只包含字母的字符串中所含的字母出现的频率相同，就是字母异位词。解法一：对两个字符串进行排序，然后比较两个字符串是否相等，排序时间复杂度O(nlogn)public boolean isAnagram2(String s, String t) { if (s.length() != t.length()) { return false; } char[] str1 = s.toCharArray(); char[] str2 = t.to..

原创 LeetCode：239.滑动窗口最大值

解法一：暴力解法，每次窗口滑动，遍历窗口内的最大值是什么，记录下来，时间复杂度O(k*n)解法二：使用双端队列具体思路是：每次窗口移动，将进入窗口的值放入一个双端队列末尾，放入之前把双端队列中小于改值的元素移出，因为这个新放入的值一定是在这些值中最晚移出的，所以比他小的值存放在队列中已经没有意义了。然后判断移出的值是否是队列第一个元素，如果是，需要移出队列第一个元素。具体代码如下：public int[] maxSlidingWindow(int[] nums, int k) { ...