二叉树详解：定义、遍历与操作-CSDN博客

本文链接：https://blog.csdn.net/qq_38311489/article/details/89423581

本文介绍了二叉树的概念，包括定义、性质、满二叉树、完全二叉树和二叉查找树。阐述了二叉树的三种遍历方式：先序、中序和后序，并探讨了如何根据遍历顺序重建二叉树。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

二叉树简介

1、二叉树的定义
二叉树是每个结点最多有两个子树的树结构。它有五种基本形态：二叉树可以是空集；根可以有空的左子树或右子树；或者左、右子树皆为空。
在这里插入图片描述
2、二叉树的性质

性质1：二叉树第i层上的结点数目最多为2i-1(i>=1)

性质2：深度为k的二叉树至多有2k-1个结点（k>=1）

性质3：包含n个结点的二叉树的高度至少为(log2n)+1

性质4：在任意一棵二叉树中，若终端结点的个数为n0，度为2的结点数为n2，则n0=n2+1

3、满二叉树、完全二叉树和二叉查找树

1、满二叉树
定义：高度为h，并且由2h-1个结点组成的二叉树，称为满二叉树
在这里插入图片描述
2、完全二叉树

定义：一棵二叉树中，只有最下面两层结点的度可以小于2，并且最下层的叶结点集中在靠左的若干位置上，这样的二叉树称为完全二叉树。

特点：叶子结点只能出现在最下层和次下层，且最下层的叶子结点集中在树的左部。显然，一棵满二叉树必定是一棵完全二叉树，而完全二叉树未必是满二叉树。
在这里插入图片描述
面试题：如果一个完全二叉树的结点总数为768个，求叶子结点的个数。

由二叉树的性质知：n0=n2+1，将之带入768=n0+n1+n2中得：768=n1+2n2+1，因为完全二叉树度为1的结点个数要么为0，要么为1，那么就把n1=0或者1都代入公式中，很容易发现n1=1才符合条件。所以算出来n2=383，所以叶子结点个数n0=n2+1=384。

总结规律：如果一棵完全二叉树的结点总数为n，那么叶子结点等于n/2（当n为偶数时）或者(n+1)/2（当n为奇数时）
3、二叉查找树

定义：二叉查找树又被称为二叉搜索树。设x为二叉查找树中的一个结点，x结点包含关键字key，结点x的key值计为key[x]。如果y是x的左子树中的一个结点，则key[y]<=key[x]；如果y是x的右子树的一个结点，则key[y]>=key[x]
在这里插入图片描述
在二叉查找树中：

（1）若任意结点的左子树不空，则左子树上所有结点的值均小于它的根结点的值。

（2）任意结点的右子树不空，则右子树上所有结点的值均大于它的根结点的值。

（3）任意结点的左、右子树也分别为二叉查找树。

（4）没有键值相等的结点。

二叉树的基本操作

基本结构

class Tree{
    String value;
    Tree lNode;
    Tree rNode;

    public Tree(String value){
        this.value = value;
        this.lNode = null;
        this.rNode = null;

    }
}

创建

//先序创建
    public static Tree createTree(String[] treeNodes){
        List<Tree> list = new ArrayList<>();
        for (String s : treeNodes){
            list.add(new Tree(s));
        }
        Tree root = list.get(0);
        for (int i = 0;i < list.size()/2;i++){
            list.get(i).lNode = list.get(i * 2 + 1);
            //避免下标越界
            if (i * 2 + 2 < list.size()){
                list.get(i).rNode = list.get(i * 2 + 2);
            }
        }
        return root;
    }

遍历

1:先序遍历(DLR)
1):访问根节点;

2):按先序遍历访问左子树

3):按先序遍历访问右子树

a.递归

//先序遍历
    public static void preOrder(Tree root){
        if (root == null){
            return;
        }
        System.out.print(root.value + "  ");
        preOrder(root.lNode);
        preOrder(root.rNode);
    }

b.非递归

public static void preOrder(Tree root) {  //先序遍历
        Stack<Tree> stack = new Stack<Tree>();
        Tree node = root;
        while (node != null || stack.size() > 0) {  //将所有左孩子压栈
            if (node != null) {   //压栈之前先访问
                System.out.println(node.value + "  ");
                stack.push(node);
                node = node.lNode;
            } else {
                node = stack.pop();
                node = node.rNode;
            }
        }
    }

2:中序遍历(LRD)

1):按中序遍历左子树

2):访问根节点

3):按中序遍历访问右子树

a.递归

public static void inOrder(Tree root){
        if(null != root){
            inOrder(root.lNode);
            System.out.print(root.value + "\t");
            inOrder(root.rNode);
        }
    }

b.非递归

 public static void inOrder(Tree root) {  //中序遍历
        Stack<Tree> stack = new Stack<Tree>();
        Tree node = root;
        while (node != null || stack.size() > 0) {
            if (node != null) {
                stack.push(node);   //直接压栈
                node = node.lNode;
            } else {
                node = stack.pop(); //出栈并访问
                System.out.print(node.value + "  ");
                node = node.rNode;
            }
        }
    }

3:后序遍历

1):按后序遍历访问左子树

2):按后序遍历访问右子树

3):访问根节点

a.递归

public static void postOrder(Tree root){
        if (root == null){
            return;
        }
        postOrder(root.lNode);
        postOrder(root.rNode);
        System.out.print(root.value + "  ");
    }

b.非递归

public static void postOrder(Tree root) {   //后序遍历
        Stack<Tree> stack = new Stack<Tree>();
        Stack<Tree> output = new Stack<Tree>();//构造一个中间栈来存储逆后序遍历的结果
        Tree node = root;
        while (node != null || stack.size() > 0) {
            if (node != null) {
                output.push(node);
                stack.push(node);
                node = node.rNode;
            } else {
                node = stack.pop();
                node = node.lNode;
            }
        }
        while (output.size() > 0) {

            System.out.print(output.pop().value + "  ");
        }
    }

4.层次遍历

从左向右遍历每层的元素

public static void levelOrder(Tree root){
        Queue<Tree> queue = new LinkedList<>();
        queue.offer(root);
        Tree node;
        while (!queue.isEmpty()){
            node = queue.poll();
            System.out.print(node.value + "  ");
            if (node.lNode != null){
                queue.offer(node.lNode);
            }
            if (node.rNode != null){
                queue.offer(node.rNode);
            }
        }
    }

根据遍历顺序创建二叉树

根据先序和中序创建二叉树

public TreeNode buildTree1(int[] preorder, int[] inorder) {
        return build1(preorder, 0, preorder.length - 1, inorder, 0, inorder.length - 1);
    }

    public TreeNode build1(int[] preorder, int preStart, int preEnd, int[] inorder, int inStart, int inEnd) {
        if (preStart > preEnd) {
            return null;
        }
        int rootValue = preorder[preStart];
        int index = 0;
        for (int i = inStart; i <= inEnd; i++) {
            if (inorder[i] == rootValue) {
                index = i;
                break;
            }
        }
        TreeNode root = new TreeNode(rootValue);
        int leftSize = index - inStart;
        root.left = build1(preorder, preStart + 1, leftSize + preStart, inorder, inStart, index - 1);
        root.right = build1(preorder, preStart + leftSize + 1, preEnd, inorder, index + 1, inEnd);
        return root;
    }

根据中序和后序创建二叉树

public TreeNode buildTree(int[] inorder, int[] postorder) {
        return build(inorder, 0, inorder.length - 1, postorder, 0, postorder.length - 1);
    }

    public TreeNode build(int[] inorder, int inStart, int inEnd, int[] postorder, int postStart, int postEnd) {
        if (inStart > inEnd) {
            return null;
        }
        int rootValue = postorder[postEnd];
        int index = 0;
        for (int i = inStart; i <= inEnd; i++) {
            if (inorder[i] == rootValue) {
                index = i;
                break;
            }
        }
        int leftSize = index - inStart;
        TreeNode root = new TreeNode(rootValue);
        root.left = build(inorder, inStart, index - 1, postorder, postStart, postStart + leftSize - 1);
        root.right = build(inorder, index + 1, inEnd, postorder, postStart + leftSize, postEnd - 1);
        return root;
    }