java数据结构--二叉树

最新推荐文章于 2024-08-23 08:14:22 发布

可爱的鸡仔

最新推荐文章于 2024-08-23 08:14:22 发布

阅读量85

点赞数

分类专栏： java数据结构文章标签：数据结构算法

本文链接：https://blog.csdn.net/jjhnb123/article/details/134401555

版权

java数据结构专栏收录该内容

9 篇文章 0 订阅

订阅专栏

本文详细介绍了二叉树的概念、节点类型，以及前序、中序、后序遍历方法。还探讨了递归和非递归方式求解二叉树深度，包括最大深度和最小深度。此外，文章还涉及对称二叉树、翻转二叉树、后缀表达式构造树和根据前后序遍历来还原树的过程。

摘要由CSDN通过智能技术生成

一.概念

二叉树是一种树状结构，其中每个节点最多有两个子节点，被称为左子节点和右子节点。二叉树通常具有以下特点：

根节点：二叉树的最顶层节点被称为根节点。它没有父节点，是整个树的起点。
子节点：每个节点最多有两个子节点，分别称为左子节点和右子节点。左子节点在树结构中位于父节点的左侧，右子节点在右侧。
叶节点：没有子节点的节点被称为叶节点，也被称为终端节点。叶节点位于树的最底层。
父节点：每个节点的上一层节点被称为父节点。每个节点除了根节点都有一个父节点。
兄弟节点：拥有相同父节点的节点被称为兄弟节点。
深度：节点的深度是指从根节点到该节点的路径上的节点数。
高度：节点的高度是指从该节点到树的最底层叶节点的最长路径。
子树：节点及其子节点以及与之相关的边所构成的树称为子树。

二叉树在计算机科学中具有广泛的应用，例如在搜索树和排序算法中的使用。因为二叉树具有简单的结构和快速的搜索能力，所以它被广泛应用于许多领域

二.构建二叉树节点类TreeNode

package 树.二叉树;

/**
 * 普通二叉树
 */
public class TreeNode {

     int value;

     TreeNode left;

     TreeNode right;


    public TreeNode(int value,TreeNode left,TreeNode right){
        this.value = value;
        this.left = left;
        this.right = right;
    }

    @Override
    public String toString() {
        return "TreeNode{" +
                "value=" + value +
                ", left=" + left +
                ", right=" + right +
                '}';
    }
}

三.二叉树的遍历

1.前序遍历preOrder

    /**
     * 前序遍历
     *
     * @param treeNode
     */
    static void preOrder(TreeNode treeNode) {
        if (treeNode == null) {
            return;
        }
        System.out.print(treeNode.value + "\t");
        preOrder(treeNode.left);    //左
        preOrder(treeNode.right);   //右
    }

2.中序遍历medOrder

    /**
     * 中序遍历
     *
     * @param treeNode
     */
    static void medOrder(TreeNode treeNode) {
        if (treeNode == null) {
            return;
        }
        medOrder(treeNode.left);    //左
        System.out.print(treeNode.value + "\t");
        medOrder(treeNode.right);   //右
    }

3.后序遍历postOrder

    /**
     * 后序遍历
     *
     * @param treeNode
     */
    static void postOrder(TreeNode treeNode) {
        if (treeNode == null) {
            return;
        }
        postOrder(treeNode.left);    //左
        postOrder(treeNode.right);   //右
        System.out.print(treeNode.value + "\t");
    }

分别打印一下：

 public static void main(String[] args) {

        /**
         *            1
         *           / \
         *          2   3
         *         /   / \
         *        6   9   8
         */


        TreeNode root = new TreeNode(
                1,
                new TreeNode(2, new TreeNode(6, null, null), null),
                new TreeNode(3, new TreeNode(9, null, null), new TreeNode(8, null, null))
        );
        System.out.println("前序遍历");
        preOrder(root);
        System.out.println();
        System.out.println("中序遍历");
        medOrder(root);
        System.out.println();
        System.out.println("后序遍历");
        postOrder(root);

    }

运行:

前序遍历
1	2	6	3	9	8	
中序遍历
6	2	1	9	3	8	
后序遍历
6	2	9	8	3	1	
进程已结束,退出代码0

4.非递归遍历

我们可以使用栈（stack）来实现二叉树的遍历，栈可以模拟递归

 /**
     * 通过迭代实现三种遍历
     */
    @Test
    public void testAllOrder(){
        /**
         *            1
         *           / \
         *          2   3
         *         /   / \
         *        6   9   8
         */
        TreeNode root = new TreeNode(
                1,
                new TreeNode(2, new TreeNode(6, null, null), null),
                new TreeNode(3, new TreeNode(9, null, null), new TreeNode(8, null, null))
        );

        //创建栈
        LinkedListStack<TreeNode> stack = new LinkedListStack<>(10);

        //定义指针变量，初始指向root节点
        TreeNode node = root;
        TreeNode pop = null;
        //遍历，只要node不为空,并且栈中有元素
        while (node != null || !stack.isEmpty()) {
            //先找左孩子
            if (node != null) {
                //压入栈
                stack.push(node);
                System.out.println("前序:"+node.value);
                //指向左孩子
                node = node.left;
            } else {
                //弹出元素
                TreeNode peek = stack.peek();
                // 没有右子树
                if (peek.right == null ) {
                    System.out.println("中序遍历:"+peek.value);
                    //弹出
                    pop = stack.pop();
                    System.err.println("后序:"+pop.value);
                }
                //右子树处理完成
                else if ( peek.right == pop) {
                    pop = stack.pop();
                    System.err.println("后序:"+pop.value);
                }
                //待处理右子树
                else {
                    System.out.println("中序遍历:"+peek.value);
                    //指向栈顶元素的右孩子
                    node = peek.right;
                }

            }

        }

    }

测试一下：

前序:1
前序:2
前序:6
后序:6
中序遍历:6
后序:2
中序遍历:2
后序:9
中序遍历:1
后序:8
前序:3
前序:9
中序遍历:9
后序:3
中序遍历:3
后序:1
前序:8
中序遍历:8

三.深度

1.概念

二叉树的深度是指从根节点到最远叶子节点的路径上的节点个数。可以通过递归或迭代的方式来计算二叉树的深度。

递归方法：

如果二叉树为空，返回深度为 0。
否则，分别计算左子树和右子树的深度。
树的深度为左子树深度和右子树深度中的较大值加 1。

迭代方法（层次遍历）：

如果根节点为空，返回深度为 0。
创建一个队列，并将根节点入队。
初始化深度为 0。
循环执行以下步骤直到队列为空：
- 获取当前层的节点个数，记为 count。
- 将当前层的节点依次出队，并将它们的左子节点和右子节点依次入队。
- 将 count 减去当前层节点个数，如果 count 大于 0，则深度加 1。
返回深度的值。

无论使用递归还是迭代的方式，都可以得到二叉树的深度。