Java实现二叉树（Binary Tree）使用二叉链式存储结构

Java实现二叉树（Binary Tree）使用二叉链式存储结构

以下使用二叉链表的方式实现

具体代码

package binarytree;

/**
 * 二叉树的二叉链表表示
 */
public class BinaryTree<T> {

    private TreeNode root;  //根节点

    public BinaryTree() {
    }

    public BinaryTree(TreeNode root) {
        this.root = root;
    }

    /**
     * 定义节点
     * 内部类
     */
    private static class TreeNode<T> {
        private T data = null;  // 数据部分
        private TreeNode lchild;  // 左节点的引用
        private TreeNode rchild; // 右节点的引用

        protected TreeNode() {
        }

        protected TreeNode(T data, TreeNode lchild, TreeNode rchild) {
            this.data = data;
            this.lchild = lchild;
            this.rchild = rchild;
        }

        private T getData() {
            return data;
        }

        private void setData(T data) {
            this.data = data;
        }

        private TreeNode getLchild() {
            return lchild;
        }

        private void setLchild(TreeNode lchild) {
            this.lchild = lchild;
        }

        private TreeNode getRchild() {
            return rchild;
        }

        private void setRchild(TreeNode rchild) {
            this.rchild = rchild;
        }
    }

    /**
     * 返回父结点
     *
     * @param element
     * @return
     */
    public TreeNode getParent(TreeNode element) {
        //如果传入参数为根节点或根节点为空，返回null
        return (root == null || root == element) ? null : parent(root, element);
    }

    /**
     * @param subTree
     * @param element
     * @return
     */
    public TreeNode parent(TreeNode subTree, TreeNode element) {
        if (subTree == null) {
            return null;
        }

        //如果subTree的左孩子节点或右孩子节点等于element，则返回subTree
        if (subTree.getLchild() == element || subTree.getRchild() == element) {
            // 返回父结点地址
            return subTree;
        }

        TreeNode p;
        // 现在左子树中找，如果左子树中没有找到，才到右子树去找
        if ((p = parent(subTree.getLchild(), element)) != null) {
            // 递归在左子树中搜索
            return p;
        } else {
            // 递归在右子树中搜索
            return parent(subTree.getRchild(), element);
        }
    }

    /**
     * 节点个数
     *
     * @return
     */
    public int getSize() {
        return getNum(root);
    }

    private int getNum(TreeNode node) {
        if (node == null) {
            return 0;
        } else {
            int i = getNum(node.getLchild());
            int j = getNum(node.getRchild());
            return j + i + 1;
        }
    }

    /**
     * 树高度
     *
     * @return
     */
    public int getHeight() {
        return getHeight(root);
    }

    private int getHeight(TreeNode tree) {
        if (tree == null)
            return 0;// 递归结束：空树高度为0
        else {
            int i = getHeight(tree.getLchild());
            int j = getHeight(tree.getRchild());
            return (i < j) ? (j + 1) : (i + 1);
        }
    }

    /**
     * 前序遍历
     * 先访问根结点，然后遍历左子树，最后遍历右子树
     *
     * @param node
     */
    public void preOrder(TreeNode node) {
        if (node != null) {
            System.out.println(node.getData());
            preOrder(node.getLchild());
            preOrder(node.getRchild());
        }
    }

    /**
     * 中序遍历
     * 首先遍历左子树，然后访问根结点，最后遍历右子树
     *
     * @param node
     */
    public void inOrder(TreeNode node) {
        if (node != null) {
            preOrder(node.getLchild());
            System.out.println(node.getData());
            preOrder(node.getRchild());
        }
    }

    /**
     * 后序遍历
     * 首先遍历左子树，然后遍历右子树，最后遍历访问根结点
     *
     * @param node
     */
    public void postOrder(TreeNode node) {
        if (node != null) {
            preOrder(node.getLchild());
            preOrder(node.getRchild());
            System.out.println(node.getData());
        }
    }

    public static void main(String[] args) {
        TreeNode n1 = new TreeNode("1", null, null);   // 没有左右孩子节点
        TreeNode n2 = new TreeNode("2", null, null);   // 没有左右孩子节点

        TreeNode n3 = new TreeNode("3", null, n2);  // 根节点左子树
        TreeNode n4 = new TreeNode("4", null, n1); // 根节点右子树
        TreeNode root = new TreeNode("root", n3, n4);   // 创建根节点

        BinaryTree bt = new BinaryTree(root);
        System.out.println("=======先序遍历======");
        bt.preOrder(bt.root);
        System.out.println("=======中序遍历======");
        bt.inOrder(bt.root);
        System.out.println("========后续遍历=======");
        bt.postOrder(bt.root);
        System.out.println("===========");
        System.out.println(bt.getHeight());
        System.out.println(bt.getSize());

        System.out.println(bt.getParent(n1).getData());
    }
}

构造的树的示意图

共有五个节点的二叉树

程序运行结果：

=======先序遍历======

root

3

2

4

1

=======中序遍历======

3

2

root

4

1

========后续遍历=======

3

2

4

1

root

===========

3

5

4

====END====