LeetCode OJ 之 Binary Tree Preorder Traversal （二叉树的前序遍历）

最新推荐文章于 2024-08-15 22:36:09 发布

思翊

最新推荐文章于 2024-08-15 22:36:09 发布

阅读量621

点赞数

CC 4.0 BY-SA版权

分类专栏： Leetcode OJ

本文链接：https://blog.youkuaiyun.com/u012243115/article/details/42000877

Leetcode OJ 专栏收录该内容

199 篇文章

订阅专栏

本文介绍二叉树的前序遍历算法，包括递归和非递归两种实现方式，并提供详细的代码示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目：

Given a binary tree, return the preorder traversal of its nodes' values.

给定一个二叉树，返回前序遍历的结果。

For example:
Given binary tree {1,#,2,3},

return [1,2,3].

Note: Recursive solution is trivial, could you do it iteratively?

思路：

非递归遍历时的思路是先输出结点值，再入栈，然后遍历左子树。退栈时，遍历栈顶结点的右子树。

详情参看：http://blog.youkuaiyun.com/u012243115/article/details/40615603 。

递归版代码：

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> preorderTraversal(TreeNode *root)
    {
        vector<int> result;
        if(root == NULL)
            return result;
        preorderTraversal(root,result);
        return result;
    }
    void preorderTraversal(TreeNode *root , vector<int> &result)
    {
        if(root == NULL)
            return;
        result.push_back(root->val);
        preorderTraversal(root->left,result);
        preorderTraversal(root->right,result);
    }
};

非递归版代码一：

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> preorderTraversal(TreeNode *root)
    {
        vector<int> result;
        stack<TreeNode *> stk;
        TreeNode *p = root;
        while(p != NULL || !stk.empty())
        {
            if(p != NULL)
            {
                result.push_back(p->val);
                stk.push(p);
                p = p->left;
            }
            else
            {
                p = stk.top();
                stk.pop();
                p = p->right;
            }
        }
        return result;
    }
};

非递归版代码二：

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    //思路是根结点先入栈，然后根结点出栈，输出根结点，右孩子入栈（如果有的话）。左孩子入栈（如果有的话）。
    vector<int> preorderTraversal(TreeNode *root)
    {
        vector<int> result;
        stack<TreeNode *> stk;
        if(root == NULL)
            return result;
        TreeNode *p = root;
        stk.push(p);
        while(!stk.empty())
        {
            p = stk.top();
            result.push_back(p->val);
            stk.pop();
            if(p->right)
                stk.push(p->right);
            if(p->left)
                stk.push(p->left);
        }
        return result;
    }
};

使用链表实现栈的效果：

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    //使用链表实现栈的效果，操作都一样，只是出栈方式不一样
    vector<int> preorderTraversal(TreeNode *root)
    {
        vector<int> result;
        list<TreeNode *> lst;
        if(root == NULL)
            return result;
        TreeNode *p = root;
        lst.push_front(p);//插入链表头，相当于入栈
        while(!lst.empty())
        {
            p = lst.front();//取链表头
            result.push_back(p->val);
            lst.erase(lst.begin());//删除链表头
            if(p->right)
                lst.push_front(p->right);
            if(p->left)
                lst.push_front(p->left);
        }
        return result;
    }
};