算法训练营第十四天 | LeetCode 144 二叉树的前序遍历、LeetCode 94 中序遍历、LeetCode 145 后序遍历（二叉树递归遍历、迭代遍历、统一迭代遍历（略））

二叉树本质上也就是结构体节点之间的连接，算是链表结构的一种扩展，不过next指针变成了left和right两个指针，也因此，二叉树结构有了更多种的可能，包括完全二叉树、满二叉树等等。相关的树的高度和层数与结点数之间的性质可以参见课本。这里着重探讨下二叉树的三种遍历方式：前序遍历、中序遍历和后序遍历。

中序遍历意思是从一个节点的左子节点开始，到它本身，再遍历它的右子节点结束，但这个过程一般要从遍历到最左下角的元素才开始记录，之后一路往上，记录到最右边结束。

前序遍历意思是先从该节点本身开始遍历，之后遍历它的左子节点，再到它的右子节点结束。这个过程一般是从根节点开始，一直到最左下角，之后到最右下角结束。

后序遍历意思是先从该节点左子节点开始，到它的右子节点，最后再到他本身结束。这个过程一般是从最左下角开始，到最右下角，再到根节点结束。

由三种遍历的定义可以很容易写出他们的递归遍历代码，直接照着意思来实现就可以了。

struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int value):val(value),left(nullptr),right(nullptr) {};
    TreeNode(int value, TreeNode* leftNode, TreeNode*                         rightNode):val(value),left(leftNode),right(rightNode) {};
}

vector<int> res;
inline void visiting(TreeNode* temp) {
    res.push_back(temp->val);
}

void inOrderVisiting(TreeNode* root) {
    if (!root) return;
    if (root->left) inOrderVisiting(root->left);
    visiting(root);
    if (root->right) inOrderVisiting(root->right);
}

void preOrderVisiting(TreeNode* root) {
    if (!root) return;
    visiting(root);
    if (root->left) preOrderVisiting(root->left);
    if (root->right) preOrderVisiting(root->right);
}

void afterOrderVisiting(TreeNode* root) {
    if (!root) return;
    if (root->left) afterOrderVisiting(root->left);
    if (root->right) afterOrderVisiting(root->right);
    visiting(root);
}

迭代法其实也不难，就是依据计算机系统中栈对函数的存储机制来理解记忆就可以了。

代码如下：

void inOrderVisiting(TreeNode* root) {
    if (!root) return;
    while (root || !mystack.empty()) {
        while (root) {
            mystack.push(root);
            root = root->left；
        }
        root = mystack.top();
        res.push_back(root->val);
        mystack.pop();
        root = root->right
    }
}

中序遍历。主要思想是如果节点为空则返回，不为空则一直向左下，同时用栈来记录该节点。此时若节点已经到达了最左下，取出最顶层节点（由于此时root指向的已经是null了所以需要赋值），将其值fangru记录结果的res向量中，将该节点pop，并把root赋值为它自身的右节点，这里不判断右节点是否存在是因为不存在下一次循环也可以直接赋为栈顶元素。另外如果是直接赋为栈顶元素会循环导入左子节点造成超时。这里主要需要去考虑的是一个顺序的问题，其他就都还好。

void preOrderVisiting(TreeNode* root) {
    if (!root) return;
    while (root || !mystack.empty()) {
        while (root) {
            res.push_back(root->val);
            mystack.push(root);
            root = root->left;
        }
        root = mystack.top();
        mystack.pop();
        root = root->right;
    }   
}

前序遍历。前序遍历是中左右的这样一种结构，所以每次向左时先把该节点入栈，并将对应值记录入res返回向量中。当到达最坐下角时，直接将root赋为栈顶元素，将其出栈，并将root赋为root->right让其进入下一重循环。这样做的原因在于是中左右结构，我们首先在遍历的过程就可以将root看成一个迭代器，这个迭代器从上到左下再到它的右边，再依托栈的先入后出的结构特性逐层往上遍历，即可全部遍历完毕。

void myreverse(vector<int>& nums) {
    int left = 0, right = nums.size() - 1;
    while (left < right) {
        int temp = nums[right];
        nums[right] = nums[left];
        nums[left] = temp;
        left++; right--;
    }
}

void afterOrderVisiting(TreeNode* root) {
    if (!root) return;
    while (root || !mystack.empty()) {
        while (root) {
            mystack.push(root);
            res.push_back(root->val);
            root = root->right;
        }
        root = mystack.top();
        mystack.pop();
        root = root->left;
    }
    myreverse(res);
}

后序遍历。后序遍历用前面用的迭代器法实现起来有坑。一般是有三种方法，我们这里介绍最简单的一种，也是最取巧的一种。首先我们将后序遍历反过来，由左右中反转成中右左，这就转化成了一个前序遍历，只不过是先遍历右边再遍历左边了。这样一来就很简单了，简单改下之前前序遍历的实现函数再写个反转函数就可以了。代码如上。

统一迭代法看起来蛮复杂的，感觉还是我找到的这几种迭代法实现起来比较简单，面试时候也比较容易写出来。等以后有需要的时候再去写吧。

LeetCode 144 二叉树的前序遍历

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> mystack;
        if (!root) return res;
        while (root || !mystack.empty()) {
            while (root) {
                res.push_back(root->val);
                mystack.push(root);
                root = root->left;
            }
            root = mystack.top();
            mystack.pop();
            root = root->right;
        }
        return res;
    }
};

LeetCode 94 二叉树的中序遍历

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> mystack;
        if (!root) return res;
        while (root || !mystack.empty()) {
            while (root) {
                mystack.push(root);
                root = root->left;
            }
            root = mystack.top();
            res.push_back(root->val);
            mystack.pop();
            root = root->right;
        }
        return res;
    }
};

LeetCode 145 二叉树的后序遍历

class Solution {
public:
    void myreverse(vector<int>& nums) {
        int left = 0, right = nums.size() - 1;
        while (left < right) {
            int temp = nums[right];
            nums[right] = nums[left];
            nums[left] = temp;
            left++; right--;
        }
    }
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> mystack;
        if (!root) return res;
        while (root || !mystack.empty()) {
            while (root) {
                mystack.push(root);
                res.push_back(root->val);
                root = root->right;
            }
            root = mystack.top();
            mystack.pop();
            root = root->left;
        }
        myreverse(res);
        return res;
    }
};