一文通数据结构与算法之——二叉树+常见题型与解题策略+Leetcode经典题

最新推荐文章于 2024-07-31 00:00:00 发布
最新推荐文章于 2024-07-31 00:00:00 发布
阅读量756 收藏 1
点赞数 1
分类专栏： Java后端面试准备 数据结构与算法 文章标签： 算法 数据结构 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42647903/article/details/120594954
版权

文章目录

二叉树

1 二叉树基本操作

1.1 二叉树定义

public class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) { val = x; };
}

1.2 前、中、后序遍历

前中后的区别是，父节点输出的位置顺序

前：父左右

中：左父右

后：左右父

力扣题库：二叉树深度优先遍历

  • 0144.二叉树的前序遍历
  • 0145.二叉树的后序遍历
  • 0094.二叉树的中序遍历
1.2.1 递归形式
//将二叉树以前序遍历的形式存在列表里，中序后序遍历代码一致，只是add的位置变换
ArrayList<Integer> list = new ArrayList<>();
public List<Integer> preorderTraversal(TreeNode root) {
    if(root==null){
        return list;
    }else{
        list.add(root.val);
        if(root.left!=null){
            preorderTraversal(root.left);
        }
        if(root.right!=null){
            preorderTraversal(root.right);
        }
    }
    return list; 
}
1.2.2 非递归，迭代形式

迭代法前序遍历，要保持遍历的深度，所以需要用到一个stack来维持

//注意栈是先进后出，所以需要先把右子节点入栈
public static List<Integer> preOrder2(TreeNode root) {
    List<Integer> list = new ArrayList<>();
    Stack<TreeNode2>  stack = new Stack<>();
    if(root == null){
        return list;
    }

    stack.push(root);
    while(!stack.isEmpty()){
        TreeNode node = stack.pop();
        list.add(node.val);

        if(node.right!=null){
            stack.push(node.right);
        }

        if(node.left!= null){
            stack.push(node.left);
        }
    }
    return list;
}

迭代法后续遍历，同前序遍历，只需要把顺序反转一下

public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        Stack<TreeNode2> stack = new Stack<>();

        if(root == null){
            return list;
        }

        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode node = stack.pop();
            list.add(node.val);
            //注意这里左右子树的新增顺序也发生了变化
            if(node.left!= null){
                stack.push(node.left);
            }
            if(node.right!=null){
                stack.push(node.right);
            }
        }
        //这句反转的代码参考自leetCode官方，只是反转的操作会使效率降低
        Collections.reverse(list);
        return list;
    }

中序遍历，分析

  • 1.我们必须实现一直深度的入左子节点
  • 2.中间节点在我们入左子节点的时候就相当于已经入栈
  • 3.从左子节点（中间节点）如何跳到右子节点，所以这里需要增加一个临时节点p，用于保存当前的节点
 
 public List<Integer> inorderTraversal(TreeNode2 root) {
        List<Integer> res = new ArrayList<>();
        Stack<TreeNode2> stack = new Stack<>();
        //用临时节点p来保存中间节点信息
        TreeNode2 p = root;
        
        while(!stack.isEmpty() || p!=null){
        	//当前节点如果不为空，那么一直入栈，并且指向自己的左节点，实现中间节点和左子节点的入栈操作
            while(p != null){
                stack.push(p);
                p = p.left;
            }
			//左子节点入栈完毕，开始出站。第一个出栈的就是最底层的那一个左子节点，入list
            p = stack.pop();
            res.add(p.val);
            
            /**
            1. 如果当前节点没有右子节点（叶子结点就没有），那么此时p=null
            2. 如果当前节点不是叶子节点，实现了对右子节点的跳转输出
            3. 所以此时的循环条件是，p非空说明没有遍历完，栈为空则说明出栈完毕，可以结束遍历
            */
            p = p.right;
        }
        return res;
    }

1.3 遍历方式

一来先判空

if(root==null){
    return null;
}

遍历树的两种方式：递归和辅助栈(队列)

递归：典型应用

|-- 判断对称二叉树、相同二叉树、翻转二叉树、二叉树子树、合并二叉树、平衡二叉树

2.相同二叉树(同理)
public boolean isSameTree(TreeNode p, TreeNode q) {
    //双指针，判断
    if(p==null && q==null){
        return true;
    }
    if(p == null || q == null){
        return false;
    }
    return (p.val == q.val) && isSameTree(p.left,q.left) && isSameTree(p.right,q.right);
}


4.合并二叉树
    public TreeNode mergeTrees(TreeNode t1, TreeNode t2) {
    if(t1==null || t2 ==null){
        return t1==null?t2:t1;
    }else{
        t1.val = t1.val+t2.val;
        t1.left = mergeTrees(t1.left,t2.left);
        t1.right = mergeTrees(t1.right,t2.right);
        return t1;
    }
}

辅助栈(队列)

//辅助栈
public void test(){
    if(root==null){
        return null;
    }
    LinkedList<TreeNode> queue = new LinkedList<>();
    queue.push(root);
    while(!queue.isEmpty()){
        TreeNode node = queue.poll();
        if(node.left!=null){
            queue.push(node.left);
        }
        if(node.right!=null){
            queue.push(node.right);
        }
    }
}

2 剑指 Offer 算法题

2.1 题目列表

递归

剑指 Offer 27. 二叉树的镜像

剑指 Offer 28. 对称的二叉树

剑指 Offer 26. 树的子结构

剑指 Offer 55 - I. 二叉树的深度

剑指 Offer 55 - II. 平衡二叉树

遍历序列化和反序列化

剑指 Offer 32 - I. 从上到下打印二叉树【广度优先搜索BFS——队列】

剑指 Offer 32 - II. 从上到下打印二叉树 II

剑指 Offer 32 - III. 从上到下打印二叉树III

剑指 Offer 07. 重建二叉树

剑指 Offer 37. 序列化二叉树

二叉搜索树

剑指Offer 33：二叉搜索树的后序遍历序列

剑指Offer 36：二叉搜索树与双向链表

剑指Offer 54：二叉搜索树的第k个结点

剑指 Offer 68 - I. 二叉搜索树的最近公共祖先

剑指 Offer 68 - II. 二叉树的最近公共祖先

剑指Offer 34：二叉树中和为某一值的路径

2.2 实战

剑指 Offer 27. 二叉树的镜像
//将所有左右节点进行互换
//递归
public TreeNode mirrorTree(TreeNode root) {
        if(root==null){
            return null;
        }
        TreeNode left = mirrorTree(root.left);
        TreeNode right = mirrorTree(root.r);
        root.left = right;
        root.right = left;
        return root;
    }

//栈
public TreeNode mirrorTree2(TreeNode root) {
        if(root==null){
            return null;
        }
        LinkedList<TreeNode> queue = new LinkedList<>();
        queue.push(root);
        while(!queue.isEmpty()){
            TreeNode node = queue.poll();
            TreeNode temp = node.left;
            node.left = node.right;
            node.right = temp;
            if(node.left!=null){
                queue.push(node.left);
            }
            if(node.right!=null){
                queue.push(node.right);
            }

        }
        return root;
    }
剑指 Offer 28. 对称的二叉树

image-20210920172828991

//用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样，那么它是对称的。
//递归法
public boolean isSymmetric(TreeNode root) {
    return root==null || symmetric(root.left,root.right);
}

public boolean symmetric(TreeNode p,TreeNode q){
    if(p==null && q==null) return true;
    if(p==null || q==null || p.val!=q.val) return false;
    return symmetric(p.left,q.right) && symmetric(p.right,q.left);
}

//辅助栈
public boolean symmetric(TreeNode p,TreeNode q) {
        LinkedList<TreeNode> queue = new LinkedList<>();
        queue.offer(p);
        queue.offer(q);
        while(!queue.isEmpty()){
            TreeNode leftNode = queue.poll();
            TreeNode rightNode = queue.poll();
//            1.入队列时就已经维持了对照位置，所以可以直接判断相等关系
            if(leftNode==null && rightNode==null) continue;
            if(leftNode==null || rightNode==null ||leftNode.val!=rightNode.val){
                return false;
            }
//            2.入队列
            queue.offer(leftNode.left);
            queue.offer(rightNode.right);

            queue.offer(leftNode.right);
            queue.offer(rightNode.left);
        }
        return true;
    }
剑指 Offer 26. 树的子结构
//输入两棵二叉树A和B，判断B是不是A的子结构。(约定空树不是任意一个树的子结构)
//1.递归
    public boolean isSubStructure(TreeNode A, TreeNode B) {
        if(A==null || B==null) return false;
        //这一步很有讲究 这样其实只是判断了三种情况，并没有递归下去。注意递归的精髓
        //return isSame(A,B) || isSame(A.left,B) || isSame(A.right,B);
        //isSame()只是一步判断是否相等的操作
        return isSame(A,B) || isSame(A.left,B) || isSame(A.right,B);

    }
    public boolean isSame(TreeNode p,TreeNode q){
//        2.分情况讨论
//        当B为空，说明已经遍历完了，return true
//        当A为空说明越过了A的叶子节点还没有找到，return false
        if(q==null) return true;
        if(p==null|| p.val!=q.val) return false;
        return isSame(p.left,q.left) && isSame(p.right,q.right);
    }
其他类似的递归操作
        2.相同二叉树(同理)
        public boolean isSameTree(TreeNode p, TreeNode q) {
            //双指针，判断
            if(p==null && q==null){
                return true;
            }
            if(p == null || q == null){
                return false;
            }
            return (p.val == q.val) && isSameTree(p.left,q.left) && isSameTree(p.right,q.right);
        }


        4.合并二叉树
         public TreeNode mergeTrees(TreeNode t1, TreeNode t2) {
            if(t1==null || t2 ==null){
                return t1==null?t2:t1;
            }else{
                t1.val = t1.val+t2.val;
                t1.left = mergeTrees(t1.left,t2.left);
                t1.right = mergeTrees(t1.right,t2.right);
                return t1;
            }
        }

        5.平衡二叉树
        理解：左旋：右子树太长了，把它匀到左边。右旋同理。
            1.先将根节点设置为新节点，将原左子树还是设为新的左子树
            2.再把右子树的左子树设为新的右子树
            3.把新节点作为右子树的 left，右子节点作为新的根节点
        双旋转：并不是子树直接左旋右旋就能实现平衡
             左旋时，右子节点的左子树高度 > 右子节点的右子树高度，要先对子树进行右旋

        判断是否为平衡二叉树
        public boolean isBalanced2(TreeNode root) {
            if(root==null){
                return true;
            }else{
                int leftHeight = depth(root.left);
                int rightHeight = depth(root.right);
                if(leftHeight-rightHeight>1 || rightHeight-leftHeight>1){
                    return false;
                }else{
                    return isBalanced(root.left)&&isBalanced(root.right);
                }
            }
        }

        BST——> AVL
剑指 Offer 55 - I. 二叉树的深度
//    1.递归+1的深度
//    2.辅助栈
int res=1;
public int maxDepth(TreeNode root) {
    if(root==null){
        return 0;
    }
    return res+Math.max(maxDepth(root.left),maxDepth(root.right));
}

public int maxDepth(TreeNode root){
        int count = 0;
        if(root==null) return count;
        LinkedList<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
//            要维护深度
            int size = queue.size();
            while(size>0){
                TreeNode node = queue.poll();
                if(node.left!=null){
                    queue.offer(node.left);
                }
                if(node.right!=null){
                    queue.offer(node.right);
                }
                size--;
            }
            count++;
        }
        return count;
    }
剑指 Offer 55 - II. 平衡二叉树
//输入一棵二叉树的根节点，判断该树是不是平衡二叉树。如果某二叉树中任意节点的左右子树的深度相差不超过1，那么它就是一棵平衡二叉树。
 //1.递归
    public boolean isBalanced(TreeNode root) {
        if(root==null) return true;
        int leftDepth = depth(root.left);
        int rightDepth = depth(root.right);
        return Math.abs(leftDepth-rightDepth)<=1 &&
                isBalanced(root.left) && isBalanced(root.right);
    }

    public int depth(TreeNode node){
//        基线，为空
        if(node==null) return 0;
        int left = depth(node.left);
        int right = depth(node.right);
        return Math.max(left,right)+1;
    }
剑指 Offer 32 - I. 从上到下打印二叉树
public int[] levelOrder(TreeNode root) {
    if(root==null) return null;
    Queue<TreeNode> queue = new LinkedList<>();
    ArrayList<Integer> list = new ArrayList<>();
    queue.offer(root);
    while (!queue.isEmpty()) {
        TreeNode node = queue.poll();
        list.add(node.val);
        if(node.left!=null) queue.offer(node.left);
        if(node.right!=null) queue.offer(node.right);
    }
    int[] ans = new int[list.size()];
    int i = 0;
    for (Integer integer : list) {
        ans[i++]=(integer);
    }
    return ans;
}
剑指 Offer 32 - II. 从上到下打印二叉树 II
	public List<List<Integer>> levelOrder(TreeNode root) {
        if(root==null) return new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<>();
        List<List<Integer>> list = new ArrayList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            ArrayList<Integer> temp = new ArrayList<>();
            while(size>0){
                TreeNode node = queue.poll();
                temp.add(node.val);
                if(node.left!=null) queue.offer(node.left);
                if(node.right!=null) queue.offer(node.right);
                size--;
            }
            list.add(temp);
        }
        return list;
    }
剑指 Offer 32 - III. 从上到下打印二叉树 III
//请实现一个函数按照之字形顺序打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右到左的顺序打印
 	public List<List<Integer>> levelOrder(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        List<List<Integer>> res = new ArrayList<>();
        if(root != null) queue.add(root);
        while(!queue.isEmpty()) {
            LinkedList<Integer> tmp = new LinkedList<>();
            for(int i = queue.size(); i > 0; i--) {
                TreeNode node = queue.poll();
                //充分利用LinkedList是链表的特征。可以双向进行添加
                if(res.size() % 2 == 0) tmp.addLast(node.val); // 偶数层 -> 队列头部
                else tmp.addFirst(node.val); // 奇数层 -> 队列尾部
                if(node.left != null) queue.add(node.left);
                if(node.right != null) queue.add(node.right);
            }
            res.add(tmp);
        }
        return res;
    }
剑指 Offer 07. 重建二叉树
	int[] preorder;
    Map<Integer,Integer> map;
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        this.preorder = preorder;
        map = new HashMap<>();//1.为方便根据值来get到索引，将数据存到map中
        for (int i = 0; i < preorder.length; i++) {
            map.put(inorder[i],i);
        }
        return build(0,0,preorder.length-1);//第一个参数preOrder用，第二个和第三个是inorder用来确定左子树右子树的边界
    }

    public TreeNode build(int rootIndex,int left,int right){
        if(left>right) return null;//1.递归的基线
        TreeNode root = new TreeNode(preorder[rootIndex]);
        int split = map.get(preorder[rootIndex]);
        
        root.left = build(rootIndex+1,left,split-1);
        root.right = build(rootIndex+split-left+1,split+1,right);//如果直接写成split+1，会出现数组越界
        return root;//        如：[1 2 3],[3 2 1]和[1 2 3],[2 3 1]这两种情况
    }
剑指 Offer 37. 序列化二叉树
 public String serialize(TreeNode root) {
//        前中后序遍历都会缺失，无法完全复原，所以以层序遍历的形式来
        if(root==null)return "[]";
        Queue<TreeNode> queue = new LinkedList<>();
        StringBuilder str = new StringBuilder("[");
        queue.offer(root);
        while(!queue.isEmpty()){
            TreeNode node = queue.poll();
            if(node != null) {
                str.append(node.val + ",");
                queue.add(node.left);
                queue.add(node.right);
            }
            else str.append("null,");
        }
        str.deleteCharAt(str.length() - 1);
        str.append("]");
        return str.toString();
    }

    // Decodes your encoded data to tree.
    public TreeNode deserialize(String data) {
        if(data.equals("[]")) return null;
//        1.将字符数组还原成数值数组
        String[] list = data.substring(1,data.length()-1).split(",");
        TreeNode root = new TreeNode(Integer.parseInt(list[0]));
//        老老实实用队列呗
        Queue<TreeNode> queue= new LinkedList<>();
        int i = 1;
        queue.offer(root);
        while(!queue.isEmpty()){
            TreeNode node = queue.poll();
//            构建左子树
            if(!list[i].equals("null")){
                node.left = new TreeNode(Integer.parseInt(list[i]));
                queue.offer(node.left);
            }
            i++;
//            构建右子树
            if(!list[i].equals("null")){
                node.right = new TreeNode(Integer.parseInt(list[i]));
                queue.offer(node.right);
            }
            i++;
        }
        return root;
    }
剑指Offer 36：二叉搜索树与双向链表
强化一下递归子树的操作，假装理解为递归的操作已经完全ok了，直接使用结果
//    中序遍历递归写法
    public void inOrder(TreeNode root){
        if(root==null) return ;
//        递归左子树，那么就可以直接理解为，左边已经好了
        inOrder(root.left);
        System.out.println(root);
//        递归右子树，也可以理解为直接好了
        inOrder(root.right);
    }

//    head用于记录头结点
//    pre用于记录当前节点的左子节点
    TreeNode pre,head;
    public TreeNode treeToDoublyList(TreeNode root) {
        if(root==null) return null;
//        1.变换双向链表的操作
        dfs(root);
//        2.头尾指针进行指向，此时head已经固定，尾节点就是pre
        pre.right = head;
        head.left = pre;

        return head;
    }

    public void dfs(TreeNode cur){
        if(cur==null) return;
//        1.左子树ok
        dfs(cur.left);

//        2.操作中间节点,
        if(pre==null){//一直递归左子树，到达左子叶子节点
            head = cur;//固定头结点
        }else{
            pre.right  = cur;
        }
        cur.left = pre;
        pre = cur;

//        3.右子树ok
        dfs(cur.right);
    }
剑指Offer 54：二叉搜索树的第k个结点
//    1.中序遍历反着来，形成倒序数组，计数--为0直接返回
    int count,res;
    public int kthLargest(TreeNode root, int k) {
        this.count = k;
        dfs(root);
        return res;
    }
    public void dfs(TreeNode node){
        if(node==null || count==0) return;
        dfs(node.right);
        if(--count==0){
            res = node.val;
            return ;
        }
        dfs(node.left);
    }
剑指 Offer 68 - I. 二叉搜索树的最近公共祖先
public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
    if(root==null) return null;
    if(root.val>p.val && root.val>q.val) return lowestCommonAncestor(root.left,p,q);
    else if(root.val<p.val && root.val<q.val) return lowestCommonAncestor(root.right,p,q);
    else return root;
}

public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
    //1.保证p是节点大的那个
    if(p.val<q.val){
        TreeNode temp = p;
        p = q;
        q = temp;
    }
    while(root!=null){
        if(root.val>p.val) root = root.left;//比大的还大
        else if(root.val<q.val) root = root.right;//比小的还小
        else break;
    }
    return root;
}
剑指 Offer 68 - II. 二叉树的最近公共祖先（注意此时的返回扩展到了二叉树）
//方法·一：
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(root.right, p, q);
        if (left == null) return right;
        if (right == null) return left;
        else return root;
    }


//方法二：自己想
public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if(isChild(p,q)) return p;
        else if(isChild(q,p)) return q;
//        1.当两节点在root的同一侧但是不为子树关系时。返回的应该是root的子节点而不是root
        else if(isChild(root.left,p)&& isChild(root.left,q)){
            return lowestCommonAncestor(root.left,p,q);
        }else if(isChild(root.right,p)&& isChild(root.right,q)){
            return lowestCommonAncestor(root.right,p,q);
        }else return root;
    }

    //判断node是否为p的父节点
    public boolean isChild(TreeNode node,TreeNode p){
        if(node==null) return false;
        if(node.val==p.val ) return true;
        return isChild(node.left,p)||isChild(node.right,p);
    }
剑指 Offer 34. 二叉树中和为某一值的路径————回溯思想

回溯是一种算法思想，可以用递归实现。从问题的某一种可能出发, 搜索从这种情况出发所能达到的所有可能, 当这一条路走到” 尽头 “的时候, 再倒回出发点, 从另一个可能出发, 继续搜索. 这种不断” 回溯 “寻找解的方法, 称作” 回溯法 “。——八皇后问题

递归是一种算法结构，递归会出现在子程序中自己调用自己或间接地自己调用自己。最直接的递归应用就是计算连续数的阶乘，计算规律：n!=(n-1)!*n。

//输入一棵二叉树和一个整数，打印出二叉树中节点值的和为输入整数的所有路径。
	LinkedList<List<Integer>> res = new LinkedList<>();
    LinkedList<Integer> path = new LinkedList<>();
    public List<List<Integer>> pathSum(TreeNode root, int target) {
        recur(root,target);
        return res;
    }
    public void recur(TreeNode node, int target) {
        if(node==null) return;
//        先将当前节点加入路径
        path.add(node.val);
        target-=node.val;
//        1.找到了，入结果
        if(target==0 && node.left==null&&node.right==null){
//            要保留原来的路径没有被改变，所以新建
            res.add(new LinkedList<>(path));
        }
//        2.没找到递归
        recur(node.left,target);
        recur(node.right,target);
//        3.找不到，回溯回到了上一层的recur，继续找其他节点。
//        很强！很难理解！
        path.removeLast();
    }

3 其他

3.二叉树的递归解决问题
|-- 最大深度、最小深度、最大宽度、节点个数、二叉树的直径

    二叉树的最小深度
    public int minDepth(TreeNode root) {
    if(root == null)
        return 0;
    int left = minDepth(root.left);
    int right = minDepth(root.right);
    //因为我们不知道left还是right的长度是0，所以此时用左加右加1！
    return (left == 0 || right == 0) ? left + right + 1 : Math.min(left, right) + 1;
}

二叉树的最大宽度：
    每一层的宽度被定义为两个端点（该层最左和最右的非空节点，两端点间的null节点也计入长度）之间的长度。

    public int widthOfBinaryTree(TreeNode root) {
    Queue< PositionTreeNode> queue = new LinkedList();
    int dep = 0, left = 0, ans = 0;
    queue.offer(new PositionTreeNode(root,0,0));
    while(!queue.isEmpty()){
        PositionTreeNode treeNode = queue.poll();
        //根据满二叉树的特点来标记位置
        if(treeNode.node!=null){
            queue.offer(new PositionTreeNode(treeNode.node.left,treeNode.depth+1,treeNode.pos*2));
            queue.offer(new PositionTreeNode(treeNode.node.right,treeNode.depth+1,treeNode.pos*2+1));

            //刚进入下一层时，需要重置最左端节点的位置。
            //第一个dep不等于node.dep就说明是第一个进入下一层的节点
            //也就是此节点的pos位置就是最左端的节点位置
            if(dep!=treeNode.depth){
                dep = treeNode.depth;
                left = treeNode.pos;
            }
            ans = Math.max(ans,treeNode.pos-left+1);
        }
    }
    return ans;
}

class  PositionTreeNode {
    TreeNode node;
    int depth, pos;
    PositionTreeNode(TreeNode n, int d, int p) {
        node = n;
        depth = d;
        pos = p;
    }
}


二叉树的节点个数：
    public int getNodeNumRec(TreeNode root) {
    if (root == null) {
        return 0;
    }             
    return getNodeNumRec(root.left) + getNodeNumRec(root.right) + 1;
}

4.完全二叉树(叶子节点都在左边)的节点个数
    二叉树的基本概念和类型：https://www.cnblogs.com/sunshineliulu/p/7775063.html

public int countNodes(TreeNode root) {
    if(root==null){
        return 0;
    }
    int leftDepth = nodeCount(root.left);
    int rightDepth = nodeCount(root.right);

    if(leftDepth ==rightDepth){
        return (1<<leftDepth) + countNodes(root.right);
    }else{
        return (1<<rightDepth) + countNodes(root.left);
    }
}

public int nodeCount(TreeNode node){
    int depth=0;
    while(node!=null){
        depth++;
        node = node.left;
    }
    return depth;
}

二叉树的直径：任意两个结点路径长度中的最大值
    int num = 0;
public int diameterOfBinaryTree(TreeNode root){
    depth(root);
    return num;
}
public int depth(TreeNode node){
    if(node==null){
        return 0;
    }else{
        int leftdepth = depth(node.left);
        int rightdepth = depth(node.right);
        num = Math.max(num,leftdepth+rightdepth);//保存的最大的左子树与右子树深度之和就是最大的直径
        return Math.max(leftdepth,rightdepth)+1;//子树的深度就是左子树、右子树中最大值+1
    }
}


|-- 二叉树路径和、最大路径和、第k大的节点、两节点的最大距离

    1.某路径和：
    public boolean hasPathSum2(TreeNode root, int sum) {
    if (root == null) {
        return false;
    } else {
        //广度遍历，保存每一层的和
        //问题在于原地更新新的和值，所以此时不用ArrayList反而用LInkedList
        LinkedList<TreeNode> queue = new LinkedList<>();
        LinkedList<Integer> list = new LinkedList<>();
        queue.offer(root);
        list.offer(root.val);
        while (!queue.isEmpty()) {
            TreeNode node = queue.poll();
            int num = list.poll();
            //如果此处一直poll下面不判断返回，最后所有都会被poll出去没有元素
            if (node.left == null && node.right == null) {
                if (num == sum) {
                    return true;
                }
                continue;
            }

            if (node.left != null) {
                queue.offer(node.left);
                list.offer(node.left.val + num);
            }
            if (node.right != null) {
                queue.offer(node.right);
                list.offer(node.right.val + num);
            }
        }
        return false;
    }
}

2.第k大节点：二叉搜索树中序遍历出来是有序数组
    public int kthLargest2(TreeNode root, int k) {
    ArrayList<Integer> list = new ArrayList<>();
    inOrder2(root,list);
    return list.get(k-1);
}

public void inOrder2(TreeNode node,ArrayList<Integer> list){
    if(node==null){
        return;
    }else{
        inOrder2(node.right,list);
        list.add(node.val);
        inOrder2(node.left,list);
    }
}

|-- 公共祖先
    1.二叉树的公共祖先：思想在判断两个节点是否在同一棵子树
    public TreeNode lowestCommonAncestor236(TreeNode root, TreeNode p, TreeNode q) {
    if(root==null || root==p |root==q){
        return root;
    }
    TreeNode left = lowestCommonAncestor236(root.left,p,q);
    TreeNode right = lowestCommonAncestor236(root.right,p,q);

    if(left == null && right == null) return null;

    if(left==null){
        return right;
    }

    if(right==null){
        return left;
    }

    return root;
}

2.二叉树的公共祖先
    public TreeNode lowestCommonAncestor235(TreeNode root, TreeNode p, TreeNode q) {
    if(p.val<root.val && q.val<root.val){
        return lowestCommonAncestor235(root.left,p,q);
    }
    if(p.val>root.val && q.val>root.val){
        return lowestCommonAncestor235(root.right,p,q);
    }
    return root;
}






|-- N叉树的前、中、后序遍历
N叉树的定义：
class NTreeNode{
    int val;
    List<NTreeNode> children;
    public NTreeNode(int _val, List<NTreeNode> _children) {
        val = _val;
        children = _children;
    }
}

1.前序遍历
 //1.递归法
    public List<Integer> postorder(NTreeNode root) {
        List<Integer> res = new ArrayList<>();
        if(root == null){
            return res;
        }else{
            myposorder(root,res);
            return res;
        }
    }

    private void myposorder(NTreeNode node,List<Integer> res){
        if(node==null){
            return;
        }else{
            for(NTreeNode nodes:node.children){
                myposorder(nodes,res);
            }
            res.add(node.val);
        }
    }
    //2.迭代法
    public List<Integer> postorder2(NTreeNode root) {
        List<Integer> list  = new ArrayList<>();
        if(root==null){
            return list;
        }

        LinkedList<NTreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            NTreeNode node = queue.poll();
            list.add(node.val);
            for (NTreeNode nodes : node.children) {
                queue.offer(nodes);
            }
        }
        Collections.reverse(list);
        return list;
    }
尚墨1111
关注
专栏目录
对称二叉树
Struggle_0的博客
10-05 300
测试地址：☞ 【题目描述】 如果二叉树的左右子树的结构是对称的，即两棵子树皆为空，或者皆不空，则称该二叉树是对称的。编程判断给定的二叉树是否对称. 例：如下图中的二叉树T1是对称的，T2是不对称的。 二叉树用顺序结构给出，若读到#则为空，二叉树T1=ABCDE，T2=ABCD#E，如果二叉树是对称的，输出“Yes”,反之输出“No”。 【输入】 二叉树用顺序结构给出，若读到#则为空。 【输出】 如果二叉树是对称的，输出“Yes”,反之输出“No”。 【输入样例】 ABCDE
Leetcode算法题-二叉树
qq_27534691的博客
10-19 239
124. 二叉树中的最大路径和 https://leetcode-cn.com/problems/binary-tree-maximum-path-sum/ class Solution { int maxValue; public int maxPathSum(TreeNode root) { maxValue = Integer.MIN_VALUE; maxPathDown(root); return maxValue; }
数据结构题型总结之---------二叉树
qq_51345380的博客
12-06 3429
第一类题型：基础的遍历问题 1.前，中，后序遍历问题，都是通过递归调用来添加节点进列表，不同的是添加的顺序，前序是递归的每一次都将节点添加进来。先加后递归。而中序是左递归后加，然后右递归。后序是左递归右递归结束后再存入列表。 例题：力扣 前序：144 中序：94 后序：145 2.层序遍历问题 这里我选择用的是迭代法，首先建一个用来记录每层数量的队列path，建立一个最后返回的，用来装所有层遍历节点的最后返回列表res 建立一个用来存放每层节点的ans列表，用path.size 与for循环
二叉树实战 22 题，速度收藏吧！
<sdffdsfsdfdfs>sfsfsfsdfsdffds</sdfsDS>Fsd
11-14 209
Linux编程点击右侧关注，免费入门到精通！作者丨IOExceptionerhttps://www.jianshu.com/p/0190985635eb先上二叉树的数据结...
数据结构——树、二叉树总结（一）
这个热点不太冷
07-25 2294
最近在看数据结构，准备跨考计算机专业，感觉一直看书很挺无趣的。感觉一周抽出一天写写总结，刷一刷OJ还是挺快乐的一件事情，感觉现在才做这些事情有点晚了，很多大佬已经很早之前就开始了，所以我只能站在大佬的肩膀上看世界了。 首先谈谈我总体对数据结构这们课的看法，我并没有上过这个课，听了几节课的视频，就听不下去了，可能是我不太喜欢别人讲课，再者就是这门课不太好讲吧。我第一本书看的是《大话数据结构...
数据结构—二叉树算法题总结
星星leslie的博客
10-20 1524
文章目录二叉树的最大深度二叉树的最小深度 二叉树的最大深度 方法一：递归 int Max(int a, int b) { if (a > b) { return a; } else { return b; } } int maxDepth(struct TreeNode* root){ if (root == NULL) { ...
【数据结构】二叉树经典入门算法题集锦（下）
林慢慢的博客
10-16 1963
前言：本章将通过五道来自LeetCode/牛客网中的二叉树相关算法题来介绍数据结构中二叉树在算法题中的应用，题目难度不大，大家就当放松放松。 文章目录1.二叉树的最大深度思路分析：题解：2.平衡二叉树思路分析：题解：3.二叉树的后序遍历思路分析：题解：4.二叉树的中序遍历思路分析：题解：5.翻转二叉树思路分析：题解： 1.二叉树的最大深度 OJ链接 给定一个二叉树，找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 思路分析： 二叉树的最大深度等价于：左右子树的最大深度
leetcode-二叉树结构题
hezhihua@zju.edu.cn
09-03 155
常规做法是
LeetCode二叉树篇题解,看这一篇就够了
Bebirds的博客
03-10 275
LeetCode二叉树篇题解,看这一篇就够了 文章目录LeetCode二叉树篇题解,看这一篇就够了基础知识树的三种遍历递归实现栈迭代统一结构层序遍历判断 BST构建 BST还原树(LeetCode——105,106)平衡二叉树二叉树的路径问题其他 基础知识 二叉树的基础知识参考 java中提供 Deque双端队列实现队列与栈的各种需求, 题目中经常会用到如下 offerlast(node)添加元素到队尾 offerFist(node)添加元素到队头 new LinkedList<>(deque
【初阶数据结构篇】二叉树算法题
最新发布
半截诗的博客~
07-31 996
一些关于链式结构二叉树的算法题目！
二叉树算法解题思路总结（一）
meihuai7538的博客
02-22 2343
第一步：先考虑用递归的方式解决问题，注意递归的终止条件。有的递归需要用到回溯法和全局变量 第二步：如果递归无法解决问题，考虑迭代法，具体的迭代方式参考层序遍历和非递归遍历 本篇文章只介绍第一步相关的内容，题目来自leetcode和牛客网的剑指offer 一、找结点 1.二叉搜索树的最近公共祖先：leetcode236 题目描述 给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。 百度百...
数据结构---二叉树的详解
热门推荐
William
02-24 2万+
前言 The only thing that overcomes hard luck is hard word. Name:Willam Time:2017/2/221、名词解释树是使用了递归定义的数据结构，树的子树还是树，其结构如下图所示： 度：结点拥有的子树数目，例如上图结点A的度为3，结点E的度为0 叶子或终端结点：度为0的结点（没有子树的结点） 树的度：各个结点中度的最大值 孩子：结点
二叉树常见解题方法
u012866052的博客
03-08 2203
文章目录一、利用递归遍历框架解题题目1：二叉树的深度（leetcode)题目2：二叉树的直径(leetcode)1、特殊场景-两个节点同时遍历题目3：对称二叉树(leetcode)题目4：填充每个节点的下一右侧节点指针(leetcode)2、特殊场景-构建二叉树二、利用层次遍历解题题目6：二叉树的层序遍历(leetcode)题目7： 填充每个节点的下一个右侧节点指针(leetcode) 一、利用递归遍历框架解题 二叉树解题重点在于利用思考根节点、左子树、右子数的关系，其余工作交给遍历处理，二叉树递归基本框架
数据结构和算法学习指南
墨鱼菜鸡
09-09 172
点击上方蓝字设为星标 下面开始今天的学习～ 这篇文章会涵盖之前的所有内容，并且会举很多代码的实例，谈谈如何使用框架思维，并且给对于算法无从下手的朋友给一点具体可执行的刷题建议。 首先，这里讲的都是普通的数据结构和算法，咱不是搞竞赛的，野路子出生，只解决常规的问题，以面试为最终目标。 另外，以下是我个人的经验的总结，没有哪本算法书会写这些...
计算机网络基础知识及面试总结-这应该是最全的了
尚墨1111的博客
05-05 4129
1. 计算机网络TCP/IP协议栈，OSI参考模型 1.1 计算机网络的性能指标 整段通路中的数据量;可以理解为比如1000米公路中的汽车数量 2.传输层： 传输层提供 应用进程之间，发送端端口到接收端端口之间的服务，要进行差错检验、流量控制、面向连接或无连接的服务 2.1 用户数据报协议UDP：不建立连接，尽最大努力交付，不保证接收 2.2 数据传输协议TCP 每个数据包含目的地址，数据路由相互独立（路径可能变化）；网络尽最大努力交付数据，但不保证不丢失、不保证先后顺序、不保证在时
图文最详细的堆解析：从二叉树到堆到解析大根堆小根堆，分析堆排序，最后实现topK经典面试问题
尚墨1111的博客
07-10 2095
堆1 数据结构——堆 Heap1.0 树1.1堆1.1.1 什么是堆1.1.2 堆的常用方法：1.2 数组构造大根堆1.2.1 节点与数组索引的对应关系1.2.2 实际样例1.3 Java实现1.3.1 自下往上法1.3.2 堆的相关操作1.4 堆排序1.4 优先队列`PriorityQueue`1.4.1 什么是优先级队列1.4.2 自定义排序和Lambda回顾1.4.3 源码分析2 面试经典TopK问题2.1 题目列表：2.2 TopK小2.2.1 基于快排找topk小2.2.2 大根堆法找topk小
字符串匹配算法
尚墨1111的博客
08-12 1457
字符串匹配算法 此算法通常输入为原字符串（string）和子串（pattern），要求返回子串在原字符串中首次出现的位置。比如原字符串为“ABCDEFG”，子串为“DEF”，则算法返回3。 BF（Brute Force，暴力检索） KMP（教科书上最常见算法） BM（Boyer Moore） RK（Robin-Karp，哈希检索） Sunday算法 暴力检索 首先将匹配串和模式串左对齐，然后从左向右一个一个进行比较，如果不成功则模式串向右移动一个单位。速度最慢。 时间复杂度：O（m*n） /** *
一文通数据结构与算法之——图+常见题型与解题策略+Leetcode经典题
尚墨1111的博客
10-03 1335
文章目录数据结构——图1 基本概念1.1 图的存储方式1.2 有向加权图1.3 实现1.4 图的遍历1.4.1 深度优先遍历图 BFS1.4.2 广度优先遍历图 BFS1.5 拓扑排序1.5.1 判断有向图是否存在环1.5.2 输出拓扑顺序：深度遍历法1.5.3 拓扑排序：广度优先遍历法2 真题2.1 路径问题（动态规划）2.1.1 **[64. 最小路径和](https://leetcode-cn.com/problems/minimum-path-sum/)**2.2.2 **[62. 不同路径]
面试相关-七大排序算法：图解+动图+最直观的代码分析_性能比较
尚墨1111的博客
05-17 1141
1 排序算法： 1.1 面试 面试中最常考的是快速排序和归并排序，经常有面试官要求现场写出这两种排序的代码。 其他排序可能会要求比较各自的优劣、各种算法的思想及其使用场景。分析算法的时间和空间复杂度。 1.2 区分 简单的排序：冒泡排序、选择排序、插入排序 简单排序的变种：快速排序、堆排序、希尔排序，比较高效的排序。 基于分治递归思想：归并排序 线性排序：计数排序、桶排序、基数排序三种 排序算法大体可分为两种： 比较排序：时间复杂度最少可达到O(nlogn)，主要有：冒泡排序，选择排序，插入排序，
这应该是你能找到的最深刻的集合面试总结——Java集合知识点集合及面试总结
尚墨1111的博客
04-30 1138
/** * 复习集合： * 1. 集合的意义: * |--数组，内容类型固定，格式不可改变，大小不可改变。提供的方法少。 * |--集合：可以加入多种类型的内容，可以改变大小提供的方法很多，功能强大。 * * 2. 集合的框架结构 + 基本方法的使用 * 单个元素的集合： * |--List：有序可重复 * |--ArrayList---LinkedList * ① 两者区别，几乎相同 * linkedList底层是由链表实现，所以在插入删除
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值