代码随想录算法训练营第十四天 | 144. 二叉树的前序遍历 、145. 二叉树的后序遍历、94. 二叉树的中序遍历

代码随想录算法训练营第十四天 | 144. 二叉树的前序遍历 、145. 二叉树的后序遍历、94. 二叉树的中序遍历

---

写在前面：

• ​ 递归
  • 确定 递归过程中的 参数 和返回值
  • 确定终止条件
  • 确定单层遍历逻辑

144. 二叉树的前序遍历

题目链接:144. 二叉树的前序遍历 - 力扣（LeetCode）

使用递归：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void returnNode(TreeNode *head,std::vector &arr){// 前序遍历
        if(head == nullptr) return;
        arr.push_back(head->val);
        returnNode(head->left,arr);
        returnNode(head->right,arr);
    }
    std::vector preorderTraversal(TreeNode* root) {
        std::vector arr;
        returnNode(root,arr);
        for(auto x:arr){
            std::cout<

145. 二叉树的后序遍历

题目链接: 145. 二叉树的后序遍历 - 力扣（LeetCode）
使用迭代：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector postorderTraversal(TreeNode* root) {
        std::vector arr;

        if(!root)  return arr;
        std::stack stack;
        stack.push(root);
        while(!stack.empty()){// 采用"前序"的思路 之后反转
            TreeNode *node = stack.top();
            stack.pop();
            arr.push_back(node->val);
            if(node->left) stack.push(node->left);
            if(node->right) stack.push(node->right);
        }
        std::reverse(arr.begin(),arr.end());
        return arr;
    }
};

94. 二叉树的中序遍历

题目链接:94. 二叉树的中序遍历 - 力扣（LeetCode）

迭代：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector inorderTraversal(TreeNode* root) {
        std::vector arr;
        std::stack stack;
        TreeNode *node = root;
        while(!stack.empty() || node ){
            if(node ){
                stack.push(node);
                node=node->left;
            }else{
                node = stack.top();
                arr.push_back(node->val);
                stack.pop();
                node = node->right;
            }
        }
        return arr;
    }
};

今日总结：

之前没有怎么接触过迭代和递归，感觉使用递归的方法来遍历二叉树是比较简单的。
使用迭代真是让人想破了脑袋。

void Digui(TreeNode *head,std::vector &ans){
	if(head == nullptr) return;
	arr.push_back(head->val);
	Digui(head->left,arr);
	Digui(head->right,arr);
}

前序和后序采用一个思路迭代：

​ 前序按照 根节点，左节点，右节点遍历

​ 后序按照 左节点，右节点，根节点遍历

std::vector QianXv(TreeNode* head){
	std::vector arr;
    std::stack atsck;
    stack.push(head);
    while(!stack.empty()){
        TreeNode *node = stack.top();
        stack.pop;
        arr,push_back(node->val);
        if(node->right) stack.push(node->right);
        if(node->left) stack.push(node->left);
    }
    return arr;
}

std::vector HouXv(TreeNode* head){
	std::vector arr;
    std::stack atsck;
    stack.push(head);
    while(!stack.empty()){
        TreeNode *node = stack.top();
        stack.pop;
        arr,push_back(node->val);
        if(node->left) stack.push(node->left);
        if(node->right) stack.push(node->right);
    }
    std::reverse(arr.begin(),arr.end());
    return arr;
}

统一方式：（这部分没看，迭代已经使我头晕了，放一下代码）

#include
#include
#include
struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode() : val(0), left(nullptr), right(nullptr) {}
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
    TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
};
// 中序
std::vector inorderTraversal_zhongxv(TreeNode* root) {
    std::vector result;
    std::stack st;
    if (root != NULL) st.push(root);
    while (!st.empty()) {
        TreeNode* node = st.top();
        if (node != NULL) {
            st.pop(); // 将该节点弹出，避免重复操作，下面再将右中左节点添加到栈中
            if (node->right) st.push(node->right);  // 添加右节点（空节点不入栈）
            st.push(node);                          // 添加中节点
            st.push(NULL); // 中节点访问过，但是还没有处理，加入空节点做为标记。
            if (node->left) st.push(node->left);    // 添加左节点（空节点不入栈）
        } else { // 只有遇到空节点的时候，才将下一个节点放进结果集
            st.pop();           // 将空节点弹出
            node = st.top();    // 重新取出栈中元素
            st.pop();
            result.push_back(node->val); // 加入到结果集
        }
    }
    return result;
}
// 前序
std::vector preorderTraversal_qianxv(TreeNode* root) {
    std::vector result;
    std::stack st;
    if (root != NULL) st.push(root);
    while (!st.empty()) {
        TreeNode* node = st.top();
        if (node != NULL) {
            st.pop();
            if (node->right) st.push(node->right);  // 右
            if (node->left) st.push(node->left);    // 左
            st.push(node);                          // 中
            st.push(NULL);
        } else {
            st.pop();
            node = st.top();
            st.pop();
            result.push_back(node->val);
        }
    }
    return result;
}
// 后序
std::vector postorderTraversal_houxv(TreeNode* root) {
    std::vector result;
    std::stack st;
    if (root != NULL) st.push(root);
    while (!st.empty()) {
        TreeNode* node = st.top();
        if (node != NULL) {
            st.pop();
            st.push(node);                          // 中
            st.push(NULL);
            if (node->right) st.push(node->right);  // 右
            if (node->left) st.push(node->left);    // 左
        } else {
            st.pop();
            node = st.top();
            st.pop();
            result.push_back(node->val);
        }
    }
    return result;
}
int main(){
    return 0;
}