代码随想录刷题day14

二叉树的递归遍历 、迭代遍历、统一迭代

递归法解决二叉树的前中后序遍历

中序遍历代码：

题解：

想好函数的参数，停止条件，和每一轮的操作有哪些，就可以写递归法。比较简单啦

    def inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        def digui(cur, res):
            if cur is None:
                return 
            digui(cur.left, res)
            res.append(cur.val)
            digui(cur.right, res)
            return res

        res = []
        return digui(root, res)

迭代法解决二叉树的前中后序遍历

后序遍历代码：

class Solution(object):
    def postorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if not root:
            return None 
        queue = []
        res = []
        queue.append(root)
        while queue:
            rot = queue.pop()
            res.append(rot.val)
            if rot.left:
                queue.append(rot.left)
            if rot.right:
                queue.append(rot.right)
        return res[::-1]

前序遍历代码：

class Solution(object):
    def preorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        zhan = []
        res = []
        if root is None:
            return zhan
        zhan.append(root)
        while zhan:
            tmp = zhan.pop()
            res.append(tmp.val)
            if tmp.right:
                zhan.append(tmp.right)
            if tmp.left:
                zhan.append(tmp.left)
        return res

中序遍历代码：

注意：

1） 用一个栈（list表示即可）来存放遍历过的节点，一个res数组存放结果，一个cur指针用来遍历二叉树。
2） 和前后序遍历的区别是，这个不能在初始时将头节点压入栈，因为第一个应该是左而非中。（要求遍历的顺序和访问的顺序不同）

class Solution(object):


    def inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        cur = root
        res = []
        st = []
        #如果是空节点，那么从栈里弹出元素，然后走向它的右节点
        #如果不是空节点，那么放入栈中，然后向左移动
        while st or cur:
            if cur != None:
                st.append(cur)
                cur = cur.left
            else:
                cur = st.pop()
                res.append(cur.val)
                cur = cur.right
        return res

统一写法的后序遍历：

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> 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;
    }
};