用Java實現二叉樹

二叉樹的定義：

二叉樹是樹形結構的一個重要類型。許多實際問題抽象出來的數據結構往往是二叉樹的形式，即使是一般的樹也能簡單地轉換爲二叉樹，而且二叉樹的存儲結構及其算法都較爲簡單，因此二叉樹顯得特別重要。
    二叉樹(BinaryTree)是n(n≥0)個結點的有限集，它或者是空集(n=0)，或者由一個根結點及兩棵互不相交的、分別稱作這個根的左子樹和右子樹的二叉樹組成。
    這個定義是遞歸的。由於左、右子樹也是二叉樹， 因此子樹也可爲空樹。下圖中展現了五種不同基本形態的二叉樹。

 

 

    其中 (a) 爲空樹， (b) 爲僅有一個結點的二叉樹， (c) 是僅有左子樹而右子樹爲空的二叉樹， (d) 是僅有右子樹而左子樹爲空的二叉樹， (e) 是左、右子樹均非空的二叉樹。這裏應特別注意的是，二叉樹的左子樹和右子樹是嚴格區分並且不能隨意顛倒的，圖 (c) 與圖 (d) 就是兩棵不同的二叉樹。

二叉樹的遍歷

對於二叉樹來講最主要、最基本的運算是遍歷。
    遍歷二叉樹 是指以一定的次序訪問二叉樹中的每個結點。所謂 訪問結點 是指對結點進行各種操作的簡稱。例如，查詢結點數據域的內容，或輸出它的值，或找出結點位置，或是執行對結點的其他操作。遍歷二叉樹的過程實質是把二叉樹的結點進行線性排列的過程。假設遍歷二叉樹時訪問結點的操作就是輸出結點數據域的值，那麼遍歷的結果得到一個線性序列。

從二叉樹的遞歸定義可知，一棵非空的二叉樹由根結點及左、右子樹這三個基本部分組成。因此，在任一給定結點上，可以按某種次序執行三個操作：
    　（1）訪問結點本身(N)，
    　（2）遍歷該結點的左子樹(L)，
    　（3）遍歷該結點的右子樹(R)。
以上三種操作有六種執行次序：
    　NLR、LNR、LRN、NRL、RNL、RLN。
注意：
    前三種次序與後三種次序對稱，故只討論先左後右的前三種次序。
　　由於被訪問的結點必是某子樹的根，所以N(Node)、L(Left subtlee)和R(Right subtree)又可解釋爲根、根的左子樹和根的右子樹。NLR、LNR和LRN分別又稱爲先根遍歷、中根遍歷和後根遍歷。

二叉樹的java實現

首先創建一棵二叉樹如下圖，然後對這顆二叉樹進行遍歷操作（遍歷操作的實現分爲遞歸實現和非遞歸實現），同時還提供一些方法如獲取雙親結點、獲取左孩子、右孩子等。

java實現代碼：

package study_02.datastructure.tree;

import java.util.Stack;

/**
 * 二叉樹的鏈式存儲
 * @author WWX
 */
public class BinaryTree {


    private TreeNode root=null;

    public BinaryTree(){
        root=new TreeNode(1,"rootNode(A)");
    }

    /**
     * 創建一棵二叉樹
     * <pre>
     *           A
     *     B          C
     *  D     E            F
     *  </pre>
     * @param root
     * @author WWX
     */
    public void createBinTree(TreeNode root){
        TreeNode newNodeB = new TreeNode(2,"B");
        TreeNode newNodeC = new TreeNode(3,"C");
        TreeNode newNodeD = new TreeNode(4,"D");
        TreeNode newNodeE = new TreeNode(5,"E");
        TreeNode newNodeF = new TreeNode(6,"F");
        root.leftChild=newNodeB;
        root.rightChild=newNodeC;
        root.leftChild.leftChild=newNodeD;
        root.leftChild.rightChild=newNodeE;
        root.rightChild.rightChild=newNodeF;
    }


    public boolean isEmpty(){
        return root==null;
    }

    //樹的高度
    public int height(){
        return height(root);
    }

    //節點個數
    public int size(){
        return size(root);
    }


    private int height(TreeNode subTree){
        if(subTree==null)
            return 0;//遞歸結束：空樹高度爲0
        else{
            int i=height(subTree.leftChild);
            int j=height(subTree.rightChild);
            return (i<j)?(j+1):(i+1);
        }
    }

    private int size(TreeNode subTree){
        if(subTree==null){
            return 0;
        }else{
            return 1+size(subTree.leftChild)
                    +size(subTree.rightChild);
        }
    }

    //返回雙親結點
    public TreeNode parent(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.leftChild==element||subTree.rightChild==element)
            //返回父結點地址
            return subTree;
        TreeNode p;
        //現在左子樹中找，如果左子樹中沒有找到，纔到右子樹去找
        if((p=parent(subTree.leftChild, element))!=null)
            //遞歸在左子樹中搜索
            return p;
        else
            //遞歸在右子樹中搜索
            return parent(subTree.rightChild, element);
    }

    public TreeNode getLeftChildNode(TreeNode element){
        return (element!=null)?element.leftChild:null;
    }

    public TreeNode getRightChildNode(TreeNode element){
        return (element!=null)?element.rightChild:null;
    }

    public TreeNode getRoot(){
        return root;
    }

    //在釋放某個結點時，該結點的左右子樹都已經釋放，
    //所以應該採用後續遍歷，當訪問某個結點時將該結點的存儲空間釋放
    public void destroy(TreeNode subTree){
        //刪除根爲subTree的子樹
        if(subTree!=null){
            //刪除左子樹
            destroy(subTree.leftChild);
            //刪除右子樹
            destroy(subTree.rightChild);
            //刪除根結點
            subTree=null;
        }
    }

    public void traverse(TreeNode subTree){
        System.out.println("key:"+subTree.key+"--name:"+subTree.data);;
        traverse(subTree.leftChild);
        traverse(subTree.rightChild);
    }

    //前序遍歷
    public void preOrder(TreeNode subTree){
        if(subTree!=null){
            visted(subTree);
            preOrder(subTree.leftChild);
            preOrder(subTree.rightChild);
        }
    }

    //中序遍歷
    public void inOrder(TreeNode subTree){
        if(subTree!=null){
            inOrder(subTree.leftChild);
            visted(subTree);
            inOrder(subTree.rightChild);
        }
    }

    //後續遍歷
    public void postOrder(TreeNode subTree) {
        if (subTree != null) {
            postOrder(subTree.leftChild);
            postOrder(subTree.rightChild);
            visted(subTree);
        }
    }

    //前序遍歷的非遞歸實現
    public void nonRecPreOrder(TreeNode p){
        Stack<TreeNode> stack=new Stack<TreeNode>();
        TreeNode node=p;
        while(node!=null||stack.size()>0){
            while(node!=null){
                visted(node);
                stack.push(node);
                node=node.leftChild;
            }
            <span abp="507" style="font-size:14px;">while</span>(stack.size()>0){
                node=stack.pop();
                node=node.rightChild;
            }
        }
    }

    //中序遍歷的非遞歸實現
    public void nonRecInOrder(TreeNode p){
        Stack<TreeNode> stack =new Stack<BinaryTree.TreeNode>();
        TreeNode node =p;
        while(node!=null||stack.size()>0){
            //存在左子樹
            while(node!=null){
                stack.push(node);
                node=node.leftChild;
            }
            //棧非空
            if(stack.size()>0){
                node=stack.pop();
                visted(node);
                node=node.rightChild;
            }
        }
    }

    //後序遍歷的非遞歸實現
    public void noRecPostOrder(TreeNode p){
        Stack<TreeNode> stack=new Stack<BinaryTree.TreeNode>();
        TreeNode node =p;
        while(p!=null){
            //左子樹入棧
            for(;p.leftChild!=null;p=p.leftChild){
                stack.push(p);
            }
            //當前結點無右子樹或右子樹已經輸出
            while(p!=null&&(p.rightChild==null||p.rightChild==node)){
                visted(p);
                //紀錄上一個已輸出結點
                node =p;
                if(stack.empty())
                    return;
                p=stack.pop();
            }
            //處理右子樹
            stack.push(p);
            p=p.rightChild;
        }
    }
    public void visted(TreeNode subTree){
        subTree.isVisted=true;
        System.out.println("key:"+subTree.key+"--name:"+subTree.data);;
    }


    /**
     * 二叉樹的節點數據結構
     * @author WWX
     */
    private class  TreeNode{
        private int key=0;
        private String data=null;
        private boolean isVisted=false;
        private TreeNode leftChild=null;
        private TreeNode rightChild=null;

        public TreeNode(){}

        /**
         * @param key  層序編碼
         * @param data 數據域
         */
        public TreeNode(int key,String data){
            this.key=key;
            this.data=data;
            this.leftChild=null;
            this.rightChild=null;
        }


    }


    //測試
    public static void main(String[] args) {
        BinaryTree bt = new BinaryTree();
        bt.createBinTree(bt.root);
        System.out.println("the size of the tree is " + bt.size());
        System.out.println("the height of the tree is " + bt.height());

        System.out.println("*******(前序遍歷)[ABDECF]遍歷*****************");
        bt.preOrder(bt.root);

        System.out.println("*******(中序遍歷)[DBEACF]遍歷*****************");
        bt.inOrder(bt.root);

        System.out.println("*******(後序遍歷)[DEBFCA]遍歷*****************");
        bt.postOrder(bt.root);

        System.out.println("***非遞歸實現****(前序遍歷)[ABDECF]遍歷*****************");
        bt.nonRecPreOrder(bt.root);

        System.out.println("***非遞歸實現****(中序遍歷)[DBEACF]遍歷*****************");
        bt.nonRecInOrder(bt.root);

        System.out.println("***非遞歸實現****(後序遍歷)[DEBFCA]遍歷*****************");
        bt.noRecPostOrder(bt.root);
    }
}
</span>

 

輸出結果

the size of the tree is 6
the height of the tree is 3
*******(前序遍歷)[ABDECF]遍歷*****************
key:1--name:rootNode(A)
key:2--name:B
key:4--name:D
key:5--name:E
key:3--name:C
key:6--name:F
*******(中序遍歷)[DBEACF]遍歷*****************
key:4--name:D
key:2--name:B
key:5--name:E
key:1--name:rootNode(A)
key:3--name:C
key:6--name:F
*******(後序遍歷)[DEBFCA]遍歷*****************
key:4--name:D
key:5--name:E
key:2--name:B
key:6--name:F
key:3--name:C
key:1--name:rootNode(A)
***非遞歸實現****(前序遍歷)[ABDECF]遍歷*****************
key:1--name:rootNode(A)
key:2--name:B
key:4--name:D
key:5--name:E
key:3--name:C
key:6--name:F
***非遞歸實現****(中序遍歷)[DBEACF]遍歷*****************
key:4--name:D
key:2--name:B
key:5--name:E
key:1--name:rootNode(A)
key:3--name:C
key:6--name:F
***非遞歸實現****(後序遍歷)[DEBFCA]遍歷*****************
key:4--name:D
key:5--name:E
key:2--name:B
key:6--name:F
key:3--name:C
key:1--name:rootNode(A)