Java二叉树

追梦不止～

已于 2022-10-16 15:00:31 修改

阅读量1.8k

点赞数 15

文章标签： java 数据结构算法

于 2022-10-16 14:52:05 首次发布

本文链接：https://blog.csdn.net/m0_64318128/article/details/127339826

版权

1.二叉树的概念

结点的度：一个结点含有子树的个数称为该结点的度；
树的度：一棵树中，所有结点度的最大值称为树的度；
叶子结点或终端结点：度为0的结点称为叶结点；
双亲结点或父结点：若一个结点含有子结点，则这个结点称为其子结点的父结点；
孩子结点或子结点：一个结点含有的子树的根结点称为该结点的子结点；
根结点：一棵树中，没有双亲结点的结点；
结点的层次：从根开始定义起，根为第1层，根的子结点为第2层，以此类推
树的高度或深度：树中结点的最大层次；

2.二叉树的性质

1. 满二叉树: 一棵二叉树，如果每层的结点数都达到最大值，则这棵二叉树就是满二叉树。如果一棵二叉树的层数为K，且结点总数是 2的k次方-1，则它就是满二叉树。
2. 完全二叉树: 完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n 个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从0至n-1的结点一一对应时称之为完全二叉树。要注意的是满二叉树是一种特殊的完全二叉树。

上面这张图既是完全二叉树又是满二叉树

1. 若规定根结点的层数为 1 ，则一棵非空二叉树的第 i 层上最多有2的i-1次方(i>0)个结点

2. 若规定只有根结点的二叉树的深度为 1 ，则深度为 K 的二叉树的最大结点数是2的k次方减一(k>=0)

3. 对任何一棵二叉树 , 如果其叶结点个数为 n0, 度为 2 的非叶结点个数为 n2, 则有 n0＝n2＋1

4. 具有 n 个结点的完全二叉树的深度 k 为 log 以2为底的（n+1）上取整

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

若i>0 ，双亲序号：(i-1)/2；i=0，i为根结点编号，无双亲结点

若2i+1<n，左孩子序号：2i+1，否则无左孩子

若2i+2<n，右孩子序号：2i+2，否则无右孩子

3.二叉树的基本操作

3.1 二叉树的遍历

二叉树的遍历分为先序遍历、中序遍历、后序遍历

先序遍历：先序遍历是先遍历根节点，再去遍历左子树，最后遍历右子树；

中序遍历：中序遍历是先遍历左子树，再去遍历根节点，最后遍历右子树；

后序遍历：后序遍历是先遍历左子树，再去遍历右子树，最后遍历根节点；

如这张图：

它的先序遍历 ：A B D E H C F G

它的中序遍历：D B E H A F C G

它的后序遍历：D H E B F G C A

下面我们用递归来实现打印二叉树的前中后序遍历

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

首先，我们找到递归的终止条件，当一棵树走到空的时候就要停止，所以我们进行判断：当传入根节点为空的时候返回去，

如果传入的根节点不为空，则先打印根节点，然后将左子树和右子树依此进行递归，则得到先序的打印

中序和后序的与先序的思路大致相同，唯一不同的就是打印根节点的时机，下面给出原码

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

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

3.2 获取二叉树的节点个数

和遍历的方法类似，当走到空的时候返回0，如果不为空则返回左子树的节点个数和右子树的节点个数加上自己的1，原码如下：

// 获取树中节点的个数
    public int size(TreeNode root) {
        if (root == null) {
            return 0;
        }
        return size(root.left) + size(root.right) + 1;
    }

3.3 获取二叉树的叶子结点的个数

首先判断节点是否为空，如果为空则返回0（空树一定没有叶子节点）叶子结点就是左子树和右子树都为空的节点，所以下面就要判断叶子结点--当左右子树都为空时返回1，最后返回左子树和右子树中所有的叶子结点个数就完成了

// 获取叶子节点的个数
    public int getLeafNodeCount(TreeNode root) {
        if (root == null) {
            return 0;
        }
        if (root.left == null && root.right == null) {
            return 1;
        }
        return getLeafNodeCount(root.left) + getLeafNodeCount(root.right);
    }

3.4 求第k层节点的个数

首先判断节点是否为空和k的合法性，当节点为空或者k==0时返回0（没有节点），接下来是获取第k层节点的个数：我们让每次递归的k都进行减一操作，当k的值为1的时候，说明当前子树已经递归到第k层（因为更进入函数的根节点就是一层并且这一层的k并没有进行减一操作，如果判断的是k==0会多往下走了一层），下面是原码：

// 获取第K层节点的个数
    public int getKLevelNodeCount(TreeNode root, int k) {
        if (root == null || k <= 0) {
            return 0;
        }
        if (k == 1) {
            return 1;
        }
        return getKLevelNodeCount(root.left, k - 1) + getKLevelNodeCount(root.right, k - 1);
    }

3.5 获取二叉树的高度

首先判断节点是否为空，为空返回0，再之后就要获取左右子树中的最大高度加上自身节点的高度1。

（返回的语句可以用Math.max（）代替）

// 获取二叉树的高度
    public int getHeight(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int heightLeft = getHeight(root.left);
        int heightRight = getHeight(root.right);
        return heightLeft > heightRight ? heightLeft + 1 : heightRight + 1;
    }

3.6 检测值为value的元素是否存在

当节点为空时返回null（结束条件），然后判断节点的val值是否和传入的val值相同，如果相同则返回这个节点，然后判断左右子树的返回节点是否为空，如果不为空则返回---返回来的节点，如果为空则返回空，原码如下：

// 检测值为value的元素是否存在
    public TreeNode find(TreeNode root, char val) {
        if (root == null) {
            return null;
        }
        if (root.val == val) {
            return root;
        }
        TreeNode node1 = find(root.left, val);
        if (node1 != null) {
            return node1;
        }
        TreeNode node2 = find(root.right, val);
        if (node2 != null) {
            return node2;
        }
        return null;
    }

3.7 层序遍历

层序遍历是按照二叉树的每一层去遍历，所以，我们定义一个队列，先将根节点存进去，然后进入循环（循环条件为队列不为空），每次循环一次执行：弹出队列的一个元素，对元素进行打印，然后将该元素的左孩子和右孩子放进去（不为空放），当队列为空时，就打印完成了下面是原码：

// 层序遍历
    public void levelOrder(TreeNode root) {
        if (root == null) {
            return;
        }
        TreeNode cur = root;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(cur);
        while (!queue.isEmpty()) {
            cur = queue.poll();
            System.out.print(cur.val + " ");
            if (cur.left != null) {
                queue.offer(cur.left);
            }
            if (cur.right != null) {
                queue.offer(cur.right);
            }
        }
    }

如果想把层序遍历的每一层分别放到一个数组或者链表中就参考下面的代码：

//二叉树的层序遍历2
    public List<List<Character>> levelOrder2(TreeNode root) {
        List<List<Character>> list = new ArrayList<>();
        if (root == null) {
            return list;
        }
        Queue<TreeNode> qu = new LinkedList<>();
        qu.offer(root);
        while (!qu.isEmpty()) {
            int size = qu.size();
            List<Character> tmp = new ArrayList<>();
            while (size > 0) {
                TreeNode cur = qu.poll();
                size--;
                tmp.add(cur.val);
                if (cur.left != null) {
                    qu.offer(cur.left);
                }
                if (cur.right != null) {
                    qu.offer(cur.right);
                }
            }
            list.add(tmp);
        }
        return list;
    }