ch4.6: find the LCA of 2 nodes in a binary tree with 3 different methods

最新推荐文章于 2021-09-06 21:22:51 发布

纯黑老白

最新推荐文章于 2021-09-06 21:22:51 发布

阅读量1.2k

点赞数

分类专栏： ctci

本文链接：https://blog.csdn.net/asicprogrammer/article/details/18728085

版权

ctci 专栏收录该内容

34 篇文章 0 订阅

订阅专栏

In this problem, it is important to fully understand the definition of least common ancestor of 2 nodes:

it means: (from leetcode blog: 点击打开链接)

        _______3______
       /              \
    ___5__          ___1__
   /      \        /      \
   6      _2       0       8
         /  \
         7   4

If you are not so sure about the definition of lowest common ancestor (LCA), please refer to my previous post:Lowest Common Ancestor of a Binary Search Tree (BST) or the definition of LCA here. Using the tree above as an example, the LCA of nodes 5 and 1 is 3. Please note that LCA for nodes 5 and 4 is 5.

Here is the whole code with comments. Really good design by Hawstein.

// Ch4.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.

//http://leetcode.com/2011/07/lowest-common-ancestor-of-a-binary-tree-part-i.html
//the LCA of nodes 5 and 1 is 3. Please note that LCA for nodes 5 and 4 is 5.

#include 
   
   
    
    
#include 
    
    
     
     
#include 
     
     
      
      
#include 
      
      
using namespace std;

class BinNode{
public:
    int key;
    BinNode *parent, *lChild, *rChild;
    BinNode(){}
    BinNode(int t): key(t), parent(NULL), lChild(NULL), rChild(NULL){}
};

class BTree{
private:
    BinNode *m_root;
public:
    BTree(): m_root(NULL){}
    BTree(BinNode *t): m_root(t){}

    BinNode* getRoot() const{return m_root;}
    
    BinNode* balanceTree(BinNode* pnode, BinNode *parent, int *arr, int low, int high){
        if(low>high || arr == NULL)
            return NULL;
        int mid = (low+high)>>1;
        pnode = new BinNode(arr[mid]);
        pnode->parent = parent;
        pnode->lChild = balanceTree(pnode->lChild, pnode, arr, low, mid-1);
        pnode->rChild = balanceTree(pnode->rChild, pnode, arr, mid+1, high);

        return pnode;
    }

    void PrintPre(BinNode *pnode)
    {
        if(pnode == NULL)
            return;
 
        cout << pnode->key << " ";
        PrintPre(pnode->lChild);
        PrintPre(pnode->rChild);        
    }

    BinNode* minimal(BinNode* pnode){
        if(pnode==NULL) return NULL;
        while(pnode->lChild){
            pnode = pnode->lChild;
        }
        return pnode;
    }

    BinNode* successor(BinNode* qnode){
        if(qnode==NULL) return NULL;
        if(qnode->rChild) return minimal(qnode->rChild);
        BinNode *r = qnode->parent;
        while(r && r->rChild==qnode){
            qnode = r;
            r = r->parent;
        }
        return r;
    }
//  method 1: use a hash table to store the n1's parent to see if n2's parents are 
//  in the map. Learn to use map: key: pointer to the value, mapped value: the real data
    BinNode* firstAns(BinNode *n1, BinNode *n2){
        if(n1==NULL || n2==NULL) return NULL;
        map
       
       
         m; while(n1){ m[n1] = true; n1=n1->parent; } while(n2 && !m[n2]){ n2 = n2->parent; } return n2; } // method 2: recursively search for the commen father of (n1,n2). // father method is use to see if (n1,n2) share the same father by going down: // n1->child->child->...->child. Only modify n1; // in the LCA recursively move n1 up 1 step until find (n1->p->p->...->p,n2) // the same father. only modify n1; // By combining these 2 methods(one goes down, one goes up), n1 will search all the // nodes in the tree to find the LCA to n2; bool father(BinNode *n1, BinNode *n2){ if(n1==NULL || n2==NULL) return false; else if (n1==n2) return true; return (father(n1->lChild, n2) || father(n1->rChild, n2)); } BinNode* firstAns2(BinNode *n1, BinNode *n2){ if (n1==NULL || n2==NULL) return NULL; while(n1){ if(father(n1,n2)) return n1; n1=n1->parent; } return NULL; // don't forget it. } /* method 3: if the node doesn't contain parent pointer(just don't use ->parent), then we can start from root and recursively. Carefully read the solution,: how to update head, res. Use Node* &res, call by reference so will modify ans. */ void firstAns3(BinNode *head, BinNode *n1, BinNode *n2, BinNode* &res){ if (head==NULL || n1==NULL || n2==NULL) return; if(head && father(head, n1) && father(head, n2)){ res = head; firstAns3(head->lChild, n1, n2, res); firstAns3(head->rChild, n1, n2, res); } } // Auxilary methods: BinNode* searchND(BinNode* x_head, int x){ if(x_head==NULL) return NULL; else if(x==x_head->key) return x_head; else if(x<=x_head->key) searchND(x_head->lChild, x); else searchND(x_head->rChild, x); } vector 
         
         
           > BFSlist(BinNode *head){ vector 
           
           
             > res; int level = 0; list 
            
              li; li.push_back(head); res.push_back(li); while(!res[level].empty()){ list 
             
               l; list 
              
                ::iterator it; for(it=res[level].begin(); it!=res[level].end(); ++it){ BinNode *n = *it; if(n->lChild) l.push_back(n->lChild); if(n->rChild) l.push_back(n->rChild); } ++level; res.push_back(l); } return res; } void print(vector 
                
                
                  > res){ vector 
                  
                  
                    >::iterator vit; for(vit=res.begin(); vit!=res.end(); ++vit){ list 
                   
                     li = *vit; list 
                    
                      ::iterator lit; for(lit=li.begin(); lit!=li.end(); ++lit){ BinNode *n = *lit; cout< 
                     
                       key<<" "; } cout< 
                      
                        balanceTree(bt->getRoot(), NULL, arr, low, high); bt = new BTree(proot); bt->PrintPre(bt->getRoot()); cout << "pnode is: "<< proot->key< 
                       
                         successor(proot))->key< 
                        
                          > jerry = bt->BFSlist(proot); bt->print(jerry); BinNode *n1 = bt->searchND(proot, 13); BinNode *n2 = bt->searchND(proot, 22); BinNode *n1_n2_ans = bt->firstAns(n1, n2); cout< 
                         
                           key<<" "< 
                          
                            key< 
                           
                             key< 
                            
                              firstAns2(n1, n2); cout< 
                             
                               key< 
                              
                                firstAns3(proot, n1, n2, result); cout< 
                               
                                 key<

纯黑老白

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
ch4.6: find the LCA of 2 nodes in a binary tree with 3 different methods

In this problem, it is important to fully understand the definition of least common ancestor of 2 nodes:it means: (from leetcode blog: 点击打开链接) _______3______ / \
复制链接

扫一扫