二叉树的先序、中序、后序、层序遍历

Binary Tree Preorder Traversal 二叉树的先序遍历

//先序遍历 先根 后左 其次是右
/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    //辅助结点p初始化为根结点，while循环的条件是栈不为空或者辅助结点p不为空，
    //在循环中首先判断如果辅助结点p存在，那么先将p加入栈中，然后将p的结点值加入结果vec中，
    //此时p指向其左子结点。否则如果p不存在的话，表明没有左子结点，我们取出栈顶结点，将p指向栈顶结点的右子结点
    vector<int> preorderTraversal(TreeNode *root) {
        if(root==NULL)
            return {};
        vector<int> vec;
        //对于非递归我们可以借助栈来实现
        stack<TreeNode*> sta;
        //创建一个辅助结点 让其指向根结点
        TreeNode* p=root;
        while(!sta.empty()||p!=NULL){
            if(p!=NULL)
            {
            //当p不为空时 将p入栈此时p为root
            sta.push(p);
            vec.push_back(p->val);
            //让p指向它的左孩子  然后循环直到左孩子为空时
            p=p->left;
            }
            if(p==NULL)
            {
            //如果左孩子为空 我们取出栈顶元素 此时的栈顶为左叶子结点的根节点
              TreeNode* t=sta.top();
              sta.pop();
            //让p指向右孩子 
              p=t->right;
            }
        }
        return vec;
    }
};

Binary Tree Inorder Traversal 二叉树的中序遍历

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    //二叉树的中序遍历  先左 后根 其次右
    //和上面先序遍历一样我们借助栈和定义一个辅助结点 p来完成
    //从根节点开始，先将根节点压入栈，然后再将其所有左子结点压入栈，
    //然后取出栈顶节点，保存节点值push_back(当前结点的val)，再将当前指针移到其右子节点上，
    //若存在右子节点，则在下次循环时又可将其左子结点压入栈中
    vector<int> inorderTraversal(TreeNode *root) {
        if(root==NULL)
             return {};
        vector<int> vec;
        stack<TreeNode*> sta;
        TreeNode* p=root;
        while(!sta.empty()||p!=NULL)
        {
            if(p!=NULL){
                sta.push(p);
                //将所以左孩子入栈
                p=p->left;
            }else{
                TreeNode* t=sta.top();
                sta.pop();
                vec.push_back(t->val);
                p=t->right;
            }
        }
        return vec;
    }
};

Binary Tree Postorder Traversal 二叉树的后序遍历

//先序遍历是 根 左 右  我们可以改变先序遍历让其便利顺序为 根 右 左 
//就是让其每次先判断右结点 后判断左结点  
//然后往vector 中插入时让其每次往begin的前一个结点插  那么这样出来的顺序
//就成为 左 右 根
class solution{
public:
     vector<int> Postorder Traversal (TreeNode* root)
     {
              if(root==NULL)
                 return {};
               vector<int> vec;
               stack<TreeNode*> sta;
               TreeNode* p=root;
                while(!sta.empty() || p!==NULL){
                if(p!==NULL)
                 {
                 sta.push(p);  
                 //每次让其插入到begin 的前一个
                 vec.insert(vec.begin(),p->val);
                 //根结点入栈后先判断其右孩子
                 p=p->right;
                 }
             }else{
              TreeNode* t=sta.top();
               sta.pop();
               p=t->left;
                   }
          }
   return vec;
};

Binary Tree Level Order Traversal 二叉树层序遍历

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    //层序遍历这里我们借助队列 现将根结点入队列 
    //这时候找根节点的左右两个子节点，这时候去掉根节点，
    //此时queue里的元素就是下一层的所有节点，用一个for循环遍历它们，然后存到一个一维向数组中
    vector<vector<int> > levelOrder(TreeNode *root) {
        vector<vector<int>> Vec;
        queue<TreeNode*> qu;
        if(root!=NULL)
          qu.push(root);
        while(!qu.empty()){
            vector<int> vec;
            int size=qu.size();
            for(int i=0;i<size;++i){
                TreeNode* front=qu.front();
                qu.pop();
                vec.push_back(front->val);
                if(front->left)
                {qu.push(front->left);
                }
                if(front->right)
                {qu.push(front->right);
                }
            }
            Vec.push_back(vec);
        }
        return Vec;
    }
};