c# 二叉树的创建和各种问题

最近学习了下二叉树，结合网上的各位大神提供的方法，写了个c#的二叉树创建和其他一些方法。

感谢http://blog.csdn.net/luckyxiaoqiang/article/details/7518888#comments WalkingInTheWind博主的博客，学到很多。

二叉树的结构：

 	public class Node
        {
            public object Value { get; set; }
            public Node Node_left { get; set; }
            public Node Node_right { get; set; }

            public Node(object value, Node lchild, Node rchild)
            {
                Value = value;
                Node_left = lchild;
                Node_right = rchild;
            }
            public Node(object val)
            {
                Value = val;
                Node_left = null;
                Node_right = null;
            }
            public Node()
            {
                Value = null;
                Node_left = null;
                Node_right = null;
            }
        }

创建二叉树的方法 可以拓展，比如应用的时候传入字符串来创建二叉树什么的

	public void BinaryTree(Node node)
        {
            //二叉树value附值，具体怎么附值根据实际情况自己更改 
            //附值代码地方 ***--**
            if (node.Value == null || String.IsNullOrEmpty(node.Value.ToString()))
                return;
            node.Node_left = new Node();
            BinaryTree(node.Node_left);
            if (node.Node_left.Value == null)
                node.Node_left = null;
            node.Node_right = new Node();
            BinaryTree(node.Node_right);
            if (node.Node_right.Value == null)
                node.Node_right = null;
        }

前序遍历

        //前序遍历
        public void FirstTraversal(Node node)
        {
            if (node.Value == null)
                return;
            Console.WriteLine(node.Value);
            FirstTraversal(node.Node_left);
            FirstTraversal(node.Node_right);
        }

中序遍历

        //中序遍历
        public void MiddleTraversal(Node node)
        {
            if (node.Value == null)
                return;
            MiddleTraversal(node.Node_left);
            Console.WriteLine(node.Value);
            MiddleTraversal(node.Node_right);
        }

后序遍历

        //后序遍历
        public void LastTraversal(Node node)
        {
            if (node.Value == null)
                return;
            LastTraversal(node.Node_left);
            LastTraversal(node.Node_right);
            Console.WriteLine(node.Value);
        }

层级遍历

        //层级遍历
        public void LevelTraversal(Node node)
        {
            Queue<object> queue = new Queue<object>();
            queue.Enqueue(node);
            while (queue.Count > 0)
            {
                Node n = queue.Dequeue() as Node;
                Console.WriteLine(node.Value);
                if (node.Node_left != null)
                {
                    queue.Enqueue(node.Node_left);
                }
                if (node.Node_right != null)
                {
                    queue.Enqueue(node.Node_right);
                }
            }
        }

其他面试会遇到的问题

1.求二叉树节点个数

2.求二叉树深度

3.求二叉树第K层节点个数

4.叶子节点个数

5.判断两个二叉树结构是否相同

6.判断二叉树是不是平衡二叉树

7.二叉树的镜像

8.如何判断是不是完全二叉树

        //求二叉树中的节点个数
        public int GetNodeNum(Node node)
        {
            if (node.Value == null)
                return 0;
            return GetNodeNum(node.Node_left) + GetNodeNum(node.Node_right) + 1;
        }

        //求二叉树的深度
        public int GetNodeDepth(Node node)
        {
            if (node.Value == null)
                return 0;
            int leftDepth = GetNodeNum(node.Node_left);
            int rightDepth = GetNodeNum(node.Node_right);
            int depth = leftDepth > rightDepth ? (leftDepth + 1) : (rightDepth + 1);//include current node, so +1
            return depth;
        }

        //求二叉树第K层的节点个数
        public int GetNodeNumOnLevel(Node node, int k)
        {
            if (node == null || k < 1)
                return 0;
            if (k == 1)
                return 1;
            int leftNum = GetNodeNumOnLevel(node.Node_left, k - 1);
            int rightNum = GetNodeNumOnLevel(node.Node_right, k - 1);
            return (leftNum + rightNum);
        }

        //求二叉树中叶子节点的个数
        public int GetLeafNodeNum(Node node)
        {
            if (node == null)
                return 0;
            if (node.Node_left == null && node.Node_right == null)
                return 1;
            int numleft = GetLeafNodeNum(node.Node_left);
            int numright = GetLeafNodeNum(node.Node_right);
            return (numleft + numright);
        }

        //判断两棵二叉树是否结构相同
        public bool AreSameStruct(Node n1, Node n2)
        {
            if (n1 == null && n2 == null)
                return true;
            else if (n1 == null || n2 == null)
                return false;
            bool leftsame = AreSameStruct(n1.Node_left, n2.Node_left);
            bool rightsame = AreSameStruct(n1.Node_right, n2.Node_right);
            return (leftsame && rightsame);
        }

        //判断二叉树是不是平衡二叉树
        public bool BalanceTree(Node node, out int height)
        {
            if (node == null)
            {
                height = 0;
                return true;
            }
            int heightleft = 0;
            bool resultleft = BalanceTree(node.Node_left, out heightleft);
            int heightright = 0;
            bool resultright = BalanceTree(node.Node_right, out heightright);
            if (resultleft && resultright && Math.Abs(heightleft - heightright) < 1)
            {
                height = Math.Max(heightleft, heightright) + 1;
                return true;
            }
            else
            {
                height = Math.Max(heightleft, heightright) + 1; ;
                return false;
            }
        }

        //求二叉树的镜像
        public Node TreeMirror(Node node)
        {
            if (node == null)
                return null;
            Node leftnode = TreeMirror(node.Node_left);
            Node rightnode = TreeMirror(node.Node_right);
            node.Node_left = rightnode;
            node.Node_right = leftnode;
            return node;
        }

        //判断二叉树是不是完全二叉树
        public bool IsCompleteBinaryTree(Node node)
        {
            if (node == null)
                return false;
            Queue<object> queue = new Queue<object>();
            queue.Enqueue(node);
            bool mustHaveNoChild = false;
            bool result = true;
            while (queue.Count>0)
            {
                Node n = queue.Dequeue() as Node;
                if (mustHaveNoChild)
                {
                    if (node.Node_left != null || node.Node_right != null)
                    {
                        result = false;
                        break;
                    }
                }
                else
                {
                    if (node.Node_left != null && node.Node_right != null)
                    {
                        queue.Enqueue(node.Node_left);
                        queue.Enqueue(node.Node_right);
                    }
                    else if (node.Node_left != null && node.Node_right == null)
                    {
                        mustHaveNoChild = true;
                        queue.Enqueue(node.Node_left);
                    }
                    else if (node.Node_left == null && node.Node_right != null)
                    {
                        result = false;
                        break;
                    }
                    else
                    {
                        mustHaveNoChild = true;
                    }
                }
            }
            return result;
        }