树和二叉树

树和二叉树

1.树的概念

树是一种非线性的数据结构，它是由n个有限结点组成一个有具体层次关系的集合

1.1特点

没有前驱结点的特殊节点称为根结点

除根结点外，其余结点被分成M(M>0)个互不相交的集合，其中每个集合是一颗颗与树类似的子树。

每棵子树的根结点有且只有一个前驱，可以有0个或多个后继

树是递归定义的

注意：在树形结构中，子树之间不能有交集

除了根结点外，每个结点有且仅有一个父节点

一颗N个结点的树有N-1条边

树的示意图

1.2基本概念

结点的度：一个结点含有子树的个数，如示意图，A的度为3，E的度为1, J的度为0

树的度：一棵树中，所有结点度的最大值，如示意图，树的度为3
叶子结点：度为0的节点，如示意图，叶子结点是F、H、I、J、K、L
双亲结点：若一个结点含有子结点，则这个结点称其为子结点的双亲结点
父结点: 如示意图，E是J的父结点，B是E和F的父结点
根结点：一颗树中，没有双亲结点的结点，如示意图，根节点是A
子结点：一个结点含有的子树的根结点称为该结点的子结点，如示意图，B的子结点是E、F

2.二叉树

2.1二叉树的定义

一棵二叉树是结点的一个有限集合，该集合可以为空，也可以是由一个根节点加上两棵别称为左子树和右子树的二叉树组成。

注意：

1. 二叉树不存在度大于2的结点
2. 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树

2.2特殊的树

满二叉树: 一棵二叉树，如果每层的结点数都达到最大值，则这棵二叉树就是满二叉树。
换句话说，如果一棵二叉树的层数为K，且结点总数是 N=2^K-1，则它就是满二叉树

完全二叉树：完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从0至n-1的结点一一对应时称之为完全二叉树。

注意：满二叉树是一种特殊的完全二叉树。

2.3 二叉树的性质

1. 若规定根结点的层数为1，则一棵非空二叉树的第i层上最多有2^i-1 (i>0)个结点
2. 若规定只有根结点的二叉树的深度为1，则深度为K的二叉树的最大结点数是 N=2^k-1
3. . 对任何一棵二叉树, 如果其叶结点个数为 n0, 度为2的非叶结点个数为 n2,则有n0＝n2＋1

假设节点总数是N，如果度为0其叶子结点树为n0，度为1的子节点个数为n1，度为2的子节点数为n2
节点总数：N=n0+n1+n2
又因为性质：二叉树的边比节点数少1
N=n1+2n2+1
联立得n0=n2+1

4. 具有n个结点的完全二叉树的深度k为log2(n+1) 向上取整

5. 对于具有n个结点的完全二叉树，如果按照从上至下从左至右的顺序对所有节点从0开始编号，则对于序号为i的结点有：

    若i>0，双亲序号：(i-1)/2；i=0，i为根结点编号，无双亲结点
    若2i+1<n，**左孩子序号：2i+1**，否则无左孩子
    若2i+2<n，**右孩子序号：2i+2**，否则无右孩子
   

2.4二叉树的存储

顺序存储
我们可以通过双亲节点与子节点下标之间的映射关系将二叉树存储在数组中，如果节点为空，我们以INT_MAX来标记。

链式存储

class TreeNode {
    int val;
    TreeNode left;//左孩子
    TreeNode right;//右孩子
    
    public TreeNode(int val) {
        this.val = val;//当前节点值
    }
}

二叉树的遍历

前序遍历
根节点 → 左子树 → 右子树

递归实现

// 前序遍历
void preOrder(TreeNode root) {
    if (root == null) return;
    System.out.print(root.val + " ");
    preOrder(root.left);
    preOrder(root.right);
}

非递归实现（使用栈）

// 前序遍历（非递归）
void preOrder(TreeNode root) {
    Stack<TreeNode> stack = new Stack<>();
    TreeNode cur = root;
    while (cur != null || !stack.isEmpty()) {
        while (cur != null) {
            System.out.print(cur.val + " ");
            stack.push(cur);
            cur = cur.left;
        }
        cur = stack.pop().right;
    }
}

中序遍历

左子树 → 根节点 → 右子树

递归实现

// 中序遍历
void inOrder(TreeNode root) {
    if (root == null) return;
    inOrder(root.left);
    System.out.print(root.val + " ");
    inOrder(root.right);
}

非递归实现

// 中序遍历（非递归）
void inOrder(TreeNode root) {
    Stack<TreeNode> stack = new Stack<>();
    TreeNode cur = root;
    while (cur != null || !stack.isEmpty()) {
        while (cur != null) {
            stack.push(cur);
            cur = cur.left;
        }
        cur = stack.pop();
        System.out.print(cur.val + " ");
        cur = cur.right;
    }
}

后序遍历

左子树 → 右子树 → 根节点

递归实现

// 后序遍历
void postOrder(TreeNode root) {
    if (root == null) return;
    postOrder(root.left);
    postOrder(root.right);
    System.out.print(root.val + " ");
}

非递归实现

// 后序遍历（非递归，双栈法）
void postOrder(TreeNode root) {
    Stack<TreeNode> s1 = new Stack<>();
    Stack<TreeNode> s2 = new Stack<>();
    s1.push(root);
    while (!s1.isEmpty()) {
        TreeNode node = s1.pop();
        s2.push(node);
        if (node.left != null) s1.push(node.left);
        if (node.right != null) s1.push(node.right);
    }
    while (!s2.isEmpty()) 
        System.out.print(s2.pop().val + " ");
}

遍历方式	时间复杂度	空间复杂度（递归/非递归）	典型应用场景
前序遍历	O(n)	O(h)	复制二叉树、前缀表达式
中序遍历	O(n)	O(h)	二叉搜索树排序、中缀表达式
后序遍历	O(n)	O(h)	内存释放、后缀表达式

层序遍历
每一层一次遍历，需要借助队列实现

实现步骤：

1. 根节点入队
2. 循环出队并访问节点
3. 将当前节点的子节点入队
4. 重复直到队列为空

List<List<Integer>> levelOrder(TreeNode root) {
    List<List<Integer>> res = new ArrayList<>();
    if(root == null) return res;
    
    Queue<TreeNode> queue = new LinkedList<>();
    queue.offer(root);
    
    while(!queue.isEmpty()){
        int levelSize = queue.size();//记录当前层的节点数
        List<Integer> level = new ArrayList<>();
        for(int i=0; i<levelSize; i++){
            TreeNode node = queue.poll();
            level.add(node.val);
            if(node.left != null) queue.offer(node.left);
            if(node.right != null) queue.offer(node.right);
        }
        res.add(level);
    }
    return res;//输出列表
}

因为每个节点被访问一次,所以时间复杂度是O(n)
当树完全不平衡时，队列中需要存储所有节点，所以空间复杂度在最坏情况下是O(n)