线索树

 

 

namespace ThreadTree

{
    class Program
    {
        static void Main(string[] args)
        {
            ThreadBinaryTree tree = new ThreadBinaryTree();
            tree.InitialTree(@"a(b,c(d,e))");
            tree.InThread();
            tree.Print();
          //  tree.InOrder();
           // tree.Print();
            //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; }
            }

            int leftFlag;

            public int LeftFlag
            {
                get { return leftFlag; }
                set { leftFlag = value; }
            }


            int rightFlag;

            public int RightFlag
            {
                get { return rightFlag; }
                set { rightFlag = value; }
            }

          
        }

        public class ThreadBinaryTree
        {
            TreeNode root;
            ArrayList list = new ArrayList();
            public ThreadBinaryTree()
            {
                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 int TreeDepth()
            {
                return TreeDepth(root);
            }
            private int TreeDepth(TreeNode node)
            {
                if (node != null)
                {
                    if (node.LeftFlag == 1 && node.RightFlag == 1)
                    {
                        return 1;
                    }
                    else
                    {
                        int leftDepth = TreeDepth(node.Left);
                        int rightDepth = TreeDepth(node.Right);
                        if (leftDepth > rightDepth)
                        {
                            return leftDepth + 1;
                        }
                        else
                        {
                            return rightDepth + 1;
                        }
                    }
                }
                return 0;
            }

            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;
            }


            public void InThread()
            {
                InThread(root);
            }
            private TreeNode pre=null;
            private void InThread(TreeNode root)
            {
                if (root != null)
                {
                    if (root.LeftFlag==0)
                    {
                        InThread(root.Left);
                    }

                    if (pre != null && pre.RightFlag == 1)
                    {
                        pre.Right = root;
                    }
                    if (root.Left == null)
                    {
                        root.LeftFlag = 1;
                        root.Left = pre;
                    }
                    if (root.Right == null)
                    {
                        root.RightFlag = 1;
                    }

                    pre = root;

                    if (root.RightFlag == 0)
                    {
                        InThread(root.Right);
                    }
                }
            }


           
            private TreeNode InorderNext(TreeNode node)
            {
                if (node.RightFlag == 1)
                {
                    return node.Right;
                }
                else
                {
                    node = node.Right;
                    while (node.LeftFlag==0)
                    {
                        node = node.Left;
                    }
                    return node;
                }
            }


            public void Print()
            {
                TreeNode temp = root;
                if (temp != null)
                {
                    while (temp.LeftFlag == 0)
                    {
                        temp = temp.Left;
                    }
                    do
                    {
                        Console.Write(temp.Element);
                        temp = InorderNext(temp);
                    }
                    while (temp != null);
                }
                
            }
        }
    }
}