weixin_39248750的博客

思路采用先序遍历的思想遍历二叉树。

思路：先根据二叉搜索树的性质查找目标结点，找到之后判断这个节点左右子节点是否为空，都不为空：遍历右子树的左节点，找到最左的叶子结点作为新的根节点。 public TreeNode deleteNode(TreeNode root, int key){ if(root==null) return null; if(key>root.val){ root.right=deleteNode(root.right,key); .

思路：一开始考虑用BFS，但是题目要求null也算在宽度之内，但如果node.left为空是无法入队的，所以就改变思路，将每个结点都对应一个坐标，利用规律根结点下标i，左孩子为2*i，右孩子为2*i+1。public int widthOfBinaryTree(TreeNode root) { int res=0; Queue<TreeNode> queue=new LinkedList<>(); queue.add(root

思路：层次遍历整个二叉树，完全二叉树应该是连续的结点，而如果前一个结点为空，也就是不连续，就说明不是完全二叉树，设置结点pre记录上一个结点。public boolean isCompleteTree(TreeNode root){ Queue<TreeNode> queue=new LinkedList<>(); queue.add(root); TreeNode pre=root; while(!queue.i

方法一：递归public TreeNode mergeTrees(TreeNode t1,TreeNode t2){ if(t1==null||t2==null){ return t1==null?t2:t1; } t1.val+=t2.val; t1.left=mergeTrees(t1.left,t2.left); t1.right=mergeTrees(t1.right,t2.right);

思路：二叉树的直径=根结点的左右子树高度相加 int max=0; public int diameterOfBinaryTree(TreeNode root) { dfs(root); return max; } public int dfs(TreeNode root){ if(root==null) return 0; int left=dfs(root.left); int righ.

int sum=0; public TreeNode convertBST(TreeNode root){ if(root==null) return null; //倒转的中序遍历 convertBST(root.right); sum+=root.val; root.val=sum; convertBST(root.left); return root; }...

力扣198public int rob(int[] nums){ int len=nums.length; if(len==0) return 0; int[] dp=new int[len+1]; dp[0]=0; dp[1]=nums[0]; for(int i=2;i<=len;i++){ dp[i]=Math.max(dp[i-1],dp[i-2]+nums[i-1])

方法一：递归 采用先序遍历public TreeNode invertTree(TreeNode root){ if(root==null) return null; TreeNode temp=root.left; root.left=root.right; root.right=temp; invertTree(root.left); invertTree(root.right); re

思路：二叉树中的最大路径和，采用后序遍历，自底向上。 int max=Integer.MIN_VALUE; public int maxPathSum(TreeNode root){ if(root==null) return 0; dfs(root); return max; } public int dfs(TreeNode root){ if(root==null) return 0;

方法一：public void flatten(TreeNode root) { if(root == null){ return ; } //将根节点的左子树变成链表 flatten(root.left); //将根节点的右子树变成链表 flatten(root.right); TreeNode temp = root.right; //把树的右

思路：验证二叉搜索树就需要遍历，遍历二叉搜索树可以采用中序遍历，这样遍历的结果是升序的，为了验证是否是升序，设置结点preNode来保存上一个访问过的结点。TreeNode preNode=null; public boolean isValidBST(TreeNode root){ if(root==null) return true; if(!isValidBST(root.left)) return false; if(preNode!=.

假设n个节点存在令G(n)的从1到n可以形成二叉排序树个数令f(i)为以i为根的二叉搜索树的个数即有:G(n) = f(1) + f(2) + f(3) + f(4) + ... + f(n)n为根节点，当i为根节点时，其左子树节点个数为[1,2,3,...,i-1]，右子树节点个数为[i+1,i+2,...n]，所以当i为根节点时，其左子树节点个数为i-1个，右子树节点为n-i，即f(i) = G(i-1)*G(n-i),上面两式可得:G(n) = G(0)*G(n-1)+G(1)*(

方法一：List<Integer> res=new LinkedList<>(); public List<Integer> inorderTraversal(TreeNode root) { dfs(root); return res; } public void dfs(TreeNode root){ if(root==null) return; dfs(root.left)

剑指offer86：在二叉树中查找public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q){ if(root==null||root==p||root==q) return root; TreeNode left=lowestCommonAncestor(root.left,p,q); TreeNode right=lowestCommonAncestor(ro

public String Serialize(TreeNode root){ if(root==null) return "{}"; StringBuilder string=new StringBuilder("{"); Queue<TreeNode> queue=new LinkedList<TreeNode>(){{add(root);}}; while(!queue.isEmpty()){ .

思路：因为是二叉搜索树，所以每个子树的根结点大于左子树，小于右子树。因此二叉树的下一个结点分两种情况讨论，有右结点如6和没有右结点。没有右结点又分为当前结点是左孩子如5还是右孩子如7。public TreeLinkNode GetNext(TreeLinkNode pNode) { if(pNode==null) return null; if(pNode.right!=null){ pNode=pNode.right;

方法一：自底向上public boolean isBalanced(TreeNode root){ return Solve(root)!=-1; } public int Solve(TreeNode root){ if(root==null) return 0; int left=Solve(root.left); if(left==-1) return -1;//剪枝 int right=S

TreeNode pre,head; public TreeNode Convert(TreeNode pRootOfTree) { dfs(pRootOfTree); return head; } public void dfs(TreeNode cur){ if(cur==null) return; dfs(cur.left); if(pre!=null) pre.right=cur; ...

剑指offer82:public boolean hasPathSum (TreeNode root, int sum) { if(root==null) return false; sum-=root.val; if(sum==0&&root.left==null&&root.right==null) return true; return hasPathSum(root.left,sum)||hasPa

方法一：递归分治 public boolean verifyPostorder(int[] postorder){ return Solve(postorder,0,postorder.length-1); } public boolean Solve(int[] postorder,int i,int j){ if(i>=j) return true;//表示此时子树结点<=1 int m=i; w.

方法一：递归public TreeNode mirrorTree(TreeNode root){ if(root==null) return null; TreeNode temp=root.left; root.left=mirrorTree(root.right); root.right=mirrorTree(temp); return root; }方法二：层次遍历public TreeNode .

剑指offer26 树的子结构：//先找到A中和B根结点一样的结点public boolean isSubStructure(TreeNode A, TreeNode B){ if(A==null||B==null) return false; return Solve(A,B)||isSubStructure(A.left,B)||isSubStructure(A.right,B); }//找到后开始遍历判断是否一样 public boolean

思路：本题采用分治算法。根据先序遍历确定根结点，再根据根结点确定中序遍历中的左右子树。 int[] preorder; HashMap<Integer,Integer> dic=new HashMap<>(); public TreeNode buildTree(int[] preorder, int[] inorder){ this.preorder=preorder;//先序 for(int i=0;i<inor.

思路：查找第K小的结点。二叉搜索树按照中序遍历就是从小到大的顺序排列，所以直接套用中序遍历的思想，递归即可。（力扣上是第K大的结点，同理，只要先遍历root.right后遍历root.left即可。 int res=-1;//需要考虑proot=null的情况，所以默认为-1 int count; public int KthNode(TreeNode proot, int k){ this.count=k; dfs(proot);

力扣 面试题32 - I. 从上到下打印二叉树public int[] levelOrder(TreeNode root) { if(root==null) return new int[0]; Queue<TreeNode> queue=new LinkedList<>(); queue.add(root); ArrayList<TreeNode> temp=new ArrayList<>

剑指offer55 二叉树的深度递归：（DFS）public int maxDepth(TreeNode root) { if(root==null) return 0; return Math.max(maxDepth(root.left),maxDepth(root.right))+1; }层次遍历BTS：public int maxDepth(TreeNode root) { if(root==null) return 0;

二叉树的遍历：先序遍历、中序遍历、后序遍历、层序遍历。先序遍历：ABDFECGHI中序遍历：DBEFAGHCI后续遍历：DEFBHGICA层次遍历：ABCDFGIEH前中后序遍历的写法有两类：递归和非递归前序遍历public static void preOrderTraveral(TreeNode node){ if(node == null){ return; } System.out.print(