leetcode 24: Maximum Depth of Binary Tree

Given a binary tree, find its maximum depth.

The maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.

1. recursive way.

 

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int maxDepth(TreeNode *root) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        if( root == NULL) return 0;
        
        int x = maxDepth( root->left );
        int y = maxDepth( root->right);
        
        return 1 + ( x>y ? x : y);
    }
};

 

2. iterative way: much harder than recursive.

3 ways to do it. 1th preorder or inorder tranversal, which must modify treenode structure.

2nd postorder tranversal

3rd BFS. level tranversal

1th: <uncompleted>

 
 struct myTreeNode : public TreeNode {
      int level;
      myTreeNode(int x, int l) : level(l), TreeNode(x) {}
 };
 

 
class Solution {
public:
    int maxDepth(TreeNode *root) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
       
       myTreeNode myroot( root->val , 0);
       stack< myTreeNode * > mystack;
          
       int max = 0; 
       myTreeNode * node = &myroot;
          
       while( (!mystack.empty()) || node!=NULL ){
        
        if( node != NULL) {
            mystack.push( node);
            node = node->left;
            node->level++;
        } else {
            node = mystack.top();
            mystack.pop();
            node = node->right;
            node->level++;
        }
        
        max = (node->level > max) ? node->level : max; 
        return max;
       }   
    }
};