Lintcode 66、67、68二叉树的前中后序遍历(递归、非递归实现)

2人阅读 评论(0) 收藏 举报
分类:

前序遍历:

/**
 * Definition of TreeNode:
 * class TreeNode {
 * public:
 *     int val;
 *     TreeNode *left, *right;
 *     TreeNode(int val) {
 *         this->val = val;
 *         this->left = this->right = NULL;
 *     }
 * }
 */

class Solution {
public:
    /**
     * @param root: A Tree
     * @return: Preorder in ArrayList which contains node values.
     */
    //vector<int> res; //递归实现中初始化result,要放在函数体外
    vector<int> preorderTraversal(TreeNode * root) {
        // write your code here
    //递归实现:
    /* if(root != NULL){
        res.push_back(root->val);
        preorderTraversal(root->left);
        preorderTraversal(root->right);
        }
    return res; */
    
    //非递归实现:
        TreeNode *x = root;
        vector<int> result;
        vector<TreeNode*> p;
        while(x != NULL || p.size() != 0){
            result.push_back(x->val);
            if(x->right != NULL)
                p.push_back(x->right);
            x = x->left;
            if(x == NULL && p.size() != 0){
                x = p.back();
                p.pop_back();
            }
        }
        return result;
    }
};

中序遍历:

/**
 * Definition of TreeNode:
 * class TreeNode {
 * public:
 *     int val;
 *     TreeNode *left, *right;
 *     TreeNode(int val) {
 *         this->val = val;
 *         this->left = this->right = NULL;
 *     }
 * }
 */

class Solution {
public:
    /**
     * @param root: A Tree
     * @return: Inorder in ArrayList which contains node values.
     */
    //vector<int> result; //递归实现时初始化result要放在函数体外
    vector<int> inorderTraversal(TreeNode * root) {
        // write your code here
        //非递归实现
        /*vector<int> result;
        vector<TreeNode*> p;
        while(root != NULL || p.size() != 0){
            while(root != NULL){
                p.push_back(root);
                root = root -> left;
            }
            root = p.back();
            p.pop_back();
            result.push_back(root -> val);
            root = root -> right;
        }
        return result; */
        
        //递归实现
        if(root != NULL){
            inorderTraversal(root -> left);
            result.push_back(root -> val);
            inorderTraversal(root -> right);
        }
        return result;
    }
};

后序遍历:

思路:用两个栈实现后序遍历的过程,具体过程如下:
1.申请一个栈,记为s1,然后将头节点压入s1中。
2.从s1中弹出的节点,然后依次将节点的左孩子和右孩子压入s1中。
3.在整个过程中,每一个从s1中弹出的节点都放进s2中。
4.不断重复步骤2和步骤3,直到s1为空,过程停止。
5.从s2中依次弹出节点并打印,打印的顺序就是后序遍历的顺序。

每棵子树的头节点都最先从s1中弹出,然后把该节点的孩子节点按照先左再右的顺序压入s1,那么从s1弹出的顺序就是先右再左,所以从s1中弹出的顺序就是中、右、左。然后,s2重新收集的过程就是把s1的弹出顺序逆序,所以s2从栈顶到栈底的顺序就变成了左、右、中。


/**
 * Definition of TreeNode:
 * class TreeNode {
 * public:
 *     int val;
 *     TreeNode *left, *right;
 *     TreeNode(int val) {
 *         this->val = val;
 *         this->left = this->right = NULL;
 *     }
 * }
 */

class Solution {
public:
    /**
     * @param root: A Tree
     * @return: Postorder in ArrayList which contains node values.
     */
    vector<int> result; //递归遍历初始化result
    vector<int> postorderTraversal(TreeNode * root) {
        // write your code here
        //非递归遍历
        /* vector<int> result;
        if(root == NULL)
            return result;
        vector<TreeNode*> s1;
        vector<TreeNode*> s2;
        s1.push_back(root);
        while(s1.size() != 0){
            TreeNode* temp1 = s1.back();
            s2.push_back(temp1);
            s1.pop_back();
            if(temp1 -> left != NULL)
                s1.push_back(temp1 -> left);
            if(temp1 -> right != NULL)
                s1.push_back(temp1 -> right);
        }
        while(s2.size() != 0){
            TreeNode* temp2 = s2.back();
            result.push_back(temp2 -> val);
            s2.pop_back();
        }
        return result; */
        
        //递归遍历
        if(root != NULL){
            postorderTraversal(root -> left);
            postorderTraversal(root-> right);
            result.push_back(root -> val);
        }
        return result;
    }
};
积累积累。
查看评论

二叉树的前中后序遍历,递归和非递归方式

解决二叉树的很多问题的方案都是基于对二叉树的遍历。遍历二叉树的前序,中序,后序三大方法算是计算机科班学生必写代码了。其递归遍历是人人都能信手拈来,可是在手生时写出非递归遍历恐非易事。正因为并非易事,所...
  • Hk_john
  • Hk_john
  • 2017-04-10 19:34:35
  • 222

【数据结构】二叉树的前中后序遍历递归和非递归实现

二叉树有很多操作,而二叉树的遍历只是其中的一个基本操作。 二叉树的遍历方式有3种:前序遍历,中序遍历,后序遍历。前中后遍历顺序是根据什么时候遍历根节点来说的。...
  • e_one
  • e_one
  • 2016-01-28 22:24:36
  • 5925

LintCode | 68. 二叉树的后序遍历

给出一棵二叉树,返回其节点值的后序遍历。 题目链接 /** * Definition of TreeNode: * public class TreeNode { * public i...
  • orz_713
  • orz_713
  • 2017-03-22 18:34:10
  • 136

Lintcode 二叉树的前序遍历 (递归和非递归法)

给出一棵二叉树,返回其节点值的前序遍历。 您在真实的面试中是否遇到过这个题?  Yes 样例 给出一棵二叉树 {1,#,2,3}, 1 \ 2 / ...
  • Hk_john
  • Hk_john
  • 2017-04-06 19:16:58
  • 1659

二叉树前中后序遍历(递归)

中途对于递归总是理不清,后来看了代码和书才想通:递归==递+归:必须要有递归结束条件,可以不是返回值,若调用一个递归的主算法为第0层算法,则从主算法调用递归算法为进入第1层调用,从第i层递归调用本算法...
  • uagvdu
  • uagvdu
  • 2016-04-26 09:36:20
  • 533

LintCode 67 二叉树的后序遍历

题目:postorderTraversal要求:给出一棵二叉树,返回其节点值的后序遍历。样例:给出二叉树 {1,#,2,3}, 1 \ 2 / 3 返回 [1,3,...
  • linglian0522
  • linglian0522
  • 2017-05-03 12:21:44
  • 255

【LintCode-67】二叉树的中序遍历(Java实现-递归算法/非递归算法)

递归算法代码记录: public List preorderTraversal(TreeNode root) { if(root==null){ retu...
  • YangDongChuan1995
  • YangDongChuan1995
  • 2017-11-07 17:25:06
  • 192

(C语言版)二叉树遍历算法——包含递归前、中、后序和层次,非递归前、中、后序和层次遍历共八种

首先,要感谢网上的参考资料。 http://mengliao.blog.51cto.com/876134/1178079(作者:BlackAlpha)http://blog.csdn.net/fz...
  • u011248694
  • u011248694
  • 2014-03-18 14:08:38
  • 2079

二叉树遍历(先中后序 递归和非递归+层次遍历)java代码 可直接运行

package edu.lnu.fang.BiTree;import java.util.LinkedList; import java.util.List; import java.util.Sta...
  • fangchao3652
  • fangchao3652
  • 2016-12-03 18:34:06
  • 574

[LintCode] 中序遍历和后序遍历树构造二叉树 Construct Binary Tree from Inorder and Postorder Traversal

根据中序遍历和后序遍历树构造二叉树 注意事项 你可以假设树中不存在相同数值的节点 样例 给出树的中序遍历: [1,2,3] 和后序遍历: [1,3,2] 返回如下的树: 2 / ...
  • wutingyehe
  • wutingyehe
  • 2016-04-18 20:25:03
  • 458
    个人资料
    持之以恒
    等级:
    访问量: 5万+
    积分: 1020
    排名: 5万+