Binary Tree_ basic algorithm

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
// 三种遍历的递归实现

void preOrder(TreeNode * root)
{
   if(NULL == root ) return ;
   visit(root->val);
   preOrder(root->left);
   preOrder(root->right);
}

void inOrder(TreeNode * root)
{
  if(NULL == root) return ;
  inOrder(root->left);
  visit(root->val);
  inOrder(root->right);
}

void postOrder(TreeNode * root)
{
  if(NULL == root) return ;
  postOrder(root->left);
  postOrder(root->right);
  visit(root->val);
}

 

// 三种遍历的非递归实现

void preOrder(TreeNode * root)
{
   if(NULL == root ) return ;
   std::stack<TreeNode *> myStack;
   TreeNode *p = root;

   while(p || !myStack.empty())
   {
        while(p){
            visit(p->val);
            if(p->right)
                 myStack.push(p->right);
            p = p->left;
        }
      
        if(!myStack.empty())
        {
          p = myStack.top();
          myStack.pop();
        }
   }
}

void inOrder(TreeNode * root)
{
  if(NULL == root) return ;
  std::stack<TreeNode *> myStack;
  TreeNode *p = root;
  
  while(p || !myStack.empty())
  {
    while(p)
    {
       myStack.push(p);
       p = p->left;
    }
    if(!myStack.empty())
    {
        p = myStack.top();
        myStack.pop();
        visit(p->val);
        p = p->right;
    }
  }
}

void postOrder(TreeNode * root)
{
  if(NULL == root) return ;
  std::stack<TreeNode *> myStack;
  TreeNode *p = root,*leftNode, *rightNode, *q;
  
  while(P || !myStack())
  {
        while(p){
             myStack.push(p); 
             leftNode = p->left;
             rightNode = p-> right;
             p = (leftNode) ? leftNode: rightNode ;
        }
        p = myStack.top();
        myStack.pop();
        visit(p->val);
        if( !myStack.empty() )
          {
             q = myStack.top();
             if(p == q->left) 
                 p = q->right;
          }else
                p = NULL:
  }
  
}

// 广度优先周游
void levelOrder(TreeNode * root)
{
   if(NULL == root ) return ;
   std::queue<TreeNode *> myQueue;
   TreeNode *p ;
   myQueue.push(root) ;

   while( !myQueue.empty())
   {
        p = myQueue.front();
        myQueue.pop();
        visit(p->val);
        if(p->left)
              myQueue.push(p->left);
        if(p->right)
              myQueue.push(p->right);
   }
}