tianynnb的博客

①递归法根据二叉搜索树的性质，判断两个节点p,q 是否在root 的同一侧，如果在的话说明p,q的相同父节点是root 的子节点；如果判断p,q 在root 的异侧那么就返回根节点root./** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val

先判断第一个字符是‘+’ 还是‘-’ ,如果都不是那么从头开始遍历字符数组，如果发现不是数字那么就break，返回最终的res；如果是数字那么就判断他是否溢出，返回相应的结果。如果全都正常的话，就用res*10+arr[i].class Solution { public int strToInt(String str) { char[] cArr= str.trim().toCharArray(); int n=cArr.length; if(n=

用动态规划算法利用两次for循环计算出上三角和下三角的乘积之和。class Solution { public int[] constructArr(int[] a) { int n=a.length; if(n==0) return new int[]{}; int[]b=new int[n]; b[0]=1; int temp=1; for(int i=1;i<n;i++){

二进制中逢2进1 用 &操作加<<1 来表示，合并用异或来表示^.class Solution { public int add(int a, int b) { while(b != 0) { // 当进位为 0 时跳出 int c = (a&b) << 1; // c = 进位 a ^= b; // a = 非进位和 b = c; // b = 进位

使用递归法class Solution { public int sumNums(int n) { return recur(n); } public int recur(int n){ if(n==0) return 0; return n+recur(n-1); }}```

不用排序的方法有一串连续的数字（无重复），这串数字中最大值为 m， 最小值为 n ，问你这串数字中一共有多少个数字？答案是 m-n+1;同样，如果我们能够知道 5 张扑克牌中的最大值 maxValuemaxValue 和最小值 minValueminValue ，那我们就知道，要使它为顺子需要 maxValue - minValue + 1maxValue−minValue+1 张牌。在查找 maxValuemaxValue 和 minValueminValue 过程中，跳过大小王 00 。如果

动态规划法使用递归会有重复子问题，会超出时间限制所以我们用动态规划算法，首先明确状态明确选择。分析问题的状态时，不要分析整体，只分析最后一个阶段即可！因为动态规划问题都是划分为多个阶段的，各个阶段的状态表示都是一样，而我们的最终答案在就是在最后一个阶段。本题不用选择接下来我们来找出动态转移方程，最后一个阶段也就是投掷完 nn 枚骰子后的这个阶段，我们用 dp[n][j]dp[n][j] 来表示最后一个阶段点数 jj 出现的次数。单单看第 nn 枚骰子，它的点数可能为 1 , 2, 3, … ,

用动态规划法求解1–> 12–>{ 12 √{ 13{ 1*53–>{22{13 √{1*54–>{ 22 √{ 23{1*55—>{32{23{1*5 √6—>{32√{23√{257–>{42 √{33{25class Solution { public int nthUglyNumber(int n) { if(n==1) return 1; int [] dp=new int[n

具体方法是使用一个双端队列 dequedeque，在每次入队时，如果 dequedeque 队尾元素小于即将入队的元素 valuevalue，则将小于 valuevalue 的元素全部出队后，再将 valuevalue 入队；否则直接入队。class MaxQueue { Deque<Integer> max,res; public MaxQueue() { max=new LinkedList<>(); res=new Linked

如果我们用一个数组加一个列表会超出内存限制的！！！所以我们可以用数组加双端队列来解答。首先我们需要确保双端队列要是单调递减的，所以队列的首个元素就是当前窗口的最大值。我们将第一个窗口的所有值，按照单调队列的规则入队之后，因为队列为单调递减，所以队头元素必为当前窗口的最大值，则将队头元素添加到数组中。即判断队列的尾元素是否大于窗口值，如果否那么在队列中弹出。然后移动窗口，要判断当前窗口前的元素是否和队列首元素相等。如果相等那么就将这个值从双端队列中弹出。每次将队头元素加入到数组中去。最后返回数组。

采用滑动窗口算法1.当窗口内的值的和小于target，窗口扩张（窗口扩张自然要加入扩张元素的值）2.当窗口内的值的和大于target，窗口收缩（窗口收缩自然要减去被收缩元素的值）3.当窗口内的值的和刚好等于target，把窗口内元素加入结果集中，继续收缩窗口class Solution { public int[][] findContinuousSequence(int target) { int left=1;int right=1; int midVal

①Hash表class Solution { public int singleNumber(int[] nums) { Map<Integer,Integer> map=new HashMap<>(); for(int item:nums){ if(map.get(item)==null){ map.put(item,1); }else{

class Solution { public int[] singleNumbers(int[] nums) { //1.遍历异或 int num=0; for(int i:nums){ num^=i; } int m=1; //2.循环左移，计算m while((num&m)==0){ m<<=1; }

/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */class Solution { public boolean isBalanced(TreeNode root) { if(root==

/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */class Solution { public int maxDepth(TreeNode root) { if(root==null)

先按照中序遍历将数组中的数加入到列表中，得到了递增的数字，然后就能得出了。/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */class Solution { List<Integer> li

class Solution { public String minNumber(int[] nums) { List<String> strsArray=new ArrayList<>(); for(int item:nums){ strsArray.add(""+item); } strsArray.sort((a,b)->(a+b).compareTo(b+a)); Str

class Solution { public int findNthDigit(int n) { // 计算该数字由几位数字组成，由1位：digits = 1；2位：digits = 2... long base = 9,digits = 1; while (n - base * digits > 0){ n -= base * digits; base *= 10; d.

①暴力解决class Solution { public int majorityElement(int[] nums) { int n=nums.length; Map<Integer,Integer> map=new HashMap<>(); for(int i:nums){ map.put(i,map.getOrDefault(i,0)+1); } for(Map.

class Solution { List<String> res=new ArrayList<>(); String s; public String[] permutation(String s) { this.s=s; recur(new StringBuilder(),new StringBuilder(s)); LinkedHashSet<String> hashSet = new Link

用中序遍历的方式，排序；然后用pre记录前一个root节点，pre.right=root;root.left=pre;pre=root;/*// Definition for a Node.class Node { public int val; public Node left; public Node right; 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) { *

根据二叉搜索树后序遍历的特点，最后的一个数一定是根节点。左–>右–>根我们只要找到比根节点大的第一个元素i，那么他的左边（不包括）是根节点的左子树，i 到 根-1 是他的右子树。i的前面一定是小于根的了，那么还要检验下i到根-1是否大于根？class Solution { int [] postorder; public boolean verifyPostorder(int[] postorder) { this.postorder=postorder;

用一个栈模拟栈的压入弹出序列，先遍历push序列，压入栈，然后看此时栈的顶部是否等于poped[i]，如果等于的话就弹出栈，i++。最后看是否stack.isEmpty()。class Solution { public boolean validateStackSequences(int[] pushed, int[] popped) { Stack<Integer> stack=new Stack<>(); int i=0;

采用分治法，主要是将n分为偶数和奇数两种情况：先判断一样n为0或负数的情况，然后判断奇偶如果n为负数，返回 1/x * myPow(1/x,-n-1)如果n为偶数，返回 myPow(x * x,n/2);如果n为奇数，返回 x * myPow(x * x,n/2);注意：当n为负数时，Java中因为n的最小值可以取到Integer.MIN_VALUE，如果直接取它的相反数的话还是它自己，会导致堆栈溢出，因此提一个x出来。class Solution { public double myP

class Solution { public int[] spiralOrder(int[][] matrix) { if(matrix.length==0) return new int[]{}; int m=matrix.length; int n=matrix[0].length; int[] res=new int[(m)*(n)]; int top=0;int bottom=matrix.length-1;

class Solution { public boolean isNumber(String s) { if(s == null || s.length() == 0){ return false; } //标记是否遇到相应情况 boolean numSeen = false; boolean dotSeen = false; boolean eSeen = false;

class Solution { public int cuttingRope(int n) { //dp[i] 表示长度为i的绳子生成m段最大乘积为？i为状态 int dp[]=new int[n+2]; dp[2]=1; for(int i=3;i<=n;i++){ //1<=j<i for(int j=1;j<i;j++){

用分治法，先序遍历的第一个节点就是根。在中序遍历中通过根 区分哪些是左子树的，哪些是右子树的。然后再递归左右子树/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */class Solution { int

class Solution { boolean[][] visited; char[][] board; int[][] dist = {{1,0},{-1,0},{0,1},{0,-1}}; public boolean exist(char[][] board, String word) { visited = new boolean[board.length][board[0].length]; this.board = boar

BFS 广度优先package com.test1;import java.util.Arrays;import java.util.LinkedList;import java.util.List;import java.util.Queue;public class Solution { boolean visted [][]; public int movingCount(int m, int n, int k) { visted=new boolean[m+

思路：递归思想，一开始想用回溯的，但后来想想，太麻烦了，就改成递归思想了。递归的终止条件是当到达叶子节点的时候。如果还没到达叶子节点时，那么看他是否有左右子节点，然后根据条件f1=hasPathSum(root.left,targetSum-root.val);f2=hasPathSum(root.right,targetSum-root.val);f1||f2;/** * Definition for a binary tree node. * public class TreeNode {

用通俗的语言来描述的话，首先我们的目标是寻找从点i到点j的最短路径。从动态规划的角度看问题，我们需要为这个目标重新做一个诠释（这个诠释正是动态规划最富创造力的精华所在）。 //Floyd算法求解任意两个顶点的最短距离问题，也就是多源最短路径问题 public void floyd() { //存储最短路径 int[][] dist=new int[vertex.length][vertex.length]; //记录最短路径经过的顶点 int[][]

我们大部分人可能比较了解BFS 和 DFS,对于Dijkstra算法他是图算法结构中解决单源最短路径问题的算法。大概就是这样一个有权图，Dijkstra算法可以计算任意节点到其他节点的最短路径。（单源最短路径问题）,Dijkstra算法只能求一个顶点到其他点的最短距离而不能任意两点。首先我们先回顾一下图论的基础吧，一幅图是由节点和边构成的，逻辑结构如下，通常我们会用邻接表或邻接矩阵来实现：①邻接表很直观，我把每个节点 x 的邻居都存到一个列表里，然后把 x 和这个列表关联起来，这样就可以通过一

用双指针，如果两个链表可以相交，那么利用两个链表和相同的性质，找到他们相交的的节点。用两个双指针A=headA,B=headB.两个指针分别同时遍历两个链表，直到找到公共节点。/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { * val = x; * next

还是利用双指针来求解：/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } * } */class Solution { public ListNode getKthFromEnd(ListNode head, int k) { ListNode

解题思路1：使用双指针来求解 定义两个双指针pre,cur. 本题需要定义一个虚头节点，因为头节点可能被删除。 两种情况cur总是向后移动的 如果当前cur.val等于val，那么就cur=cur.next; pre.next=cur;如果当前cur.val不等于val,那么cur.next=cur.next;pre=pre.next;/** * Definition for singly-linked list. * public class ListNode { * int va.

请从字符串中找出一个最长的不包含重复字符的子字符串，计算该最长子字符串的长度。分析： 我们可以这样定义dp数组:dp[i] 以第i个字符结尾的最长的不包含重复字符的子字符串。然后我们可以用Hash表记录下字符数组每个字符的最近一次数组下标。如果之前没有出现过就赋值为-1；然后我们分析下选择：①如果第i个字符没有出现过（-1）那么dp[i]=dp[i-1]+1;②如果第i个字符之前出现过，且之前的下标为t;i-t >dp[i-1]: dp[i]=dp[i-1]+1;i-t<=.

给定一个数字，我们按照如下规则把它翻译为字符串：0 翻译成 “a” ，1 翻译成 “b”，……，11 翻译成 “l”，……，25 翻译成 “z”。一个数字可能有多个翻译。请编程实现一个函数，用来计算一个数字有多少种不同的翻译方法。分析：用 dp(i)dp(i) 表示前 ii 个数字的翻译方法数首先明确状态（显而易见了），接下来明确选择我们可以有两种选择方式：①就单独排 ②和前面一个组合（前提是组合数得是10-25的）接下来我们就可以写状态转移方程了如果和前面的数字组合如果当前数可以和.

输入一个整型数组，数组中的一个或连续多个整数组成一个子数组。求所有子数组的和的最大值。要求时间复杂度为O(n)。//dp数组含义：以下标为i的数结尾的数组，最大子数组为dp[i]; 所以呢dp[i]最小也得等于它本身！！！class Solution { public int maxSubArray(int[] nums) { int n=nums.length; int dp[]=new int [n+1]; //dp数组含义：以下标为i的.