JAVA實現二叉樹

      摘要： 一個二叉樹的Java實現。可以學習廣義表達式及二叉樹的遞歸及非遞歸處理技巧。

      難度：初級。

 

       為了克服對樹結構編程的畏懼感和神秘感，下定決心將二叉樹的大部分操作實現一遍，並希望能夠掌握二叉樹編程的一些常用技術和技巧。

      [1]  數據結構和表示： 二叉樹的輸入輸出格式采用廣義表表達式形式，內部表示采用左孩子右孩子的鏈式存儲。

      [2]  已經實現的操作有：

             A. 根據二叉樹的廣義表表達式來創建二叉樹(含表達式合法性檢測)；

             B. 根據二叉樹的前序和中序遍歷列表來創建二叉樹；

             C. 根據二叉樹的中序和后序遍歷列表來創建二叉樹；

             D. 二叉樹的“左孩子右孩子”鏈式存儲轉化為廣義表表達式；

             E. 二叉樹的前序、中序、后序的遞歸和非遞歸遍歷；層序遍歷；結點關聯列表；

             F. 求解二叉樹的高度、結點總數、葉子結點總數、所有的葉子結點列表；根結點到所有葉子結點的路徑；最長路徑；

             G. 二叉樹復制，二叉樹全等性比較，二叉樹交換（將二叉樹的所有結點的左右子樹互換）

       [3]  尚待實現的操作：

             A. 求解二叉樹中所有最長(短)路徑

             E. 其它

 

       [4]  二叉樹 Java 實現代碼：

      

/**
 * BinaryTree: 實現二叉樹，可以根據給定的廣義表表達式、前序及中序遍歷列表、中序及后序遍歷列表創建二叉樹;
 *             二叉樹的前序、中序、后序的遞歸和非遞歸遍歷，層序遍歷;求解二叉樹的一些特性
 *             
 * @author shuqin1984 2011-3-19
 * 
 */
package datastructure.tree;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class BinaryTree {
    
    /**    二叉樹的廣義表表示  */
    private String expression;
    /**      樹的根結點   */    
    private TreeNode  root;
    
    /** 
     * 用於檢測二叉樹廣義表表達式合法性的編譯了的正則表達式:
     * 合法的廣義表表達式可以是：
     * [1] 基本表達式： A，A(,), A(B,), A(,B), A(B,C)
     * [2] 上述的 A，B，C 可以是 [1] 中的基本表達式
     * [3] A,B,C 可允許的取值范圍由應用決定，這里僅允許是 大小寫字母，數字，+-/*%
     * [4] 表達式中不含任何空格符，因此，在檢查表達式之前，必須確保表達式中不含空格符
     * 
     */
    private static String permittedChars = "[a-zA-Z0-9//+//-//*/////%]";
    private static String basicUnit = "[a-zA-Z0-9//+//-//*/////%//(//),]";
    private static Pattern basicPattern = Pattern.compile("" + "|" + permittedChars + "|" + permittedChars + "//(" + permittedChars + "?," + permittedChars + "?//)?");
    private static Pattern extendPattern = Pattern.compile(permittedChars + "//(" + basicUnit + "*," + basicUnit + "*//)");
    
    /**
     * 構造器
     * @param root 樹的根結點
     */
    public BinaryTree(TreeNode root) {
        this.root = root;
    }
    
    /**
     * 構造器
     * @param expression 二叉樹的廣義表表達式
     */
    private BinaryTree(String expression) {
        this.expression = expression;
    }
    /**
     * 樹結點實現
     */
    private class TreeNode {
        
        private char ch;
        private TreeNode rchild;
        private TreeNode lchild;
        
        public TreeNode(char ch, TreeNode rchild, TreeNode lchild) {
            this.ch = ch;
            this.rchild = rchild;
            this.lchild = lchild;
        }
        public char getCh() {
            return ch;
        }
        public TreeNode getRchild() {
            return rchild;
        }
        public void setRchild(TreeNode rchild) {
            this.rchild = rchild;
        }
        public TreeNode getLchild() {
            return lchild;
        }
        public void setLchild(TreeNode lchild) {
            this.lchild = lchild;
        }    
        
        public String toString()
        {
            return "" + getCh();
        }
    }
    
    /**
     * 結點關聯類
     */
    private class NodeLink {
        
        private TreeNode node1;
        private TreeNode node2;
        
        public NodeLink(TreeNode node1, TreeNode node2) {
            this.node1 = node1;
            this.node2 = node2;
        }
        
        public String toString() {
            
            return "(" + node1.getCh() + "," + node2.getCh() + ")";
        }
            
    }
    
    /**
     *  【設置/獲取】屬性
     */
    public TreeNode getRoot() {
        return root;
    }
    public void setRoot(TreeNode root) {
        this.root = root;
    }
    
    
    /**
     * getPreOrderList: 獲得樹的先序遍歷列表
     * @param flag 是否采用遞歸遍歷的標記；若 flag = true， 采用遞歸遍歷；否則，采用非遞歸遍歷
     * @return 二叉樹的先序遍歷列表
     */
    
    public List<TreeNode> getPreOrderList(boolean flag) {
        
        List<TreeNode>    nodelist = new ArrayList<TreeNode>();
        if (flag == true) {
           nodelist = preOrderTraverse(getRoot(), nodelist);
        }
        else {
           nodelist = preOrderTraverseIter(getRoot());
        }
        return nodelist;
    }
    
    /**
     * getInOrderList: 獲得樹的中序遍歷列表
     * @param flag 是否采用遞歸遍歷的標記；若 flag = true， 采用遞歸遍歷；否則，采用非遞歸遍歷
     * @return 獲得樹的中序遍歷列表
     */
    
    public List<TreeNode> getInOrderList(boolean flag) {
        
        List<TreeNode>    nodelist = new ArrayList<TreeNode>();
        if (flag == true) {
           nodelist = inOrderTraverse(getRoot(), nodelist);
        }
        else {
           nodelist = inOrderTraverseIter(getRoot());
        }
        return nodelist;
    }
    
    /**
     * getPostOrderList: 獲得樹的后序遍歷列表
     * @param flag 是否采用遞歸遍歷的標記；若 flag = true， 采用遞歸遍歷；否則，采用非遞歸遍歷
     * @return 獲得樹的后序遍歷列表
     */
    
    public List<TreeNode> getPostOrderList(boolean flag) {
        
        List<TreeNode>    nodelist = new ArrayList<TreeNode>();
        if (flag == true) {
            nodelist = postOrderTraverse(getRoot(), nodelist);
        }
        else {
            nodelist = postOrderTraverseIter(getRoot());
        }
        return nodelist;
    }
    
    /**
     * 獲得樹的層序遍歷列表
     * 
     * @return 獲得樹的層序遍歷列表
     */
    
    public List<TreeNode> getFloorOrderList() {
        
        List<TreeNode>    nodelist = new ArrayList<TreeNode>();
        nodelist = floorOrderTraverse(getRoot());
        return nodelist;
    }
    
    /**
     * createBinaryTree: 根據樹的廣義表表示構造二叉樹
     * @throws Exception 
     */
    public static BinaryTree createBinaryTree(String expression) throws Exception 
    {
        BinaryTree bt = new BinaryTree(trimSpace(expression));
        bt.createBinaryTree();
        return bt;
    }
    
    /**
     * createBinaryTree: 根據二叉樹的廣義表表達式來創建二叉樹
     * @exception 若二叉樹的廣義表表達式不合法，則拋出異常
     */
    private void createBinaryTree() throws Exception {
        
        // 檢查傳入的二叉樹廣義表示法是否合法有效
        if (!checkValid(expression))
            throw new Exception("廣義表表達式不合法，無法創建二叉樹!");
        
        // 使用 LinkedList 來執行棧的功能
        LinkedList<TreeNode> stack = new LinkedList<TreeNode>();
        TreeNode newnode = null;
        int flag = 0;  //  flag = 0: 創建左子樹 | flag = 1: 創建右子樹
        
        for (char ch: expression.toCharArray()) {
            switch (ch) {
               
               // 遇到  "(" 時，表示該結點可能有孩子結點，將該父結點壓入棧中
               case '(': 
                   stack.push(newnode);
                   flag = 0;
                   break;
                   
               // 遇到  ")" 時，表示已經掃描完父結點的右孩子結點的值，彈出該父結點       
               case ')':
                   stack.pop();
                   break;
                   
              // 遇到 "," 時， 表示將要掃描父結點的右孩子結點的值。       
               case ',':
                   flag = 1;
                   break;       
              
              // 遇到結點的值，將其加入二叉樹中       
               default:
                   
                    newnode = new TreeNode(ch, null, null);
                    if (root == null) {
                           root = newnode;
                    }
                    else {
                           if (flag == 0) {
                              TreeNode topnode = stack.peek();
                              topnode.setLchild(newnode);
                           }
                           else 
                           {
                               TreeNode topnode = stack.peek();
                               topnode.setRchild(newnode); 
                           }
                    }
                    break;           
            }
        }        
    }
    
    /**
     * checkValid: 判斷給定二叉樹的廣義表表示是否合法有效
     *             
     * @param expression 給定二叉樹的廣義表表示【字符串形式】
     * @return 如果給定的二叉樹廣義表表示合法有效，返回true; 否則，返回 false
     * 
     */
    private static boolean checkValid(String expression)
    {
        Matcher m = null;
        if (basicPattern.matcher(expression).matches())
            return true;
        else if ((m = extendPattern.matcher(expression)).matches()) {
            int index = separatorIndex(expression);
            if (index == -1) {  // 不存在能夠分割二叉樹廣義表達式的左右子樹表達式的逗號
                return false;
            }
            String rightEx = "";
            String leftEx = ""; 
            if (index > 2) {
                leftEx = expression.substring(2, index);  // 左子樹的廣義表達式
            }
            if (index < expression.length()-2) { 
                  rightEx = expression.substring(index+1, expression.length()-1);  // 右子樹的廣義表達式
            }
            return checkValid(leftEx) && checkValid(rightEx);        
        }
        else {
            return false;
        }
    }
    
    
    /**
     * getGeneralList: 獲取該二叉樹的廣義表表示(字符串表示)
     */
    public String getGeneralListString()
    {
        StringBuilder sb = new StringBuilder("");
        if (expression == null) {
            createGeneralList(root, sb);
            return sb.toString();
        }
        return  expression;        
    }
    
    /**
     * getGeneralList: 根據給定二叉樹生成其廣義表表示(字符串形式)
     * @param root 樹的根結點
     * @return 樹的廣義表表示【字符串形式】
     */    
    private void createGeneralList(TreeNode root, StringBuilder sb) {
        
        if (root != null) {
            
            sb.append(root.getCh());
            if (root.getLchild() != null || root.getRchild() != null) {
                sb.append('(');
                if (root.getLchild() != null) {
                    createGeneralList(root.getLchild(), sb);
                }
                sb.append(',');
                if (root.getRchild() != null) {                
                    createGeneralList(root.getRchild(), sb);        
                }
                sb.append(')');
            }    
        }            
    }
    
    /**
     * size: 獲取二叉樹的結點總數
     *  
     * @param root 樹的根結點
     * @return  樹的結點總數
     * 
     */
    public int size(TreeNode root) {
        
        if (root == null)
            return 0;
        else {
            return size(root.getLchild()) + size(root.getRchild()) + 1;
        }
    }
    
    /**
     * leafCounter: 獲取二叉樹的葉子結點數目
     * 
     * @param root 樹的根結點
     * @return  樹的葉子結點數目
     * 
     */
    public int leafCounter(TreeNode root) {
        if (root == null)
            return 0;
        else {
            if (root.getLchild() == null && root.getRchild() == null)
                return 1;
            else
                return leafCounter(root.getLchild()) + leafCounter(root.getRchild());
        }
    }
    
    /**
     * getLeafNodes : 獲取該二叉樹的所有葉子結點
     */
    public List<TreeNode> getLeafNodes()
    {
        List<TreeNode> leaflist = new ArrayList<TreeNode>();
        getLeafNodes(getRoot(), leaflist);
        return leaflist;
    }
    
    /**
     * printLeafPaths : 打印該二叉樹的所有葉子結點到根的路徑
     */
    public void printLeafPaths()
    {
        List<TreeNode> leafPath = new ArrayList<TreeNode>();
        buildLeafPaths(root, leafPath);
    }
    
    /**
     * buildLeafPaths : 遞歸求解給定二叉樹的所有葉子結點到根的路徑
     * @param root 給定二叉樹的根結點
     * @param path 存放某個葉子結點到根的路徑
     */
    public void buildLeafPaths(TreeNode root, List<TreeNode> path)
    {
        if (root != null) {    
            path.add(root);  // 將從根結點到葉子結點的路徑上的結點保存起來
            if (root.getLchild() == null && root.getRchild() == null) { // 到達葉子結點，完成一條路徑，並可對其處理
                processPath(path);
            }
            else {
                buildLeafPaths(root.getLchild(), path);
                if (root.getLchild() != null) {      
                   path.remove(path.size()-1);  // 回溯，從左子樹到右子樹，刪除前一條路徑上的葉子結點
                }
                buildLeafPaths(root.getRchild(), path);
                if (root.getRchild() != null) {
                   path.remove(path.size()-1);
                }
            }
        }
    }
    
    /**
     * processPath : 處理從某葉子結點到根結點的路徑的操作
     */
    private void processPath(List<TreeNode> path)
    {
        System.out.println(listToString(path));
    }
    
    /**
     * getLeafNodes: 遞歸求解給定二叉樹的所有葉子結點
     * @param root   給定二叉樹的根結點
     * @param leaflist 給定二叉樹的所有葉子結點
     */
    private void getLeafNodes(TreeNode root, List<TreeNode> leaflist)
    {
        if (root != null) {
            if (root.getLchild() == null && root.getRchild() == null) {
                leaflist.add(root);
                return ;
            }
            getLeafNodes(root.getLchild(), leaflist);
            getLeafNodes(root.getRchild(), leaflist);
        }
    }
    
    
    /**
     * height: 獲取二叉樹的高度 
     * 
     * @param root   樹的根結點
     * @return       樹的高度
     *  
     */
    
    public int height(TreeNode root)
    {
        if (root == null)
            return 0;
        else
            return 1 + Math.max(height(root.getLchild()), height(root.getRchild()));
    }
    
    /**
     * getNodelinkList: 獲取該二叉樹的結點關聯列表
     * @return 樹的結點關聯列表
     */
    public List<NodeLink> getNodelinkList() {
        
        List<NodeLink> linklist = new ArrayList<NodeLink>();
        createNodelinkList(getRoot(), linklist);
        return linklist;
        
    }
        
    /**
     * createNodelinkList: 遞歸求解給定二叉樹的結點關聯列表表示
     * @param root 給定二叉樹的根結點
     * @param linklist 存放給定二叉樹的結點關聯對象
     */
    private void createNodelinkList(TreeNode root, List<NodeLink> linklist) {
        
        if (root != null) {
            if (root.getLchild() != null) {
                NodeLink nodelink = new NodeLink(root, root.getLchild());
                linklist.add(nodelink);
                createNodelinkList(root.getLchild(), linklist);
            }
            if (root.getRchild() != null) {
                NodeLink nodelink = new NodeLink(root, root.getRchild());
                linklist.add(nodelink);
                createNodelinkList(root.getRchild(), linklist);
            }
        }
    }
    
    /**
     * preOrderTraverse: 二叉樹的遞歸先序遍歷
     * 
     */
    private List<TreeNode> preOrderTraverse(TreeNode root, List<TreeNode> nodelist) {
        
        if (root != null) {
            nodelist.add(root);
            preOrderTraverse(root.getLchild(), nodelist);    
            preOrderTraverse(root.getRchild(), nodelist);
        }
        
        return nodelist;
    }
    
    /**
     * preOrderTraverseIter: 二叉樹的非遞歸先序遍歷
     */
    private List<TreeNode> preOrderTraverseIter(TreeNode root) {
        LinkedList<TreeNode> stack = new LinkedList<TreeNode>();
        List<TreeNode> nodelist = new ArrayList<TreeNode>();
        TreeNode pNode = root;
        for (;;) {
            while (pNode != null) {
                nodelist.add(pNode);        // 訪問根結點
                stack.push(pNode);          // 根結點入棧    
                pNode = pNode.getLchild();  // 訪問左子樹
            }    
            pNode = stack.pop();
            pNode = pNode.getRchild();      // 訪問右子樹
            if (pNode == null && stack.isEmpty()) { break; }
        }           
        return nodelist;
    }
    
    /**
     * inOrderTraverse: 二叉樹的遞歸中序遍歷
     * 
     */
    private List<TreeNode> inOrderTraverse(TreeNode root, List<TreeNode> nodelist) {
        
        if (root != null) {
            inOrderTraverse(root.getLchild(), nodelist);
            nodelist.add(root);
            inOrderTraverse(root.getRchild(), nodelist);
        }
        
        return nodelist;
    }
    
    /**
     * inOrderTraverseIter: 二叉樹的非遞歸中序遍歷
     */
    
    private List<TreeNode> inOrderTraverseIter(TreeNode root) {
        
        LinkedList<TreeNode> stack = new LinkedList<TreeNode>();
        List<TreeNode> nodelist = new ArrayList<TreeNode>();
        
        TreeNode pNode = root;
        for (;;) {
            while (pNode != null) {            // 訪問左子樹
                stack.push(pNode);      
                pNode = pNode.getLchild();
            }
            pNode = stack.pop();   
            nodelist.add(pNode);               // 訪問根結點
            pNode = pNode.getRchild();           // 訪問右子樹
            if (pNode == null && stack.isEmpty()) { break; }
        }
        
        return nodelist;
    }
    
    /**
     * postOrderTraverse: 二叉樹的遞歸后序遍歷
     */
    private List<TreeNode> postOrderTraverse(TreeNode root, List<TreeNode> nodelist) {
        
        if (root != null) {
            postOrderTraverse(root.getLchild(), nodelist);
            postOrderTraverse(root.getRchild(), nodelist);
            nodelist.add(root);
        }
        
        return nodelist;
    }
    
    /**
     * postOrderTraverseIter: 二叉樹的非遞歸后序遍歷
     */
    private List<TreeNode> postOrderTraverseIter(TreeNode root) {
        
        LinkedList<TreeNode> stack = new LinkedList<TreeNode>();
        List<TreeNode> nodelist = new ArrayList<TreeNode>();
        
        int flag = 0;  // 標識是否訪問過右子樹; flag = 0 表示沒有訪問； flag = 1 表示已經訪問過
        TreeNode pNode = root;
        TreeNode tmpNode = null;
        loop1:
        for (;;) {
            while (pNode != null) {        // 訪問左子樹
                stack.push(pNode);     
                pNode = pNode.getLchild();
                flag = 0;
            }
            loop2:
            for (;;) {
                if (!stack.isEmpty()) {
                    
                    if (flag == 0)               // 尚未訪問根結點的右子樹
                    {
                       pNode = stack.peek();     // 取根結點的右子樹，訪問其右子樹
                       pNode = pNode.getRchild(); 
                       flag = 1;
                       continue loop1;
                    }
                    
                    if (flag == 1) {            // 已經訪問過右子樹
                        pNode = stack.pop();
                        nodelist.add(pNode);    // 訪問根結點，實際上是左右子樹均為空的葉子結點 
                        tmpNode = pNode;        // 訪問某個結點后，立即訪問其父結點的右子樹
                        pNode = stack.peek();   // 取該結點的父結點    
                        if (pNode != null) {    // 父結點不為空(沒有回溯到整棵樹的根結點)
                            if (tmpNode == pNode.getRchild()) { 
                                // 如果剛剛訪問的結點正是其父結點的右孩子，則直接回溯訪問其父結點; 
                                continue loop2; 
                            }
                            else {  // 否則，訪問其父結點的右子樹
                                pNode = pNode.getRchild();
                                continue loop1;
                            }
                        } 
                        
                    }
                    
                    
                }
                else   // 棧空，遞歸調用結束，退出
                {
                    break loop1;
                }
            }    
            
        }
        return nodelist;
    }
    
    /**
     * floorOrderTraverse: 二叉樹的層序遍歷
     * 
     * @param  root 樹的根結點
     * @return 樹的層序遍歷列表
     * 
     */
    private List<TreeNode> floorOrderTraverse(TreeNode root) {
        
        // 使用 LinkedList 來執行隊列的功能
        LinkedList<TreeNode> queue = new LinkedList<TreeNode>();
        List<TreeNode> nodelist = new ArrayList<TreeNode>();
        if (root != null) {
            nodelist.add(root);
            queue.addLast(root);
            while(queue.size() > 0) {
                TreeNode node = queue.removeFirst();
                if (node.getLchild() != null) {
                    nodelist.add(node.getLchild());
                    queue.addLast(node.getLchild());
                }   
                if (node.getRchild() != null) {
                    nodelist.add(node.getRchild());
                    queue.addLast(node.getRchild());
                }    
            }
        }
        
        return nodelist;
    }
    
    /**
     * copyBinaryTree: 復制二叉樹
     * @return 復制后的二叉樹
     */
    public BinaryTree copyBinaryTree()
    {
        TreeNode anotherRoot = null;
        anotherRoot = copy(getRoot());
        return new BinaryTree(anotherRoot);
    }
    
    /**
     * copy: 復制二叉樹
     * @param srcRoot 要復制的二叉樹的根結點
     * @param destRoot 目標二叉樹的根結點
     */
    private TreeNode copy(TreeNode srcRoot)
    {
        if (srcRoot != null) {
            TreeNode newNode = new TreeNode(srcRoot.getCh(), null, null);
            newNode.setLchild(copy(srcRoot.getLchild()));
            newNode.setRchild(copy(srcRoot.getRchild()));
            return newNode;
        }
        return null;
    }
    
    /**
     * equalsTo: 比較該二叉樹與給定二叉樹 another 是否全等；
     *           若全等則返回 true, 否則返回 false.
     */
    public boolean equalsTo(BinaryTree another)
    {
        return compareEqual(root, another.getRoot());
    }
    
    /**
     * equalsTo : 比較給定的兩個二叉樹是否全等
     *            兩個二叉樹全等當且僅當 
     *            A. 兩個二叉樹均為空; 或者 
     *            B. 兩個二叉樹均非空，且所有對應位置的結點都相同，對應結點之間的關聯也完全相同.
     */
    private boolean compareEqual(TreeNode root, TreeNode anotherRoot)
    {
        return (root == null && anotherRoot == null) || 
               ((root != null && anotherRoot != null) &&
                (root.getCh() == anotherRoot.getCh()) &&
                (compareEqual(root.getLchild(), anotherRoot.getLchild())) && 
                (compareEqual(root.getRchild(), anotherRoot.getRchild())));
    }
    
    /**
     * swapTree : 將該二叉樹的所有結點的左右孩子互換
     */
    public void swapTree()
    {
        StringBuilder sb = new StringBuilder("");
        swapTree(root);
        createGeneralList(root, sb);
        expression = sb.toString();
    }
    
    /**
     * swapTree : 將給定的二叉樹的所有結點的左右孩子互換
     * @param root 給定二叉樹的根結點
     */
    private void swapTree(TreeNode root)
    {
        if (root != null) {
            TreeNode tmp = root.getLchild();
            root.setLchild(root.getRchild());
            root.setRchild(tmp);
            swapTree(root.getLchild());
            swapTree(root.getRchild());
        }
    }
     
    /**
     * longestPath: 獲取該二叉樹中的一條最長路徑
     * @return 二叉樹中的一條最長路徑
     */
    public List<TreeNode> longestPath() 
    {
        List<TreeNode> longestPath = new ArrayList<TreeNode>();
        longestPath(root, longestPath);
        return longestPath;
    }
    
    /**
     * longestPath: 遞歸求解給定二叉樹的一條最長路徑
     * @param root  給定二叉樹的根結點
     * @param longestPath 存放二叉樹的最長路徑上的結點
     */
    private void longestPath(TreeNode root, List<TreeNode> longestPath)
    {
        if (root != null) {
            longestPath.add(root);
            if (root.getLchild() == null && root.getRchild() == null) { // 左右子樹均空
                 return ;
            }
            if (root.getLchild() != null && root.getRchild() == null) { // 左子樹非空，右子樹為空，則最長路徑的結點必在左子樹路徑上
                longestPath(root.getLchild(), longestPath);
            }
            if (root.getLchild() == null && root.getRchild() != null) { // 左子樹非空，右子樹為空，則最長路徑的結點必在右子樹路徑上
                longestPath(root.getRchild(), longestPath);
            }
            if (root.getLchild() != null && root.getRchild() != null) { // 左右子樹均非空;分別求解左右子樹的最長路徑，取最大者
                List<TreeNode> leftLongestPath = new ArrayList<TreeNode>();
                List<TreeNode> rightLongestPath = new ArrayList<TreeNode>();
                longestPath(root.getLchild(), leftLongestPath);
                longestPath(root.getRchild(), rightLongestPath);
                if (leftLongestPath.size() >= rightLongestPath.size()) {
                    longestPath.addAll(leftLongestPath);
                } else if (leftLongestPath.size() < rightLongestPath.size()) {
                    longestPath.addAll(rightLongestPath);
                }
                
            }
        }
    }
    
    
    
    /**
     * listToString: 返回二叉樹的結點列表的字符串表示
     * 
     * @param nodelist  樹的結點列表
     * @return  二叉樹的結點列表的字符串表示 
     * 
     */
    public String listToString(List<TreeNode> nodelist) {
        
        if (nodelist == null || nodelist.size() == 0) {
            return "[ 空樹 ]";
        }
        StringBuilder str = new StringBuilder("[");
        Iterator<TreeNode> iter = nodelist.iterator();
        while (iter.hasNext()) {
            TreeNode node = iter.next();
            str.append(node.getCh()+" ");
        }
        str.deleteCharAt(str.length()-1);
        str.append(']');
        return str.toString();
    }
    
    
    /**
     * createBinaryTree: 根據前序和中序遍歷列表生成二叉樹
     * 
     * @param preOrderList  前序列表字符串
     * @param inOrderList   中序列表字符串
     * @throws Exception 
     * 
     */
    public static BinaryTree createBinaryTree(String preOrderList, String inOrderList) throws Exception {
        BinaryTree bt = new BinaryTree(getGeneralList(preOrderList, inOrderList));
        bt.createBinaryTree();
        return bt;
    }
    
    /**
     * getGeneralist: 根據前序和中序遍歷列表生成二叉樹的廣義表表示【字符串形式】
     * 
     * @param preOrderList  前序列表字符串
     * @param inOrderList   中序列表字符串
     * @return generalList  廣義表表示
     * 
     */
    
    private static String getGeneralList(String preOrderList, String inOrderList) {
        
        String s = "";
        if (preOrderList.length() > 0 || inOrderList.length() > 0) {
            
            // 如果只含一個結點值，就直接返回
            if (preOrderList.length() == 1)
                return preOrderList;
            
            // 根據前序遍歷， 第一個是根結點的值
            char ch = preOrderList.charAt(0); 
            
            // 根據中序遍歷及根結點，將前序列表分為左右子樹列表。
            int index = inOrderList.indexOf(ch);
            String inOrderLeft = inOrderList.substring(0, index);                     // 左子樹的中序遍歷列表
            String inOrderRight = inOrderList.substring(index+1);                     // 右子樹的中序遍歷列表
            String preOrderLeft = preOrderList.substring(1, inOrderLeft.length()+1);  // 左子樹的前序遍歷列表
            String preOrderRight = preOrderList.substring(inOrderLeft.length()+1);    // 右子樹的前序遍歷列表
            s += ch;
            s += "(" + getGeneralList(preOrderLeft,inOrderLeft) + "," + getGeneralList(preOrderRight,inOrderRight) + ")"; 
        }
        return s;
    }
    
    /**
     * createBinaryTree: 根據中序和后序遍歷列表生成二叉樹
     * 
     * @param  inOrderList   中序列表
     * @param  postOrderList 后序列表
     * @param  flag          標記
     * 
     * @throws Exception 
     */
    public static BinaryTree createBinaryTree(String inOrderList, String postOrderList, boolean flag) throws Exception {
        BinaryTree bt = new BinaryTree(getGeneralList(inOrderList, postOrderList, flag));
        bt.createBinaryTree();
        return bt;
    }
    
    
    
    /**
     * getGeneralList: 根據中序和后序遍歷生成二叉樹的廣義表表示【字符串形式】
     * 
     * @param  inOrderList   中序列表
     * @param  postOrderList 后序列表
     * @param  flag          標記
     * @return generalList   廣義表表示
     * 
     */
    
    private static String getGeneralList(String inOrderList, String postOrderList, boolean flag) {
        
        String s = "";
        if (inOrderList.length() > 0 || postOrderList.length() >0) {
            
            // 如果只含一個結點值，就直接返回
            if (inOrderList.length() == 1) 
                return inOrderList;
            
            // 根據后序遍歷規則，最后一個是根結點的值
            char ch = postOrderList.charAt(postOrderList.length()-1); 
            
            // 根據中序遍歷及根結點，將前序列表分為左右子樹列表。
            int index = inOrderList.indexOf(ch);
            String inOrderLeft = inOrderList.substring(0, index);                     // 左子樹的中序遍歷列表
            String inOrderRight = inOrderList.substring(index+1);                     // 右子樹的中序遍歷列表
            String postOrderLeft = postOrderList.substring(0, inOrderLeft.length());  // 左子樹的前序遍歷列表
            String postOrderRight = postOrderList.substring(inOrderLeft.length(), 
                                    inOrderLeft.length()+inOrderRight.length());    // 右子樹的前序遍歷列表
            s += ch;
            s += "(" + getGeneralList(inOrderLeft,postOrderLeft,true) + "," + getGeneralList(inOrderRight,postOrderRight,true) + ")"; 
        }
        return s;
    }
    
    /**
     * trimSpace: 將廣義表表達式字符串中的空格符去掉
     */
    private static String trimSpace(String s)
    {
        StringBuilder sb = new StringBuilder("");
        for (int i=0; i < s.length(); i++) {
            char ch = s.charAt(i);
            if (!(new Character(ch).toString().matches("//s"))) {   
                sb.append(ch);
            }
        }
        return sb.toString();
    }
    
    /**
     * separatorIndex : 求解廣義表表達式中分割左右子樹的分隔符的位置
     *                  由於這里使用逗號分割左右子樹，則當且僅當其位置應當滿足：
     *                  在該分割符之前，左括號的數目恰好比右括號的數目多1. 
     * @return  若存在滿足條件的分隔符，則返回其位置；否則返回 -1
     */
    private static int separatorIndex(String expression)
    {
        int leftBracketCounter=0, rightBacketCounter=0;
        int index = 0;
        for (; index < expression.length(); index++) {
            char ch = expression.charAt(index);
            if (ch == '(') {
                leftBracketCounter++;
            }
            else if (ch == ')') {
                rightBacketCounter++;
            }
            else if (ch == ',') {
                if (leftBracketCounter == rightBacketCounter+1) break;
            }
        }
        if (index < expression.length()) {
            return index;
        }
        return -1;
    }
    
}