二叉树的循环遍历和递归遍历（经典）

备注：以下代码均采用c++实现。

递归遍历

前序遍历：根、左、右

    // 前序遍历：根、左、右
    void beforeOrder(TreeNode* root, vector<int>& before){
        // 终止条件
        if(root == NULL){
            return;
        }
        // 放入当前节点
        before.push_back(root->val);
        // 放入左子节点
        beforeOrder(root->left, before);
        // 放入右子节点
        beforeOrder(root->right, before);
    }

中序遍历：左、跟、右

	// 中序遍历：左、根、右
    void middleOrder(TreeNode* root, vector<int>& middle){
        // 终止条件
        if(root == NULL){
            return;
        }
        // 放入左子节点
        middleOrder(root->left, middle);
        // 放入当前节点
        middle.push_back(root->val);
        // 放入右子节点
        middleOrder(root->right, middle);
    }

后序遍历：左、右、跟

 	// 后序遍历：左、右、根
    void afterOrder(TreeNode* root, vector<int>& after){
        // 终止条件
        if(root == NULL){
            return;
        }
        // 放入左子节点
        afterOrder(root->left, after);
        // 放入右子节点
        afterOrder(root->right, after);
        // 放入当前节点
        after.push_back(root->val);
    }

函数调用：

   /**
     * 
     * @param root TreeNode类 the root of binary tree
     * @return int整型vector<vector<>>
     */
    vector<vector<int> > threeOrders(TreeNode* root) {
        // write code here
        vector<int> before;
        vector<int> middle;
        vector<int> after;
        vector<vector<int>> ret;
        if(root == NULL){
            ret.push_back(before);
            ret.push_back(middle);
            ret.push_back(after);
            return ret; 
        }
   
        beforeOrder(root, before);
        middleOrder(root, middle);
        afterOrder(root, after);
        
        ret.push_back(before);
        ret.push_back(middle);
        ret.push_back(after);
        return ret;
    }

循环遍历

前序遍历：跟、左、右

    // 前序遍历：根、左、右
    void beforeOrder(TreeNode* root, vector<int>& before){
        // 辅助栈
        stack<TreeNode*> s;
        
        // 前序遍历：根、左、右
        TreeNode* p = root; 
        s.push(p);
        while(!s.empty()){
            p = s.top();
            s.pop();
            before.push_back(p->val);
            if(p->right){
                s.push(p->right);
            }
            if(p->left){
                s.push(p->left);
            }
        }
    }

中序遍历：左、跟、右

    // 中序遍历：左、根、右
    void middleOrder(TreeNode* root, vector<int>& middle){
        // 辅助栈
        stack<TreeNode*> s;
        
        // 中序遍历：左、根、右
        TreeNode* p = root;
        p = root;
        while(!s.empty() || p){
            // 先找到最左边的节点
            while(p){
                s.push(p);
                p = p->left;
            }
            // 循环出栈
            if(!s.empty()){
                p = s.top();
                s.pop();
                // 左子节点为空，放入当前节点
                middle.push_back(p->val);
                // 遍历右节点
                p = p->right;
            }
        }
    }

后序遍历：左、右、跟

    // 后序遍历：左、右、根
    void afterOrder(TreeNode* root, vector<int>& after){
        
        // 辅助栈
        stack<TreeNode*> s;
        
        // 中序遍历：左、右、跟
        TreeNode* p = root;
        s.push(p);
        while(!s.empty()){
            p = s.top();
            s.pop();
            after.push_back(p->val);
            if(p->left){
                s.push(p->left);
            }
            if(p->right){
                s.push(p->right);
            }
        }
        // 翻转列表
        reverse(after.begin(), after.end());
    }

主函数调用

    /**
     * 
     * @param root TreeNode类 the root of binary tree
     * @return int整型vector<vector<>>
     */
    vector<vector<int> > threeOrders(TreeNode* root) {
        // write code here
        vector<int> before;
        vector<int> middle;
        vector<int> after;
        vector<vector<int>> ret;
        if(root == NULL){
            ret.push_back(before);
            ret.push_back(middle);
            ret.push_back(after);
            return ret; 
        }
        
        // 递归方式调用
        before.clear();
        beforeOrder(root, before);
        middle.clear();
        middleOrder(root, middle);
        after.clear();
        afterOrder(root, after);
        
        ret.push_back(before);
        ret.push_back(middle);
        ret.push_back(after);
        return ret;
    }