广义表表达的树

namespace Tree
{
    class Program
    {
        static void Main(string[] args)
        {
            BinaryTree tree = new BinaryTree();
            tree.InitialTree(@"a(b,c(d,e))");


           

            //tree.PrintTree();
            tree.InOrder();
            tree.PostOrder();
            tree.PreOrder();
            //tree.LevelOrder();
            Console.WriteLine(tree.TreeDepth());
            
        }
    }

    public class TreeNode
    {
        public TreeNode(object element)
        {
            this.element = element;
        }
        TreeNode left;

        public TreeNode Left
        {
            get { return left; }
            set { left = value; }
        }
        TreeNode right;

        public TreeNode Right
        {
            get { return right; }
            set { right = value; }
        }
        object element;

        public object Element
        {
            get { return element; }
            set { element = value; }
        }
    }

    public class BinaryTree
    {
        TreeNode root;
        ArrayList list = new ArrayList();
        public BinaryTree()
        {
            root = null;
        }

        private void ParseExpression(string expression)
        {
            char temp;
            string node = string.Empty;
        
            for (int i = 0; i < expression.Length; i++)
            {
                temp = expression[i];
                if (IsNodeCharacter(temp))
                {

                    node += temp;
                    while (++i < expression.Length && IsNodeCharacter(expression[i]))
                    {
                        node += expression[i];
                    }
                    list.Add(node);
                    node = "";
                    if (i >= expression.Length)
                    {
                        break;
                    }
                    else
                    {
                        i--;
                    }
                }
                else
                {
                    list.Add(temp);
                }
            }

            //for (int i = 0; i < list.Count; i++)
            //{
            //    Console.WriteLine(list[i].ToString() + " ");
            //}
        }

        private bool IsNodeCharacter(char temp)
        {
            if (temp == '(' || temp == ')' || temp == ',')
            {
                return false;
            }
            else
            {
                return true;
            }
        }

        public void InitialTree(string expression)
        {
            ParseExpression(expression);

            string temp;
            int k = 0;
            Stack stack = new Stack();
            TreeNode node = null;
            for (int i = 0; i < list.Count; i++)
            {
                temp = list[i].ToString();
                switch (temp)
                {
                    case "(":
                        k = 1;
                        stack.Push(node);
                        break;
                    case ")":
                        stack.Pop();
                        break;
                    case ",":
                        k = 2; break;
                    default:
                        node = new TreeNode(temp);
                        if (root == null)
                        {
                            root = node;
                        }
                        else
                        {
                            if (k == 1)
                            {
                                (stack.Peek() as TreeNode).Left = node;
                            }
                            else if (k == 2)
                            {
                                (stack.Peek() as TreeNode).Right = node;
                            }
                        }
                        break;

                }
            }
        }


        public void InOrder()
        {
            InOrder(root);
            Console.WriteLine();
        }
        private void InOrder(TreeNode node)
        {
            if (node != null)
            {
                InOrder(node.Left);
                Console.Write(node.Element + "->");
                InOrder(node.Right);
            }
        }

        public void PreOrder()
        {
            PreOrder(root);
            Console.WriteLine();
        }
        public void PreOrder(TreeNode node)
        {
            if (node != null)
            {

                Console.Write(node.Element + "->");
                PreOrder(node.Left);
                PreOrder(node.Right);
            }
        }

        public void PostOrder()
        {
            PostOrder(root);
            Console.WriteLine();
        }
        public void PostOrder(TreeNode node)
        {
            if (node != null)
            {

              
                PostOrder(node.Left);
                PostOrder(node.Right);
                Console.Write(node.Element + "->");
            }

        }


        public void LevelOrder()
        {
            TreeNode current = root;
            TreeNode temp;
            Queue queue = new Queue();
            queue.Enqueue(current);
            while (queue.Count != 0)
            {
                temp = queue.Dequeue() as TreeNode;
                Console.Write(temp.Element + "->");
                if (temp.Left != null)
                {
                    queue.Enqueue(temp.Left);
                }
                if (temp.Right != null)
                {
                    queue.Enqueue(temp.Right);
                }
            }
            Console.WriteLine();
        }

        public int TreeDepth()
        {
            return TreeDepth(root);
        }
        private int TreeDepth(TreeNode node)
        {
            if (node == null)
            {
                return 0;
            }
            else
            {
                int leftDepth = TreeDepth(node.Left);
                int rightDepth = TreeDepth(node.Right);
                if (leftDepth > rightDepth)
                {
                    return leftDepth + 1;
                }
                else
                {
                    return rightDepth + 1;
                }
            }
        }

        public void PrintTree()
        {
            PrintTree(root);
            Console.WriteLine();
        }
        private void PrintTree(TreeNode node)
        {
            if (node != null)
            {
                Console.Write(node.Element);
                if (node.Left != null || node.Right != null)
                {
                        Console.Write("(");
                        PrintTree(node.Left);
                        if (node.Right != null)
                        {
                            Console.Write(",");
                        }
                        PrintTree(node.Right);
                        Console.Write(")");
                }
            }
        }

        public void DeleteTree()
        {
            root = null;
        }
    }
}

转载于:https://www.cnblogs.com/healer_zll/archive/2009/03/14/1411233.html