Tree

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Tree
{
    class BinaryTree
    {
        public TreeNode RootNode;

        public void CreatTree()
        {
            TreeNode NodeBaby = new TreeNode("小华",1);
            TreeNode NodeMother = new TreeNode("妈妈",2);
            TreeNode NodeFather = new TreeNode("爸爸",3);
            TreeNode NodeGrandPalaw = new TreeNode("外公",4);
            TreeNode NodeGrandMaLaw = new TreeNode("外婆",5);
            TreeNode NodeGrandPa = new TreeNode("爷爷",6);
            TreeNode NodeGrandMa = new TreeNode("奶奶",7);

            NodeBaby.LeftNode = NodeMother;
            NodeBaby.RightNode = NodeFather;
            NodeMother.LeftNode = NodeGrandPalaw;
            NodeMother.RightNode = NodeGrandMaLaw;
            NodeFather.LeftNode = NodeGrandPa;
            NodeFather.RightNode = NodeGrandMa;

            RootNode = NodeBaby;
           
        }

        private void Visit(TreeNode node)
        {
            if (node != null)
            {
                node.Display();

            }
        }

        public void PreOrderTraverse(TreeNode node)
        {
            if (node != null)
            {
                Visit(node );
                PreOrderTraverse(node .LeftNode );
                PreOrderTraverse(node .RightNode );
            }
        }

        public void MidOrderTraverse(TreeNode node)
        {
            if (node != null)
            {
               
                MidOrderTraverse(node.LeftNode);
                Visit(node);
                MidOrderTraverse(node.RightNode);
            }
        }

        public void BehOrderTraverse(TreeNode node)
        {
            if (node != null)
            {

                BehOrderTraverse(node.LeftNode);             
                BehOrderTraverse(node.RightNode);
                Visit(node);
            }
        }

        public void InitBiTree()
        {
            RootNode = null;
        }

        public void  DestroyBiTree()
        {
            RootNode = null;
        }

        public void ClearBiTree()
        {
            RootNode = null;
        }

        public bool  BiTreeEmpty()
        {
            if (RootNode == null)
            {
                return false;
            }
            else
            {
                return true;
            }

        }

        public int BiTreeDepth()
        {
           
            TreeNode node = RootNode;
            int n=0;
            while  (node != null)
            {
               
                n=n+1;
                if (node.LeftNode != null)
                {
                    node = node.LeftNode;
                }
                else if (node.RightNode != null)
                {
                    node = node.RightNode;
                }
                else
                {
                    node = null;
                }
             
            }

            return n;
          
        }

        public TreeNode Root()
        {
            if (RootNode != null)
            {
                return RootNode;
            }
            else
            {
                return null ;
            }
        }

        public TreeNode   Value(TreeNode node)
        {
            if (node != null)
            {
                return node;

            }
            else
            {
                return null;
            }
        }

      
        public void Parent(TreeNode node)
        {
            if (node.RightNode == null && node.LeftNode == null)
            {
                return;
            }

            else
            {
                if (node.LeftNode != null)
                {
                    node.LeftNode .Display();
                }
                if (node.RightNode != null)
                {
                    node .RightNode.Display();
                }

            }
        }

        public TreeNode LeftNode(TreeNode node)
        {
            if (node.LeftNode != null)
            {
                return node.LeftNode;
            }
            else
            {
                return null;
            }

        }

        public TreeNode RightNode(TreeNode node)
        {
            if (node.RightNode != null)
            {
                return node.RightNode;
            }
            else
            {
                return null;
            }
        }

        public TreeNode LeftSibling(TreeNode node)
        {
            if (node.LeftNode != null)
            {
                return node.LeftNode;
            }
            else
            {
                return null;
            }
        }

        public TreeNode RightSibling(TreeNode node)
        {
            if (node.RightNode != null)
            {
                return node.RightNode;
            }
            else
            {
                return null ;
            }
        }

        public void InsertChild(TreeNode node1, int n, TreeNode node2)
        {
            if (n == 0)
            {
                node2.RightNode = node1.LeftNode;
                node1.LeftNode = node2;
            }
            else if (n == 1)
            {
                node2.RightNode = node1.RightNode;
                node1.RightNode = node2;
            }

            else
            {
                return;
            }
        }

        public void DeleteChild(TreeNode node, int n)
        {
            if (n == 0)
            {
                node.LeftNode = null;
            }
            else if (n == 1)
            {
                node.RightNode = null;
            }
            else
            {
                return;
            }
        }

        public void LevelOrderTraverse()
        {
            LinkedQueue que = new LinkedQueue();
            que.EnQueue(RootNode);
            while (!que.Empty)
            {
                TreeNode CurrentNode = que.DeQueue();
                if (CurrentNode != null)
                {
                    CurrentNode.Display ();

                    if (CurrentNode.LeftNode != null)
                    {
                       
                        que.EnQueue(CurrentNode.LeftNode);
                    }
                    if (CurrentNode.RightNode != null)
                    {
                       
                        que.EnQueue(CurrentNode.RightNode);
                    }
                }

               
               
            }

        }

       
    }
}

 

学习数据结构很锻炼能力，太有意识了