Java版数据结构——二叉树

二叉树的详细介绍，及实现代码

性质1 若二叉树的层次从1开始, 则在二叉树的第 i 层最多有 2^{i -1}个结点。(i ≥1)

用数学归纳法证明 根结点在第1 层上，这层结点数最多为1 个，即20 个；第2 层上最多有2 个结点，即21 个；… 假设第i-1层的结点最多有2i-2 个，且每个结点最多有两个孩子,那么第i 层上结点最多有2*2 i-2 =2 i-1 个。

性质2 深度为 k 的二叉树最多有 2^k-1个结点。(k ≥ 1)

根据性质1，显然深度为k的二叉树的结点总数至多为： （证明用求等比级数前k项和的公式）

性质3 对任何一棵二叉树, 如果其叶结点个数为 n₀, 度为2的非叶结点个数为 n₂, 则有n₀＝n₂＋1

若设度为1的结点有 n1 个，总结点个数为 n，总边数为 e，则根据二叉树的定义，
n = n0 + n1 + n2 ， e = 2n2 + n1 = n - 1
因此，有
2n2 + n1 = (n0 + n1 + n2) - 1
n2 = n0 - 1
n0 = n2 + 1

性质4 具有 n 个结点的完全二叉树的深度为log₂(n) +1(其中 x 表示不大于x的最大整数)

设完全二叉树的高度为h，则有2^h-1 - 1 < n ≤ 2^h - 1或2^h-1 ≤ n < 2h
取对数 h-1 ≤ log₂(n) < h
∵ 是整数
∴ h-1 ≤ log₂(n) < h

性质5 如果将一棵有n个结点的完全二叉树自顶向下，同一层自左向右连续给结点编号 1, 2, …, n，那么，对于编号为i (1 ≤ i ≤ n) 的结点,则有以下关系：

若i == 1,则该结点为根，无双亲结点
若i > 1,则该结点的双亲结点编号为i /2
若2i ≤ n,则有编号为2i 的左孩子，否则没有左孩子
若2i+1 ≤ n,则有编号为2i+1的右孩子，否则没有右孩子
若 i 为奇数,且i != 1,则其左兄弟编号为i-1
若 i 为偶数,且i != n,则其右兄弟编号为i+1

二叉树实现代码

测试类：

public class Teat {
    public static void main(String[] args) {
        int i;
        int arr[] = {7, 4, 1, 5, 16, 8, 11, 12, 15, 9, 2}; /*原始数组*/
        BinaryTree tree = new BinaryTree();
        System.out.print("原始数组内容: \n");
        for (i = 0; i < 11; i++)
            System.out.print("[" + arr[i] + "] ");
        System.out.println();
        for (i = 0; i < arr.length; i++) tree.Add_Node_To_Tree(arr[i]);
        System.out.print("[二叉树aaaA的内容]\n");
        System.out.print("前序遍历结果：\n");
        tree.PreOrder(tree.rootNode);
        System.out.print("\n");
        System.out.print("中序遍历结果：\n");
        tree.InOrder(tree.rootNode);
        System.out.print("\n");
        System.out.print("后序遍历结果：\n");
        tree.PostOrder(tree.rootNode);
        System.out.print("\n");
    }
}

实现方法：

以链表的方式进行存储

class TreeNode {
    int value;
    TreeNode left_Node;
    TreeNode right_Node;

    public TreeNode(int value) {
        this.value = value;
        this.left_Node = null;
        this.right_Node = null;
    }
}

class BinaryTree {
    public TreeNode rootNode;

    public void Add_Node_To_Tree(int value) {
        if (rootNode == null) {
            rootNode = new TreeNode(value);
            return;
        }
        TreeNode currentNode = rootNode;
        while (true) {
            if (value < currentNode.value) {
                if (currentNode.left_Node == null) {
                    currentNode.left_Node = new TreeNode(value);
                    return;
                } else
                    currentNode = currentNode.left_Node;
            } else {
                if (currentNode.right_Node == null) {
                    currentNode.right_Node = new TreeNode(value);
                    return;
                } else
                    currentNode = currentNode.right_Node;
            }
        }
    }
	
	//先序遍历
    public void InOrder(TreeNode node) {
        if (node != null) {
            InOrder(node.left_Node);
            System.out.print("[" + node.value + "] ");
            InOrder(node.right_Node);
        }
    }
	
	//中序遍历
    public void PreOrder(TreeNode node) {
        if (node != null) {
            System.out.print("[" + node.value + "] ");
            PreOrder(node.left_Node);
            PreOrder(node.right_Node);
        }
    }
    
	//后序遍历
    public void PostOrder(TreeNode node) {
        if (node != null) {
            PostOrder(node.left_Node);
            PostOrder(node.right_Node);
            System.out.print("[" + node.value + "] ");
        }
    }
}

图文演示