StormWangxhu的博客

回溯算法求解全排列问题

剑指Offer 系列题解

解法：排序+双指针class Solution { public List<List<Integer>> threeSum(int[] nums) { Arrays.sort(nums); List<List<Integer>> res = new ArrayList<>(); for(int k = 0; k < nums.length - 2; k++){

思路双向循环链表：链表、双向、循环下面解释下：双向：链表每个节点都有两个指针，前驱指针、后继指针循环：链表头结点和尾节点也互相连接。解法：二叉树中序遍历+双指针class Solution { Node pre, head; public Node treeToDoublyList(Node root) { if(root == null) return null; // 双向链表已完成 dfs(ro

哈希表使用

按照XMind中图再刷一遍

思路按照正常的思路，既然 B[i]=A[0]×A[1]×…×A[i-1]×A[i+1]×…×A[n-1]，那么想要计算出 B[i] 来那每次都去遍历数组 A，把这些数字相乘就行了。而数组 B 的长度为 n，并且计算数组 B 中的每个元素时都需要完整的遍历一遍数组 A，而数组 A 的长度为 n，那么整体的时间复杂度就达到了 O(N2) 级别，按照这个逻辑写出的代码提交会超时。那么哪里可以优化呢？上面的暴力解法中充斥着大量重复的计算！比如数组 A 为 [1,2,3,4,5] 。1、想要计算除了 2

思路根据题意，此 5 张牌是顺子的 充分条件 如下：除大小王外，所有牌 无重复 ；设此 55 张牌中最大的牌为 max ，最小的牌为 min （大小王除外），则需满足：max - min < 5因而，可将问题转化为：此 5 张牌是否满足以上两个条件？解法一：哈希表class Solution { public boolean isStraight(int[] nums) { Set<Integer> set = new HashSet<&gt

思路由于需要在常数时间内找到最小的元素，那么说明肯定是不能使用遍历，因为遍历是 O(n) 级别的时间，那么只能使用辅助空间进行存储，这是一种空间换时间的思想。这里我们设置两个栈：普通栈和辅助栈。解法：两个栈实现class MinStack { Stack<Integer> stack; Stack<Integer> minStack; /** initialize your data structure here. */ public Min

思路为了得到这样一个结果，需要执行如下的操作：考虑定义双指针 ii , jj 分列数组左右两端，循环执行：1、指针 ii 从左向右寻找偶数；2、指针 jj 从右向左寻找奇数；3、将 偶数 nums[i]nums[i] 和 奇数 nums[j]nums[j] 交换。可始终保证： 指针 ii 左边都是奇数，指针 jj 右边都是偶数解法：双指针法class Solution { public int[] exchange(int[] nums) { int left = 0

思路先序遍历树 A，判断树 A 中的每个节点x 为根的子树是否包含树 B。上面这句话包含两个步骤：先序遍历树 A 的每个节点判断以树 A 的每个节点为根节点的子树是否包含 树 B解法:class Solution { public boolean isSubStructure(TreeNode A, TreeNode B) { return (A != null && B != null) && (recur(A, B) || isSu

面试题32 - I. 从上到下打印二叉树 主要考察 树的按层打印 ；面试题32 - II. 从上到下打印二叉树 II 额外要求 每一层打印到一行 ；本题额外要求 打印顺序交替变化（建议按顺序做此三道题）。解法思路：1、用一个变量来判断该层是奇数层还是偶数层2、双端队列的应用class Solution { public List<List<Integer>> levelOrder(TreeNode root) { if(root==null){

解法：class Solution { public int[] levelOrder(TreeNode root) { if(root==null){ return new int[]{}; } Queue<TreeNode> queue = new LinkedList<>(); queue.add(root); List<Integer> result

二叉树的层级打印用队列

解法：字符串遍历class Solution { public int translateNum(int num) { String s = String.valueOf(num); int a = 1, b = 1; for(int i = 2; i <= s.length(); i++) { String tmp = s.substring(i - 2, i); int c = tmp.com

解法：class Solution { int res = 0; int count = 0; public int kthLargest(TreeNode root, int k) { helper(root,k); return res; } public void helper(TreeNode root,int k){ if(root==null){ return; }

解法：二分查找法class Solution { public int missingNumber(int[] nums) { int i =0,j = nums.length-1; while(i<=j){ int m = (i+j)/2; if(nums[m]==m){ i = m+1; }else{ j = m-1;

解法一：切片解法class Solution { public String reverseLeftWords(String s, int n) { return s.substring(n, s.length()) + s.substring(0, n); }}时间复杂度：O（N）空间复杂度：O（N）解法二：列表class Solution { public String reverseLeftWords(String s, int n) {

解法一：自顶向下class Solution { public boolean isBalanced(TreeNode root) { if(root==null){ return true; } return Math.abs(maxDepth(root.left)-maxDepth(root.right))<=1&&isBalanced(root.left)&&isBalanced(r

总结树的遍历：树的递归/深度优先搜索使用的数据结构：栈树的层序遍历/广度优先搜索使用的数据结构：队列解法一：树的后序遍历class Solution { public int maxDepth(TreeNode root) { if(root==null){ return 0; } int left = maxDepth(root.left); int right = maxDepth(root.righ

解法一：动态规划class Solution { public int maxValue(int[][] grid) { int row = grid.length; int col = grid[0].length; int[][] dp = new int[row][col]; dp[0][0] = grid[0][0]; // 只有一列 for(int i=1;i<row;i++){

class Solution { public int maxProfit(int[] prices) { int max = 0; int min = Integer.MAX_VALUE; for(int i=0;i<prices.length;i++){ min = Math.min(min,prices[i]); max = Math.max(max,prices[i]-min);

方法一：最长公共子序列给定两个字符串 word1 和 word2 ，分别删除若干字符之后使得两个字符串相同，则剩下的字符为两个字符串的公共子序列。为了使删除操作的次数最少，剩下的字符应尽可能多。当剩下的字符为两个字符串的最长公共子序列时，删除操作的次数最少。因此，可以计算两个字符串的最长公共子序列的长度，然后分别计算两个字符串的长度和最长公共子序列的长度之差，即为两个字符串分别需要删除的字符数，两个字符串各自需要删除的字符数之和即为最少的删除操作的总次数。关于最长公共子序列，请读者参考「1143. 最

package com.wangxiaohu;import java.util.PriorityQueue;public class FindKthLargest2 { public static void main(String[] args) { int[] nums = new int[]{4,2,1,5,3,6}; int k = findKthLargest(nums,3); System.out.println(k);

基于快速排序算法实现寻找数组元素中的第 K 大元素。这里要注意的是元素下标的转换，对于快排升序排序的话，第 K 大就是从后向前第 K 个元素，那么这个元素对于数组而言，正是正数第 n-k 个下标对应的元素。本文算法也叫做快速选择算法。基于快速排序算法。区别为，快速排序算法是整个排序完，而快速选择算法则对 每次 partition 产生的下标进行对比，利用二分的思想左右向第 k 个数逼近，直到找到第 K 个元素为止。

快速排序算法，一般面试当中，都会手写，建议背住。

解法package com.wangxiaohu;import java.util.HashSet;public class LeetCode160 { /** * 双指针 * 160. 相交链表 * leetcode:https://leetcode-cn.com/problems/intersection-of-two-linked-lists/ * * @param headA * @param headB *

解法 public ListNode middleNode(ListNode head) { // 快慢指针初始化指向 head ListNode slow = head, fast = head; // 快指针走到末尾时停止 while (fast != null && fast.next != null) { slow = slow.next; fast = fast.n

解法package com.wangxiaohu;public class LeetCode21 { /** * 合并两个有序链表 * * @param list1 * @param list2 * @return */ public ListNode mergeTwoLists(ListNode list1, ListNode list2) { ListNode dummy = new ListNode(-

解法package com.wangxiaohu;import java.util.PriorityQueue;public class LeetCode23 { /** * 合并 K 个升序链表 * 参考：https://labuladong.gitee.io/algo/2/17/16/ * * @param lists * @return */ public ListNode mergeKLists(ListNode

解法package com.wangxiaohu;public class LeetCode25 { /** * 每 K 个一组反转链表 * 参考：https://leetcode-cn.com/problems/reverse-nodes-in-k-group/submissions/ * * @param head * @param k * @return */ public ListNode reverseK

package com.wangxiaohu;public class LeetCode234_01 { /** * 判断链表是否为回文链表 * 参考：https://labuladong.gitee.io/algo/2/17/19/ * 时间复杂度：O（N） * 空间复杂度：O（1） * * @param head * @return */ boolean isPalindrome(ListNode he

解法package com.wangxiaohu;public class LeetCode92 { /** * 92. 反转链表 II * 递归反转 * * @param head * @param m * @param n * @return */ ListNode reverseBetween(ListNode head, int m, int n) { // base case

解法package com.wangxiaohu;public class LeetCode206 { /** * 递归反转整个链表 * 递归函数的定义是：输入一个节点head，将「以head为起点」的链表反转，并返回反转之后的头结点。 * 时间复杂度：O（N） * 空间复杂度：O（N） * * @param head * @return */ public ListNode reverseList(L

解法package com.wangxiaohu;public class LeetCode53 { /** * 一维动态规划 * 思路： * dp 数组的含义：以 nums[i] 为结尾的「最大子数组和」为 dp[i] * dp[i] 有两种「选择」，要么与前面的相邻子数组连接，形成一个和更大的子数组；要么不与前面的子数组连接，自成一派，即自己最大。 * 在这两种选择中择优，就可以计算出最大子数组， * * @param

解法package com.wangxiaohu;import java.util.LinkedHashMap;public class LeetCode146 { /** * 题目：146. LRU 缓存机制 * leetcode:https://leetcode-cn.com/problems/lru-cache/ * 实现思路：哈希链表 * LRU 缓存机制特点： * 1、查询快（哈希表的特点） * 2、插入快（链表特点）

解法package com.wangxiaohu;public class LeetCode1143_1 { /** * 题目：1143.最长公共子序列 * 定义：s1[0..i-1] 和 s2[0..j-1] 的 lcs 长度为 dp[i][j] * 目标：s1[0..m-1] 和 s2[0..n-1] 的 lcs 长度，即 dp[m][n] * 思路：自底向上的 dp 数组的动态规划思路 * * @param text1

解法package com.wangxiaohu;import java.util.Arrays;public class LeetCode1143 { /** * 定义 dp table 含义： * dp[i][j]： 表示 s1[i ...],s2[j...]的最长公共子序列的长度 * base case ：当i,j 等于字符串长度最后时，返回 0，因为索引是从 0 开始，等于 长度的时候取的是空串 * 思路：自顶向下带备忘录的动态规划思路

解法/** * 带有备忘录的递给 */ int[] memo; public int climbStairs2(int n) { memo = new int[n + 1]; return dp(n); } private int dp(int n) { if (n <= 2) { return n; } if (memo[n] > 0

解法 /** * dp 数组迭代 * 题目：70. 爬楼梯 * leetcode:https://leetcode-cn.com/problems/climbing-stairs/ * * @param n * @return */ public int climbStairs(int n) { int[] dp = new int[n + 1]; dp[0] = 1; dp