二叉树的前 中 后 层序遍历

• 二叉树的前序遍历

  /*
  先将根节点打印，而后将右子节点入栈，最后将左子节点入栈
  循环得到栈顶，将其看作跟节点，再分别处理右子节点和左子节点
  */
   vector<int> preorderTraversal(TreeNode* root) {
          vector<int> vec;
          if(root != NULL)
          {
              stack<TreeNode*> stack;
              stack.push(root);
              while(!stack.empty())
              {
                  root = stack.top();
                  vec.push_back(root->val);
                  stack.pop();
                  if(root->right != NULL)
                  {
                      stack.push(root->right);
                  }
                  if(root->left != NULL)
                  {
                      stack.push(root->left);
                  }
              }
          }
          return vec;
      }

   

• 二叉树的中序遍历

/*
从树的跟开始一直将左子节点入栈，当节点为NULL时，说明是最左的节点，打印
而后将其右子树作为一颗新树进行以上逻辑
判断退出条件是栈为NULL也就是所有的子树都处理完成
*/ 
vector<int> inorderTraversal(TreeNode* root) {
        vector<int> vec;
        if( root != NULL )
        {
            stack<TreeNode*> stack;
            while(!stack.empty() || root != NULL)
            {
                if(root != NULL)
                {
                    stack.push(root);
                    root = root->left;
                }
                else
                {
                    root = stack.top();
                    stack.pop();
                    vec.push_back(root->val);
                    root = root->right;
                }
            }
        }
        return vec;
    }

• 二叉树的后序遍历

/*
因为最后才打印根节点，如果使用一个栈来处理，无法判断当前访问的根节点是第一次访问还是第二次访问，
所以使用了两个栈，第一次访问根节点是将其入栈，最后一遍出栈的时候就能保证是第二次访问它
第一次将根节点入栈st2，而后将其左子节点入栈st1，右子节点入栈st1，再循环将st1内的栈顶当作根节点，
之所以是先入左再入右是因为从st1拿出根节点时要再压入st2，所以最后从st2出栈的时候顺序就变成了先左再右
*/
vector<int> postorderTraversal(TreeNode* root) {
        vector<int> vec;
        if(root != NULL)
        {
            stack<TreeNode*> stack1;
            stack<TreeNode*> stack2;
            stack1.push(root);
            while(!stack1.empty())
            {
                root = stack1.top();
                stack2.push(root);
                stack1.pop();
                if(root->left != NULL)
                {
                    stack1.push(root->left);
                }
                if(root->right != NULL)
                {
                    stack1.push(root->right);
                }
            }
            while(!stack2.empty())
            {
                vec.push_back(stack2.top()->val);
                stack2.pop();
            }
        }
        return vec;
    }

• 二叉树的递归写法

/*
前序
*/
void preorderTraversal(TreeNode* root)  
{  
    if(NULL != root)  
    {  
        cout<<root->val<<endl;  
        if(NULL != root->left)  
            preorderTraversal(root->left);  
        if(NULL != root->right)  
            preorderTraversal(root->right);      
    }  
}