LinCode 二叉树的前中后遍历

最新推荐文章于 2020-10-18 13:27:46 发布

原创最新推荐文章于 2020-10-18 13:27:46 发布 · 382 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

数据结构 LintCode 专栏收录该内容

4 篇文章

订阅专栏

本文介绍了二叉树的前序、中序和后序遍历的非递归实现方法。前序遍历采用栈，顺序为根左右；中序遍历遵循左根右原则；后序遍历参照特定博客完成详细解释。

二叉树的前中后序遍历，前序遍历，根左右；中序遍历，左根右；后续遍历，左右根。非递归

这里写图片描述
二叉树的前序遍历
方法1，这个完全是我自己想的。在做完用队列实现二叉树的层次遍历后，按照这个思路，写了这个算法。
1，判断是否空树，如果是，则返回空；如果不是，则根入栈
2，栈不是空的，进入循环。新建一个树结点，把根赋给它，根出栈，对根处理；然后判断根是否有右子树，如果有则进栈；同理，判断是否有左子树，如果有则进栈。第一遍循环结束，然后再循环，直到遍历完。

vector<int> preorderTraversal(TreeNode *root) {
       vector<int>vec;
       if( ! root)
           return vec;
        stack<TreeNode *>stack;
        stack.push(root);
        while(! stack.empty())
        {
            TreeNode *head=stack.top();
            stack.pop();
            vec.push_back(head->val);
            if(head->right)
                stack.push(head->right);
            if(head->left)
                stack.push(head->left);
        }
        return vec;
    }

方法2，这个方法参考网上代码，和下面中序遍历一脉相承，只改动一处地方，把对数据的处理提到前面。

vector<int> preorderTraversal(TreeNode * root) {
        // write your code here
        vector<int> vec;
        stack<TreeNode *> stack;
        TreeNode *head=root;
        while( !stack.empty() || head)
        {
            if(head)
            {
                vec.push_back(head->val); //数据处理
                stack.push(head);
                head=head->left;
            }
            else
            {
                head=stack.top();
                stack.pop(); 
                head=head->right;
            }
        }
        return vec;
    }

中序遍历：左根右
1，在循环里，循环执行if，结点进栈，head移到左子树，直到找到最左结点。
2，栈顶出栈，对该数据处理，head移到右子树，如果该右子树有左子树，则重复执行第一步。

  vector<int> inorderTraversal(TreeNode * root) {
        // write your code here
        vector<int> vec;
        stack<TreeNode *> stack;
        TreeNode *head=root;
        while( !stack.empty() || head)
        {
            if(head)
            {
                stack.push(head);
                head=head->left;
            }
            else
            {
                head=stack.top();
                stack.pop();
                vec.push_back(head->val);
                head=head->right;
            }
        }
        return vec;
    }

后续遍历，参考来自以下博客，里面解释的很详细。
http://blog.csdn.net/u011116672/article/details/50221459

vector<int> postorderTraversal(TreeNode * root) {
        // write your code here
        vector<int> vec;
        stack<TreeNode *>stac;
        stack<int>stack_tag;
        TreeNode *head=root;
        while( !stac.empty() || head)
        {
            while(head)
            {
                stac.push(head);
                stack_tag.push(0);
                head=head->left;
            }
            while( !stac.empty() && stack_tag.top())
            {
                vec.push_back(stac.top()->val);
                stac.pop();
                stack_tag.pop();
            }
            if( !stac.empty())
            {
                stack_tag.pop();
                stack_tag.push(1);
                head=stac.top();
                head=head->right;
            }
        }
        return vec;
    }