CareerCup Chapter 4 Trees and Graphs

struct TreeNode{

        int val;

       TreeNode* left;

       TreeNode* right;

       TreeNode(int val):val(val),left(NULL),right(NULL){}

};

Not all binary trees are binary search trees.

4.1 Implement a function to check if a tree is balanced. For the purposes of this question, a balanced tree is defined to be a tree such that no two leaf nodes differ in distance from the root by more than one.

      Calculate all node's two leaf by recursion, in each recursion, judge its two leaf nodes differ is more than one or not. -1 represents no balanced, and >=0 represents balanced.

      int depthAndCheck(TreeNode *root){

            if(root==NULL)return 0;

            else{

                    int leftD = depthAndCheck(root->left);

                    int rightD = depthAndCheck(root->right);

                    if(leftD==-1||rightD==-1)return -1; //find one node no balanced,then the tree is no balanced.

                    if(leftD-rightD<=-2||leftD-rightD>=2)return -1; //judge its two children.

                    return max(leftD,rightD)+1;

             }

      }

4.2 Given a directed graph, design an algorithm to find out whether there is a route between two nodes.

       struct GraphNode{

             int val; //value

             vector<GraphNode*> next; //directed to nodes

       };

       Here, two nodes are A and B, we breadth first search the graph at the beginning of A to see whether there is a route from A to B, then breadth first search at the beginning of B to see whether there is a route from B to A. We declare a set<GraphNode*> to record whether the Node is visited.

      bool isHaveRoute(GraphNode *A,GraphNode *B){

           if(A==B)return true;

           set<GraphNode*>  visited;

           list<GraphNode*>  array[2];

           int cur=0,pre=1;

           array[0].push(A);visited.insert(A);

           while(!array[cur].empty()){

                cur=!cur;pre=!pre;

                array[cur].clear();

                while(!array[pre].empty()){

                         for(int i=0;i<array[pre].front()->next.size();i++){

                                  if(visited.count(array[pre].front()->next[i])==0){

                                         if(array[pre].front()->next[i]==B)return true;

                                          array[cur].push(array[pre].front()->next[i]);

                                          visited.insert(array[pre].front()->next[i]);

                                  }

                         }

                         array[pre].pop_front();

                 }

            }

            return false;

      }

      bool isHaveRouteAB(GraphNode *A,GraphNode *B){

            if(isHaveRoute(A,B)||isHaveRoute(B,A))return true;

            else return false;

      }

4.3 Given a sorted (increasing order) array, write an algorithm to create a binary tree with minimal height.

      I think the problem is to create a binary search tree with minimal height.

      The left child is smaller than the parent and the right child is bigger than the parent. So, we can find the middle of the array, and divide this array to two part, the left part is the left child part of the middle and the right part is the right child part.

      TreeNode* binaryST(int a[],int left,int right){

            if(left>right)return NULL;

            int mid=left+(right-left)/2;

            TreeNode *parent = new TreeNode(a[mid]);

            parent->left = binaryST(a,left,mid-1);

            parent->right = binaryST(a,mid+1,right);

            return parent;

      }

     TreeNode *resBST(int a[],int n){

            if(n<=0)return NULL;

            return binaryST(a,0,n-1);

     }

4.4 Given a binary search tree, design an algorithm which creates a linked list of all the nodes at each depth (i e , if you have a tree with depth D, you’ll have D linked lists).

      BFS,like 4.2.

4.5 Write an algorithm to find the ‘next’ node (i e , in-order successor) of a given node in a binary search tree where each node has a link to its parent.

     in-order, first, read the node's left, then the node, the the node's right.

     When the node has right child, the successor will be the left-most child of it's right child part.

     When the node is a left child,its parent is its successor.

     When the node is a right child, traverse its parents until we find a parent that the node is in the left child part of this parent. This parent is the node's successor.

     TreeNode* findNextNode(TreeNode* root){

          if(root!=NULL)

               if(root->parent==NULL||root->right!=NULL){

                     return findLeftMostChild(root->right);

               }else{

                    while(root->parent){

                           if(root->parent->left==root)break;

                           root=root->parent;

                    }

                    return root->parent;

               }

          }

          return NULL;

     }

     TreeNode* findLeftMostChild(TreeNode* root){

           if(root==NULL)return NULL;

           if(root->left)root=root->left;

           return root;

     }

4.6 Design an algorithm and write code to find the first common ancestor of two nodes in a binary tree.Avoid storing additional nodes in a data structure NOTE: This is not necessarily a binary search tree.

4.7 You have two very large binary trees: T1, with millions of nodes, and T2, with hundreds of nodes Create an algorithm to decide if T2 is a subtree of T1.

    we traverse T1 to find a node that equal to T2's root, then compare T1 and T2 to find whether T2 is a subtree of T1.

    bool isSubTree(TreeNode* T1,TreeNode* T2){

          if(T2==NULL)return true;

          if(T1==NULL)return false;

          if(T1->val==T2->val){

                if(isMatch(T1,T2))return true;

          }

          return isSubTree(T1->left,T2)||isSubTree(T1->right,T2);

    }

    bool isMatch(TreeNode* T1,TreeNode *T2){

          if(T1==NULL&&T2==NULL)return true;

          if(T1==NULL||T2==NULL)return false;

          if(T1->val!=T2->val)return false;

          return isMatch(T1->left,T2->left)&&isMatch(T1->right,T2->right);

    }

4.8 You are given a binary tree in which each node contains a value. Design an algorithm to print all paths which sum up to that value. Note that it can be any path in the tree - it does not have to start at the root.

     we declare a vector<int> to store one path from root to current node, and traverse this vector to find a path that sum up to the value.

     void traverseAllPaths(TreeNode* root,int num,vector<int> buffer,int level){

           if(root==NULL)return;

           buffer.push_back(root->val);

           int temp=num;

           for(int i=level;i>=0;i--){

                 temp-=buffer[i];

                 if(temp==0)printfPath(buffer,i,level);

           }

           vector<int> bufferL,bufferR;

           for(int i=0;i<buffer.size();i++){

                 bufferL.push_back(buffer[i]);

                 bufferR.push_back(buffer[i]);

           }

           traverseAllPaths(root->left,num,bufferL,level+1);

           traverseAllPaths(root->right,num,bufferR,level+1);

     }

     void printfPath(vector<int> buffer,int begin,int end){

           for(int i=begin;i<=end;i++)printf("%d ",buffer[i]);

           printf("\n");

     }