二叉樹的java實現

一、分析

　　一個二叉樹節點有三個部分，一個是指向左子樹的部分，一個是指向右子樹的部分，另外一個是數據部分。可以把這個節點抽象成一個節點對象，給對象有兩個節點對象屬性和一個數據屬性。如下圖：

　　一個二叉樹有只有一個根節點，其余的都是根節點的直接或間接子節點。所以可以把二叉樹抽象成一個對象，該對象有一個節點類型的數據，也就是用來保存根節點。如下圖：

 

二、代碼

package com.algorithms.treee;

/**
 * 二叉樹
 */
public class BinaryTree
{
    private TreeNode root;// 根節點

    public BinaryTree()
    {
    }

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

    public TreeNode getRoot()
    {
        return root;
    }

    public void setRoot(TreeNode root)
    {
        this.root = root;
    }

    /**
     * 定義節點
     */
    private static class TreeNode
    {
        private String data = null;// 數據部分
        private TreeNode left;// 左節點的引用
        private TreeNode right;// 右節點的引用

        public TreeNode()
        {
        }

        public TreeNode(String data, TreeNode left, TreeNode right)
        {
            this.data = data;
            this.left = left;
            this.right = right;
        }

        public String getData()
        {
            return data;
        }

        public void setData(String data)
        {
            this.data = data;
        }

        public TreeNode getLeft()
        {
            return left;
        }

        public void setLeft(TreeNode left)
        {
            this.left = left;
        }

        public TreeNode getRight()
        {
            return right;
        }

        public void setRight(TreeNode right)
        {
            this.right = right;
        }

    }

    /**
     * 返回父結點
     * 
     * @param element
     * @return
     */
    public TreeNode getParent(TreeNode element)
    {
        return (root == null || root == element) ? null : parent(root, element);
    }

    public TreeNode parent(TreeNode subTree, TreeNode element)
    {
        if (subTree == null)
            return null;
        if (subTree.getLeft() == element || subTree.getRight() == element)
            // 返回父結點地址
            return subTree;
        TreeNode p;
        // 現在左子樹中找，如果左子樹中沒有找到，才到右子樹去找
        if ((p = parent(subTree.getLeft(), element)) != null)
            // 遞歸在左子樹中搜索
            return p;
        else
            // 遞歸在右子樹中搜索
            return parent(subTree.getRight(), element);
    }

    /**
     * 節點個數
     * 
     * @return
     */
    public int getSize()
    {
        return getNum(root);
    }

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

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

    private int getHeight(TreeNode node)
    {
        if (node == null)
            return 0;// 遞歸結束：空樹高度為0
        else
        {
            int i = getHeight(node.getLeft());
            int j = getHeight(node.getRight());
            return (i < j) ? (j + 1) : (i + 1);
        }
    }

    /**
     * 前序遍歷
     * 
     * @param node
     */
    public void preOrder(TreeNode node)
    {
        if (node != null)
        {
            System.out.println(node.getData());
            preOrder(node.getLeft());
            preOrder(node.getRight());
        }
    }

    /**
     * 中序遍歷
     * 
     * @param node
     */
    public void inOrder(TreeNode node)
    {
        if (node != null)
        {
            inOrder(node.getLeft());
            System.out.println(node.getData());
            inOrder(node.getRight());
        }
    }

    /**
     * 后續遍歷
     * 
     * @param node
     */
    public void postOrder(TreeNode node)
    {
        if (node != null)
        {
            postOrder(node.getLeft());
            postOrder(node.getRight());
            System.out.println(node.getData());
        }
    }

    public static void main(String[] args)
    {

        TreeNode l12 = new TreeNode("left12", null, null);
        TreeNode r12 = new TreeNode("right12", null, null);
        TreeNode l22 = new TreeNode("left22", null, null);
        TreeNode r22 = new TreeNode("right22", null, null);

        TreeNode l1 = new TreeNode("left1", l12, r12);// 根節點左子樹
        TreeNode r1 = new TreeNode("right1", l22, r22);// 根節點右子樹
        TreeNode root = new TreeNode("root", l1, r1);// 創建根節點

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

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