二叉树面试题

1、先提供二叉树类（已经封装好了先序，中序，后序排序），还有结点类

   //二叉树类
    class BinaryTree 
    {
        public Node root;
        public BinaryTree() 
        {
            root = null;
        }
        public BinaryTree(int i) 
        {
            this.root = new Node(i);
        }
        //插入结点
        public void InsertNode(int i) 
        {
            Node newNode = new Node(i);
            if (root == null)
            {
                root = newNode;
            }
            else 
            {
                Node CurrentNode = root;
                Node Parent;
                while (true) 
                {  
                        if (i < CurrentNode.data)
                        {
                             Parent = CurrentNode;
                            CurrentNode = CurrentNode.LeftNode;
                            if (CurrentNode == null) 
                            {
                                Parent.LeftNode = newNode;
                                break;
                            }
                        }
                        else
                        {
                             Parent = CurrentNode;
                            CurrentNode = CurrentNode.RightNode;
                            if (CurrentNode == null)
                            {
                                Parent.RightNode = newNode;
                                break;
                            }
                        }
                }
                
            }

        }
        //中序遍历
        //             (4)Node1        
        //              /      \
        //        (2)Node2      (6)Node3
        //        /      \         /    \
        //  (1)Node4   (3)Node5 (5)Node6 (7)Node7
        //排序顺序如标号
        public void InOrder(Node newNode) 
        {
            if (newNode != null) 
            {
                InOrder(newNode.LeftNode);
                //显示该结点数字
                Console.WriteLine(newNode.data);
                InOrder(newNode.RightNode);
            }
        }
        //先序遍历
        //             (1)Node1        
        //              /      \
        //        (2)Node2      (5)Node3
        //        /      \         /    \
        //  (3)Node4   (4)Node5 (6)Node6 (7)Node7
        public void PreOrder(Node newNode) 
        {
            if (newNode != null)
            {
                Console.WriteLine(newNode.data);
               
                PreOrder(newNode.LeftNode);
               
                PreOrder(newNode.RightNode);
            }
        }
        //后序遍历
        //             (7)Node1        
        //              /      \
        //        (3)Node2      (6)Node3
        //        /      \         /    \
        //  (1)Node4   (2)Node5 (4)Node6 (5)Node7
        public void PostOrder(Node newNode) 
        {
            if (newNode != null)
            {
                PostOrder(newNode.LeftNode);
                PostOrder(newNode.RightNode);
                Console.WriteLine(newNode.data);
            }
        }
    }
    //结点类
    class Node{
        public int data;
        public Node LeftNode;
        public Node RightNode;
        public Node(int data)
        {
          this.data=data;
          this.LeftNode = null;
          this.RightNode = null;
        }
        public Node(int data, Node LeftNode, Node RightNode) 
        {
            this.data = data;
            this.LeftNode = LeftNode;
            this.RightNode = RightNode;
        }
    }

2、

（1）输入一个n值，返回所有路径，该路径上的所有结点的和等于该n值。

  我用的是先序排序解决，可能写得不太好，各位大牛指点指点。

 

int s=0;
        public List
    
    
     
      list1 = new List
     
     
      
      ();
        public List
      
      
       
       
        
        > Alist = new List
        
         
         
           >(); bool hasDelete = false; public void PreOrder(Node newNode) { if (newNode != null) { list1.Add(newNode.data); Console.WriteLine(newNode.data); //结点值相加 s = s + newNode.data; //若和等于N，直接退出递归 if (s == n) { List 
          
            temp = new List 
           
             (); //将合适的路径记录到list里 foreach (var i in list1) { temp.Add(i); } Alist.Add(temp); //从List1里移除该结点，并且减去该数，以寻找下一条路径 list1.Remove(newNode.data); s = s - newNode.data; //作一标志位，以判断该数是以包含路径的形式删除，还是不满足条件删除 hasDelete = true; return; } else { hasDelete = false; } PreOrder(newNode.LeftNode); //遍历到最左端，仍发现s不等于n，则把左结点删除，并将和减去该值 if (s != n) { if (newNode.LeftNode != null&&hasDelete==false) { s = s - newNode.LeftNode.data; list1.Remove(newNode.LeftNode.data); } } //遍历到最右端，仍发现s不等于n，则把右结点删除，并将和减去该值 PreOrder(newNode.RightNode); if (s != n) { if (newNode.RightNode != null && hasDelete == false) { s = s - newNode.RightNode.data; list1.Remove(newNode.RightNode.data); } } } } }