m0_52001011的博客

剑指 Offer 38. 字符串的排列class Solution { Set<String> set=new HashSet<>(); public String[] permutation(String s) { StringBuilder sb=new StringBuilder(); boolean[] used=new boolean[s.length()]; backtracking(s,"",used)

class MaxQueue { //使用双向队列原因：维护递减列表需要元素队首弹出、队尾插入、队尾弹出操作皆为 O(1) 时间复杂度。 Queue<Integer> queue; Deque<Integer> queue2; public MaxQueue() { queue=new LinkedList<>(); queue2=new LinkedList<>(); }

剑指 Offer 57 - II. 和为s的连续正数序列class Solution { public int[][] findContinuousSequence(int target){ //返回格式出错 // List<List<Integer>> res=new ArrayList<>(); List<int[]> res=new ArrayList<>(); //滑动

剑指 Offer 39. 数组中出现次数超过一半的数字class Solution { public int majorityElement(int[] nums) { if(nums.length==1) return nums[0]; Arrays.sort(nums); int n=nums.length; int res=nums[0]; // 2 3 3 for(int i=0;i<=n

剑指 Offer 56 - I. 数组中数字出现的次数方法一：纯纯为了正确，此做法不符合题目的要求class Solution { public int[] singleNumbers(int[] nums) { Set<Integer> set=new HashSet<>(); for(int i=0;i<nums.length;i++){ if(set.contains(nums[i])){

剑指 Offer 07. 重建二叉树/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */class Solution { HashMap<Integer,Integer> map=new H

剑指 Offer 68 - II. 二叉树的最近公共祖先做题思路·：终止条件：当越过叶节点，则直接返回 null ；当 rootroot 等于 p, q ，则直接返回 root ；递推工作：开启递归左子节点，返回值记为 left；开启递归右子节点，返回值记为 right ；返回值： 根据 left 和 right，可展开为四种情况；当 left 和 right 同时为空 ：说明 root 的左 / 右子树中都不包含 p,q ，返回 null ；当 left 和 right 同时不为空

剑指 Offer 41. 数据流中的中位数方法一：借用list集合来解决问题class MedianFinder { List<Integer> res; /** initialize your data structure here. */ public MedianFinder() { res=new ArrayList<>(); } public void addNum(int num)

剑指 Offer 45. 把数组排成最小的数class Solution { public String minNumber(int[] nums) { String[] str=new String[nums.length]; for(int i=0;i<nums.length;i++) str[i]=String.valueOf(nums[i]); Arrays.sort(str,new Comparator<Str

剑指 Offer 54. 二叉搜索树的第k大节点/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */class Solution { int count=0; int i=0; int r

剑指 Offer 13. 机器人的运动范围class Solution { //利用used数组来确保dfs过程中方格已经判断过 boolean[][] used; public int movingCount(int m, int n, int k) { //此题自己做时，和矩阵中的路径搞混了的一点是没有分析出此题不需要进行回溯撤销操作 used=new boolean[m][n]; return dfs(0,0,m,n,k);

#剑指 Offer 58 - I. 翻转单词顺序class Solution { public String reverseWords(String s) { //s.trim(); String t=s.trim(); //s.split(" ") 只能去除一个空格 //s.split("\\s+") 去除一个或多个空格 String[] str=t.split("\\s+"); String re

剑指 Offer 52. 两个链表的第一个公共节点/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { * val = x; * next = null; * } * } */public class Solution { public L

剑指 Offer 47. 礼物的最大价值class Solution { public int maxValue(int[][] grid) { int n=grid.length; int m=grid[0].length; int[][] dp=new int[n][m]; for(int i=0;i<n;i++){ for(int j=0;j<m;j++){ i

剑指 Offer 42. 连续子数组的最大和class Solution { public int maxSubArray(int[] nums) { if(nums.length<1) return 0; int res=nums[0]; int max=nums[0]; for(int i=1;i<nums.length;i++){ res=Math.max(res+nums[i],nums[i

剑指 Offer 26. 树的子结构/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */class Solution { public boolean isSubStructure(TreeNode A,

剑指 Offer 32 - III. 从上到下打印二叉树 III/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */class Solution { public List<List<Inte

剑指 Offer 11. 旋转数组的最小数字class Solution { public int minArray(int[] numbers) { //面试-->二分思路 //注意：将中点值和最右边的边界进行比较，因为这样才能判断出中点值是在左边排序数组还是右边排序数组 //目的：找到右边排序数组的第一个值 int i=0; int j=numbers.length-1; while(i&lt

剑指 Offer 04. 二维数组中的查找class Solution { public boolean findNumberIn2DArray(int[][] matrix, int target) { //思路：依次对每行进行二分查找 //注意对特殊情况矩阵的判断，即二维数组为空或二维数组只有一行时。 if(matrix.length==0 || matrix[0].length<1) return false;

剑指 Offer 05. 替换空格class Solution { public String replaceSpace(String s) { StringBuilder res=new StringBuilder(); for(int i=0;i<s.length();i++){ if(s.charAt(i)==' '){ res.append("%20"); }else{

剑指 Offer 30. 包含min函数的栈class MinStack { Stack<Integer> stack; /** initialize your data structure here. */ public MinStack() { stack=new Stack<>(); } public void push(int x) { stack.push(x); }

剑指 Offer 53 - I. 在排序数组中查找数字 I主思想：二分查找算法方法一：找到目标值的左右边界，相减即可得到出现次数class Solution { //方法一：思路： //找到目标值的左右边界，相减即可得到出现次数 public int search(int[] nums, int target) { // 3 5 8 8 8 10 11 int l=0; int r=nums.length-1;

剑指 Offer 50. 第一个只出现一次的字符方法一：哈希表class Solution { public char firstUniqChar(String s) { HashMap<Character,Integer> map=new HashMap<>(); for(int i=0;i<s.length();i++){ char c=s.charAt(i); map.put(c,

剑指 Offer 09. 用两个栈实现队列方法一：class CQueue { Stack<Integer> stack1=new Stack<>(); Stack<Integer> stack2=new Stack<>(); public CQueue() { } public void appendTail(int value) { stack1.push

328. 奇偶链表/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode() {} * ListNode(int val) { this.val = val; } * ListNode(int val, ListNode next) { this.val = val; this.next = nex

1441. 用栈操作构建数组class Solution { public List<String> buildArray(int[] target, int n) { List<String> list=new ArrayList<>(); if(target.length==0) return list; int count=1; // for(int i=0;i<target.length

1721. 交换链表中的节点/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode() {} * ListNode(int val) { this.val = val; } * ListNode(int val, ListNode next) { this.val = val; this.next

82. 删除排序链表中的重复元素 II/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode() {} * ListNode(int val) { this.val = val; } * ListNode(int val, ListNode next) { this.val = val; this.

61. 旋转链表/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode() {} * ListNode(int val) { this.val = val; } * ListNode(int val, ListNode next) { this.val = val; this.next = next

142. 环形链表 II/** * Definition for singly-linked list. * class ListNode { * int val; * ListNode next; * ListNode(int x) { * val = x; * next = null; * } * } */public class Solution { public ListNode detectCycle(

206. 反转链表/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode() {} * ListNode(int val) { this.val = val; } * ListNode(int val, ListNode next) { this.val = val; this.next = nex

46. 全排列class Solution { List<List<Integer>> res=new ArrayList<>(); List<Integer> path=new ArrayList<>(); public List<List<Integer>> permute(int[] nums){ int[] used=new int[nums.length];

40. 组合总和 IIclass Solution { List<List<Integer>> res=new ArrayList<>(); List<Integer> path=new ArrayList<>(); public List<List<Integer>> combinationSum2(int[] candidates, int target) { //未理解这里的

216. 组合总和 IIIclass Solution { List<List<Integer>> list=new ArrayList<>(); List<Integer> path=new ArrayList<>(); public List<List<Integer>> combinationSum3(int k, int n) { backtrackin

187. 重复的DNA序列class Solution { public List<String> findRepeatedDnaSequences(String s) { int n=s.length(); ArrayList<String> list=new ArrayList<>(); if(n<10) return list; HashMap<String,Integer>

349. 两个数组的交集class Solution { public int[] intersection(int[] nums1, int[] nums2) { int n=nums1.length; int m=nums2.length; HashSet<Integer> set=new HashSet<>(); ArrayList<Integer> list=new ArrayList&lt

64. 最小路径和class Solution { public int minPathSum(int[][] grid) { int n=grid.length; int m=grid[0].length; int[][] dp=new int[n][m]; dp[0][0]=grid[0][0]; //思路：动态规划分为三种情况， for(int i=0;i<n;i++){

152. 乘积最大子数组class Solution { public int maxProduct(int[] nums) { //最大值和最小值都需保留因为负数*负数有可能就成为了最大值。 int max1=1; int min1=1; int max=nums[0]; for(int i=0;i<nums.length;i++){ if(nums[i]<0){

516. 最长回文子序列class Solution { public int longestPalindromeSubseq(String s) { int n=s.length(); //dp[i][j]表示长度为i~j的字符串中最长回文子序列的长度 int[][] dp=new int[n][n]; for(int i=0;i<n;i++) dp[i][i]=1; //相等 dp[i][j]=dp[i+1

583. 两个字符串的删除操作class Solution { public int minDistance(String word1, String word2) { int n=word1.length(); int m=word2.length(); int[][] dp=new int[n+1][m+1]; //此题注意初始化即可。 for(int i=0;i<n+1;i++) dp[i][0]=i;