【LeetCode 144、94、145、102、107】二叉树的前序遍历、中序遍历、后序遍历、层次遍历 [递归、非递归]

LeetCode 144 前序遍历

 递归遍历：

class Solution {
public:
    vector<int> vec;
    vector<int> preorderTraversal(TreeNode* root) {
        if(root == NULL)
        {
            return vec;
        }
        vec.push_back(root->val); //遇到root压入数值
        preorderTraversal(root->left);
        preorderTraversal(root->right);
        return vec;
    }
};

非递归遍历：

class Solution {
public:
    //结合栈来进行非递归遍历
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> vec;
        stack<TreeNode *> st;
        TreeNode *p = root;
        if(root == NULL) return vec;
        while(p != NULL || !st.empty())
        {
            while(p != NULL) //将root和root->left结点不断入栈
            {
                vec.push_back(p->val);
                st.push(p);
                p = p->left;
            }
            if(!st.empty()) //取栈顶元素来遍历root->right结点
            {
                p = st.top();
                st.pop();
                p = p->right;
            }
        }
        return vec;
    }
};

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> vec;
        stack<TreeNode *> st;
        if(root == NULL) return vec;
        st.push(root);  //先将根节点入栈
        while(!st.empty())
        {
            root = st.top();
            st.pop();
            if(root == NULL)
                continue;
            else
            {
                vec.push_back(root->val); //将val存入vec中
                st.push(root->right); //先压root右结点
                st.push(root->left);  //后压root左结点
            }                         //取栈顶元素存val时，出栈符合前序遍历规则
        }                             //根 左 右
        return vec;
    }
};

LeetCode 94 中序遍历

递归遍历：

class Solution {
public:
    vector<int> vec;
    vector<int> inorderTraversal(TreeNode* root) {
        if(root == NULL) return vec;
        inorderTraversal(root->left);
        vec.push_back(root->val);
        inorderTraversal(root->right);
        return vec;
    }
};

 非递归遍历：

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> vec;
        stack<TreeNode *> st;
        if(root == NULL) return vec;
        TreeNode *p = root;
        while(p != NULL || !st.empty())
        {
            while(p != NULL) //不断压root和root->left入栈
            {
                st.push(p);
                p = p->left;
            }
            if(!st.empty()) //取栈顶元素打印，之后压root->right入栈
            {
                p = st.top();
                vec.push_back(p->val); 
                st.pop();
                p = p->right;
            }
        }
        return vec;
    }
};

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> vec;
        stack<TreeNode *>st;
        if(root == NULL) return vec;
        while(root != NULL || !st.empty())
        {
            if(root != NULL) //不断压root和root->left入栈
            {
                st.push(root);
                root = root->left;
            } 
            else //取栈顶元素打印，压入root->right
            {
                root = st.top();
                st.pop();
                vec.push_back(root->val);
                root = root->right;
            }
        }
        return vec;
    }
};

LeetCode 145 后序遍历

递归遍历：

class Solution {
public:
    vector<int> vec;
    vector<int> postorderTraversal(TreeNode* root) {
        if(root == NULL) return vec;
        postorderTraversal(root->left);
        postorderTraversal(root->right);
        vec.push_back(root->val);
        return vec;
    }
};

非递归遍历：

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> vec;
        stack<TreeNode *> st;
        TreeNode* tag = NULL;
        if(root == NULL) return vec;
        while(root != NULL || !st.empty())
        {
            while(root != NULL) //不断压root和root->left入栈
            {
                st.push(root);
                root = root->left;
            }
            root = st.top(); //取出栈顶元素
            st.pop();
            if(root->right == NULL || root->right == tag)
            {
                vec.push_back(root->val);
                tag = root;
                root = NULL;
            }
            else //重新入栈  //将root->right压栈
            {
                st.push(root);
                root = root->right; 
            }
        }
        return vec;
    }
};

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> vec;
        stack<TreeNode *> st;
        if(root == NULL) return vec;
        st.push(root);
        while(!st.empty())
        {
            root = st.top();
            st.pop();
            if(root == NULL)
                continue;
            else
            {
                vec.push_back(root->val);
                st.push(root->left);
                st.push(root->right);
            }
        }
        //这样的遍历顺序为：中，右，左
        //最后reverse结果，则遍历结果变为：左，右，中。
        reverse(vec.begin(),vec.end());
        return vec;
    }
};

LeetCode 102 层次遍历 I

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> vec;
        queue<TreeNode *> que;
        if(root == NULL) return vec;
        que.push(root);
        while(!que.empty()) 
        {
            vector<int> v;
            int size = que.size(); //size是用来划分vec中每个组的元素个数
            while(size--)
            {
                TreeNode *p = que.front();
                v.push_back(p->val);
                que.pop();
                if(p->left != NULL)
                {
                    que.push(p->left);
                }
                if(p->right != NULL)
                {
                    que.push(p->right);
                }
            }
            vec.push_back(v);
        }
        return vec;
    }
};

LeetCode 107 层次遍历 II

 Tips：要把vector<vector<int>> vec中所有元素进行逆置；

//只需要在最后加上：

reverse(vec.begin(),vec.end());