二叉树的基础认识与训练

二叉树

特点：

1. 每个结点最多有两棵子树，即二叉树不存在度大于 2 的结点
2. 二叉树的子树有左右之分，其子树的次序不能颠倒，二叉树是有序树

二叉树的性质

1. 若根节点的层数为1，则一棵非空二叉树的第i层上最多有2^(i - 1) (i>0)个结点
2. 若只有根节点的二叉树的深度为1，则深度为K的二叉树的最大结点数是2^k - 1 (k>=0)
3. 对任何一棵二叉树, 若叶结点个数为 n0, 度为2的非叶结点个数为 n2,则有n0＝n2＋1
4. 具有n个结点的完全二叉树的深度k为log2(n + 1)上取整

二叉树的存储结构：顺序存储和类似于链表的链式存储

二叉树的前序遍历：（[根][左][右] ）

/**
 * 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) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public void preorder(TreeNode root,List<Integer> ret) {
         if(root == null) {
            return;
        }
        ret.add(root.val);
        preorder(root.left,ret);       
        preorder(root.right,ret);
    }
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> list = new LinkedList<>();
        preorder(root,list);
        return list;
    }
}

中序遍历：（[左][根][右]）

class Solution {
    public void inorder(TreeNode root,List<Integer> list) {
        if(root == null) {
            return;
        }
        inorder(root.left,list);
        list.add(root.val);
        inorder(root.right,list);
    }
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        inorder(root,list);
        return list;
    }
}

后序遍历：（[左][右][根]）

class Solution {

    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        if(root != null) {
            List<Integer> listleft = postorderTraversal(root.left);
            list.addAll(listleft);
            List<Integer> listright = postorderTraversal(root.right);
            list.addAll(listright);
            list.add(root.val);
        }
        return list;
    }
}

相同的树：

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

另一个树的子树

class Solution {
    public boolean isSameTree(TreeNode p, TreeNode q) { //判断树是否相同
        if(p == null && q == null) {
            return true;
        }
        if(p == null && q != null || (p != null && q == null)) {
            return false;
        }
        if(q.val != p.val) {
            return false;
        }
        return isSameTree(p.left,q.left) && isSameTree(p.right,q.right);
    }
    public boolean dfs(TreeNode s, TreeNode t) {
        if (s == null) {
            return false;
        }
        return isSameTree(s, t) || dfs(s.left, t) || dfs(s.right, t);
    }
    public boolean isSubtree(TreeNode s, TreeNode t) {
        return dfs(s,t);
    }
}