qq_44182694的博客

并查集

单调栈

因为：[3,4,5] 当执行 cmr = 0时 4 距离最左右边界最小值是1。cmr = 0 查询该元素value 距离左右边界最小值。cmr = 2时 向右添加元素value。最后输出所有当cmr = 0时得到的数组。cmr = 1时向左添加元素value。第二个index是value；第一个index是cmr；现在构造一个双端队列。...

回溯法的应用：回溯法和递归法类似，但回溯法每次进入递归和出递归的时候都会保持一个状态。换句话说，当结束递归的时候，会恢复之前的状态，双方互不影响。class Solution { List<List<Integer>> result = new ArrayList<>(); public List<List<Integer>> permute(int[] nums) { if(nums==null||nums.l

package 剑指offer.树;import java.util.ArrayList;public class leetcode129求根节点到叶节点数字之和 { // 储存一个paths ArrayList<String> paths = new ArrayList<String>(); public int sumNumbers(TreeNode root) { dfs(root,""); Intege

package 剑指offer.栈;import java.util.Stack;/*最小栈每次出栈是栈的最小的元素需要一个容器记录当前的栈的最小值是多少。leetcode716 最大栈每次出栈是栈的最大的元素 */public class leetcode155最小栈 { class MinStack { Stack<Integer> xStack; Stack<Integer> minStack;

package 剑指offer.哈希表;import java.util.HashMap;public class leetcode146LRU缓存 { //定义一个双端链表 class ListNode{ public int key; public int value; public ListNode prev; public ListNode next; //构造函数 public

package 剑指offer.二分查找;import java.util.HashMap;import java.util.Map;public class 只出现一次的数字 { public int singleNumber(int[] nums) { HashMap<Integer,Integer> hashMap =new HashMap<>(); for (int i =0;i<nums.length;i++){

package 剑指offer.二分查找;import java.util.HashSet;//二分查找的思想public class x的平方根 { public int mySqrt(int x) { // int l = 0, r = x, ans = -1; while (l <= r) { int mid = l + (r - l) / 2; //long不加还不行

也是二叉树的层序遍历要有一个标志位来区分是奇数层还是偶数层同时需要一个队列能顺序输出节点，还得会逆序输出节点双端队列可以办到。package 剑指offer.树;import java.util.Deque;import java.util.LinkedList;import java.util.List;import java.util.Queue;/** * 奇数层从左到右遍历，偶数层从右向左排列 * */public class 锯齿形遍历二叉树 { publi

package 剑指offer.树;import java.util.ArrayList;import java.util.LinkedList;import java.util.List;import java.util.Queue;/** * 其实就是找二叉树的每层的右侧的节点 * quene1是存放当前层的节点 * queue2存放下一层的节点 * 由于是从左到右进行遍历，因此最后那个node就是最右侧的节点 * */public class 二叉树的右侧视图 {

package 剑指offer.树;import java.util.LinkedList;import java.util.Queue;public class 二叉树的最低层最左边的值 { public int findBottomLeftValue(TreeNode root){ int bottomleftvalue=root.val; Queue<TreeNode> queue1 =new LinkedList<>();

但凡说道每层 讨论树的层级问题就要想到树的层序遍历！相关问题有很多：每层的最大值右侧视图最左侧最底部的节点的值锯齿形遍历树的节点（奇数层从左到右，偶数层从右向左遍历）。。。用到的方法无外乎两个队列一个队列储存当前层的节点一个队列储存下一层的节点package 剑指offer.树;import java.util.ArrayList;import java.util.Deque;import java.util.LinkedList;import java.util.List

计算每个柱子能接多少雨水找该柱子左侧最高柱子长度，找打该柱子右侧最高柱子的长度该柱子能接雨水的高度=（左右两侧最高柱子的最小值）-该柱子的高度注意第一根柱子与最后一根柱子不接雨水package 剑指offer.数组;public class leetcode42接雨水 { public int trap(int[] height) { //雨水的体积 int sum = 0; for (int i = 0; i < height.l

和前面一道题非常相像本质就是模仿十进制加法package 剑指offer.字符串;//字符串相加public class leetcode415字符串相加 { public String addStrings(String num1, String num2) { StringBuilder result = new StringBuilder(""); int i = num1.length() - 1, j = num2.length() - 1, c

package 剑指offer.动态规划;/** * 斐波那契数列 * 每次这能爬一节 或者两节 * 请问多多少种爬楼梯的做法 * * 从dp[i]的定义可以看出，dp[i] 可以有两个方向推出来。 * 首先是dp[i - 1]，上i-1层楼梯，有dp[i - 1]种方法，那么再一步跳一个台阶不就是dp[i]了么。 * 还有就是dp[i - 2]，上i-2层楼梯，有dp[i - 2]种方法，那么再一步跳两个台阶不就是dp[i]了么。 * 那么dp[i]就是 dp[i - 1]与dp[i

package 剑指offer.动态规划;public class leetcode5最长回文子串 { public String longestPalindrome(String s) { int len = s.length(); //小于2就不是回文串 if (len < 2) { return s; } //初始化最大长度 int maxLen = 1;

package 剑指offer.字符串;import java.util.HashSet;import java.util.Set;public class leetcode3无重复字符最长子串 { public int lengthOfLongestSubstring(String s) { // 哈希集合，记录每个字符是否出现过 HashSet<Character> occ = new HashSet<Character>();

package 剑指offer.树;import java.util.ArrayList;import java.util.LinkedList;import java.util.List;import java.util.Queue;public class 树的层序遍历 { public List<List<Integer>> levelOrder(TreeNode root) { //如果根节点为空 if(root == n

package 剑指offer.树;import java.util.ArrayList;import java.util.List;import java.util.Stack;/** * “左子树->当前节点->右子树” * * * */public class leetcode94树的中序遍历 { /** * 非递归 * @param root * @return */ public List<Inte

package 剑指offer.排序;import java.util.Arrays;import java.util.LinkedList;import java.util.List;/** * to_Array()方法将 Arraylist 对象转换为数组。 * 返回值 * 如果参数 T[] arr 作为参数传入到方法，则返回 T 类型的数组。 * 如果未传入参数，则返回 Object 类型的数组。 */public class t74合并区间 { public int

package 剑指offer.栈;import java.util.Deque;import java.util.LinkedList;import java.util.Stack;/** * 思想是双栈 把栈1的元素压入栈2中，然后再把新元素压入栈1的栈底 * 然后再把栈2的元素挨个弹出。压入栈1中 * 这时候新元素就跑到栈1的栈底了 * * | | | | * | | | | * |____|

package 剑指offer.数组;import java.util.ArrayList;import java.util.List;/** * * 输入：matrix = [[1,2,3],[4,5,6],[7,8,9]] * 1 2 3 * 4 5 6 * 7 8 9 * 输出：[1,2,3,6,9,8,7,4,5] * 坐标变化：（0,0）（0,1）（0,2） 拐弯（1,2）（2,2）拐弯（2,1）（2,0）拐弯（1,0） 拐弯（1,1）.

package 剑指offer.数组;/** * 将数组一分为二，其中一定有一个是有序的，另一个可能是有序，也能是部分有序。 * 此时有序部分用二分法查找。无序部分再一分为二，其中一个一定有序，另一个可能有序，可能无序。就这样循环. */public class leetcode33搜索旋转排序数组 { public int search(int[] nums, int target) { int n = nums.length; if (n == 0).

package 剑指offer.数组;import java.util.HashMap;import java.util.Map;public class leetcode169多数元素 { /** * 方法一：摩尔投票法 * 摩尔投票法经常用来求出现次数超过n/2的众数 * 由于众数是出现次数大于n/2的元素，假设数组中第一个元素为众数，count为1。 * 从第二个元素开始遍历数组，若元素与众数相等，则count+1，若不等，则count-1。

这个思路其实很简单，就是细节麻烦一点思路就是先对整个链表进行分组，每k个分一组。然后翻转链表（注意这里结束的标志是tail，而不是null）最后在连接起来注意最后一节链表是不需要翻转的(小于K个)所以在分组的时候提到了如果tail==null,那么就不要翻转，直接返回hair.nextpackage 剑指offer.链表;public class leetcode25K个一组翻转链表 { public ListNode reverseKGroup(ListNode head, i

思想是利用前缀和因为本题中没有告诉数组内的数一定是正整数，因此用双指针法就行不通，只能用前n项的和思想假设(i<j),前j项和为x，前i项和为x-k;那么就可以说明从i+1到j位的累计和就是K因此我需要一个哈希表，用于存放前n项和，以及出现的次数只要出现sum-k，那么就get出现的次数package 剑指offer.数组;import java.util.HashMap;import java.util.Map;public class t110与1个数相同的子数组forlear

动态规划的思想：用当天的价格减去之前历史值的最小值；然后再取最大。这种方法只需要遍历一次package 剑指offer.数组;public class t201买卖股票的最佳时间 { public int maxProfit(int[] prices){ int max_profit=0; int min=prices[0]; for(int i=0;i<prices.length;i++){ max_profit

package 剑指offer.数组;public class t8和大于或等于K的最短子数组forlearn { public int minSubArrayLen(int k, int[] nums){ int left= 0; int sum =0; int min_length=Integer.MAX_VALUE; for(int right=0;right<nums.length;right++){

最大堆思想package 剑指offer.堆;import java.util.*;public class t61和最小的K个数对forlearn { public List<List<Integer>> kSmallestPairs(int[] nums1, int[] nums2, int k){ //新建一个最大堆 Queue<int[]> max_heap =new PriorityQueue<>((

利用最小堆来做（堆容量为K）只要保证堆顶的数一定比外部的数据大，那么就能保证堆内的数一定是最大的K个Map<Integer,Integer> numtocount=new HashMap<>(); for (int num :nums){ numtocount.put(num,numtocount.getOrDefault(num,0)+1); } Queue<Map

package 剑指offer.链表;public class t22链表环入口的节点 { /** * 不需要知道节点的数目的做法 * 找到快慢指针相遇的地方，在这个地方起一个指针；再在头结点起一个指针。两个指针同时走，下次相遇的节点就是环的入口节点 * （这个涉及一个数学证明，喜欢了解的小伙伴可以自行了解，可以记住这个结论） * @param head * @return */ public ListNode detectCy

package 剑指offer.链表;public class t29排序的循环链表 { public ListNode insert(ListNode head, int insertVal) { ListNode listNode = new ListNode(insertVal); //只有自己一个节点时候 if (head == null) { head = listNode; head.n.

在一个数组中能否找到三个数相加得0；结果不能重复也就是说不重复三元组package 剑指offer;import java.util.*;/** * Java 集合类的 List.addAll() 方法用于将指定 collection 中的所有元素添加到列表。 */public class t7三数之和 { public List<List<Integer>> threeSum(int[] nums){ //先排好序 Arr

package 剑指offer;/** * 我们要明白链表逆序的好处 * 4->2->5 * 5->8->1 * 9->0->7 * * 第一：数需要对齐，尤其是两个数不是相同位数的情况，那么那就回想一下：我们做加法都是尾部对齐，而不是头部 * 这样的话，逆序是比较符合人的思维逻辑的 * 第二：如果存在进位的情况，那我进位是会加到后面，而逆序的时候，下一个节点就是后位。所以逆序把问题变得更加简单 * */public class le.

题目这里利用小顶堆的来实现把这元素依次放到堆中，然后依次出堆，每次出堆的时间是O(logn)n为堆的高度每次出堆都是堆中最小的元素，同时也是链表中的最小元素package 剑指offer;import java.util.Comparator;import java.util.PriorityQueue;import java.util.Queue;public class t78合并排序链表 { class Mycompartor implements Comparator

package 剑指offer;public class t75数组相对排序 { public int[] relativeSortArray(int[] arr1, int[] arr2) { //这里counts的数组大小是有数组的最大值与最小值的范围决定的 //而不是arr1.length+arr2.length决定的 int[] counts = new int[1001]; for (int num : arr1) {.

计数排序对于小范围数据，小规模数据，排序性能非常好影响计数排序性能的只要还是数组中的最大值与最小值的差值如果差值过大，那么就没必要用计数排序了*计数排序的思想就是先对数组的数进行频率统计，统计完毕后，只需要将num 出现的频率即可。package 剑指offer;public class t127计数排序 { public int[] sortArray(int[] nums){ //定义最大最小值 int min=Integer.MAX_VALUE;

package 剑指offer;//时间复杂度是O(logn)//在树里面就是树的深度的对数public class t126递增排序数组二分查找 { public int search(int[] nums,int target){ int left =0; int right =nums.length-1; while (left<=right){ int mid=(left+right)/2;

前情提要：手撕快速排序我们这时候就需要这个partition函数了。这道题的整体思路就是没必要对数组排序然后去第K个大的我们回想之前的分区函数，最后就是小于中间值的都在左边；大于中间值的都在右边。于是我们今天就要巧妙的利用这一点。我这需要找到中间值的下标为n-k，只有确定这个下角标。小于这个下角标的都在左面大于这个下角标的都在右边注意这个分区函数是从小到大排列的如果没有正好找到这个n-k的小标：如果大于n-k，说明第K个大的数在左侧如果小于n-k，那么就说明第K个大的数在右侧继续寻找