面试经典算法系列之二叉树5 -- 二叉树的前序遍历

最新推荐文章于 2024-09-04 22:12:41 发布
最新推荐文章于 2024-09-04 22:12:41 发布
阅读量196 收藏 1
点赞数 1
分类专栏： 面试经典算法系列 文章标签： 面试 算法 leetcode c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44630255/article/details/137658411
版权

面试经典算法20 - 二叉树的前序遍历

LeetCode.144
公众号：阿Q技术站

问题描述

给你二叉树的根节点 root ，返回它节点值的 前序 遍历。

示例 1：

img

输入：root = [1,null,2,3]
输出：[1,2,3]

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[1]

示例 4：

img

输入：root = [1,2]
输出：[1,2]

示例 5：

img

输入：root = [1,null,2]
输出：[1,2]

提示：

  • 树中节点数目在范围 [0, 100] 内
  • -100 <= Node.val <= 100

思路

递归
  1. 使用递归进行前序遍历，即根节点 -> 左子树 -> 右子树。
  2. 对于每个节点，先将节点的值加入结果数组，然后递归遍历左子树和右子树。
迭代

遍历，先将根节点压入栈中。然后循环执行以下操作：

  • 弹出栈顶节点，如果节点为空，则继续弹出，直到遇到非空节点。
  • 对于非空节点，先将其值加入结果数组，然后将右子节点压入栈中，再将左子节点压入栈中，保证左子节点在右子节点之前被访问。

图解

这里给大家图解一下迭代的方法。

  1. 先将根节点压入栈中。

image-20240228231435835

  1. 当栈不为空时，弹出栈顶元素，遍历右子节点，再遍历左子节点。

image-20240228234208113

  1. 依次弹出栈顶元素，并添加到结果集。

image-20240228234530533

参考代码

C++
递归
#include <iostream>
#include <vector>
#include <stack>
#include <unordered_map>

using namespace std;

// 定义二叉树节点
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;
        preorder(root, result);
        return result;
    }

    void preorder(TreeNode* root, vector<int>& result) {
        if (root == nullptr) {
            return;
        }
        result.push_back(root->val); // 将当前节点的值加入结果数组
        preorder(root->left, result); // 递归遍历左子树
        preorder(root->right, result); // 递归遍历右子树
    }
};

// 创建二叉树
TreeNode* createTree() {
    TreeNode* root = new TreeNode(1);
    root->right = new TreeNode(2);
    root->right->left = new TreeNode(3);
    return root;
}

// 打印结果
void printResult(const vector<int>& result) {
    cout << "前序遍历结果：";
    for (int val : result) {
        cout << val << " ";
    }
    cout << endl;
}

int main() {
    Solution sol;
    TreeNode* root = createTree();
    vector<int> result = sol.preorderTraversal(root);
    printResult(result);
    return 0;
}
迭代
#include <iostream>
#include <vector>
#include <stack>

using namespace std;

// 二叉树节点的定义
struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

// 非递归前序遍历
vector<int> preorderTraversal(TreeNode* root) {
    vector<int> result; // 存储遍历结果的数组
    if (!root) return result; // 如果根节点为空，直接返回空数组

    stack<TreeNode*> st; // 辅助栈，用于存储遍历过程中的节点
    st.push(root); // 将根节点入栈

    while (!st.empty()) { // 当栈非空时循环执行以下操作
        TreeNode* node = st.top(); // 获取栈顶节点
        st.pop(); // 弹出栈顶节点
        result.push_back(node->val); // 将节点值加入结果数组

        if (node->right) { // 如果节点有右子节点，将右子节点入栈
            st.push(node->right);
        }
        if (node->left) { // 如果节点有左子节点，将左子节点入栈
            st.push(node->left);
        }
    }

    return result; // 返回结果数组
}

// 创建二叉树
TreeNode* createTree(vector<int>& nodes, int index) {
    if (index >= nodes.size() || nodes[index] == -1) {
        return nullptr; // 如果节点为空，则返回nullptr
    }
    TreeNode* root = new TreeNode(nodes[index]); // 创建当前节点
    root->left = createTree(nodes, 2 * index + 1); // 创建左子树
    root->right = createTree(nodes, 2 * index + 2); // 创建右子树
    return root; // 返回当前节点
}

// 销毁二叉树
void destroyTree(TreeNode* root) {
    if (!root) return; // 如果根节点为空，直接返回
    destroyTree(root->left); // 递归销毁左子树
    destroyTree(root->right); // 递归销毁右子树
    delete root; // 删除当前节点
}

int main() {
    vector<int> nodes = {1, 2, 3, -1, -1, 4, 5}; // 定义二叉树的先序遍历序列
    TreeNode* root = createTree(nodes, 0); // 创建二叉树
    vector<int> result = preorderTraversal(root); // 进行非递归前序遍历
    for (int val : result) { // 输出遍历结果
        cout << val << " ";
    }
    cout << endl;

    destroyTree(root); // 销毁二叉树

    return 0;
}
Java
import java.util.*;

// 二叉树节点的定义
class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) { val = x; }
}

public class Main {
    // 非递归前序遍历
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>(); // 存储遍历结果的数组
        if (root == null) return result; // 如果根节点为空，直接返回空数组

        Stack<TreeNode> stack = new Stack<>(); // 辅助栈，用于存储遍历过程中的节点
        stack.push(root); // 将根节点入栈

        while (!stack.isEmpty()) { // 当栈非空时循环执行以下操作
            TreeNode node = stack.pop(); // 获取栈顶节点
            result.add(node.val); // 将节点值加入结果数组

            if (node.right != null) { // 如果节点有右子节点，将右子节点入栈
                stack.push(node.right);
            }
            if (node.left != null) { // 如果节点有左子节点，将左子节点入栈
                stack.push(node.left);
            }
        }

        return result; // 返回结果数组
    }

    // 创建二叉树
    public TreeNode createTree(int[] nodes, int index) {
        if (index >= nodes.length || nodes[index] == -1) {
            return null; // 如果节点为空，则返回null
        }
        TreeNode root = new TreeNode(nodes[index]); // 创建当前节点
        root.left = createTree(nodes, 2 * index + 1); // 创建左子树
        root.right = createTree(nodes, 2 * index + 2); // 创建右子树
        return root; // 返回当前节点
    }

    // 销毁二叉树
    public void destroyTree(TreeNode root) {
        if (root == null) return; // 如果根节点为空，直接返回
        destroyTree(root.left); // 递归销毁左子树
        destroyTree(root.right); // 递归销毁右子树
    }

    public static void main(String[] args) {
        Main solution = new Main();
        int[] nodes = {1, 2, 3, -1, -1, 4, 5}; // 定义二叉树的先序遍历序列
        TreeNode root = solution.createTree(nodes, 0); // 创建二叉树
        List<Integer> result = solution.preorderTraversal(root); // 进行非递归前序遍历
        for (int val : result) { // 输出遍历结果
            System.out.print(val + " ");
        }
        System.out.println();

        solution.destroyTree(root); // 销毁二叉树
    }
}
Python
# 二叉树节点的定义
class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

# 非递归前序遍历
def preorderTraversal(root):
    result = [] # 存储遍历结果的数组
    if not root:
        return result # 如果根节点为空，直接返回空数组

    stack = [] # 辅助栈，用于存储遍历过程中的节点
    stack.append(root) # 将根节点入栈

    while stack: # 当栈非空时循环执行以下操作
        node = stack.pop() # 获取栈顶节点
        result.append(node.val) # 将节点值加入结果数组

        if node.right: # 如果节点有右子节点，将右子节点入栈
            stack.append(node.right)
        if node.left: # 如果节点有左子节点，将左子节点入栈
            stack.append(node.left)

    return result # 返回结果数组

# 创建二叉树
def createTree(nodes, index):
    if index >= len(nodes) or nodes[index] == -1:
        return None # 如果节点为空，则返回None
    root = TreeNode(nodes[index]) # 创建当前节点
    root.left = createTree(nodes, 2 * index + 1) # 创建左子树
    root.right = createTree(nodes, 2 * index + 2) # 创建右子树
    return root # 返回当前节点

# 销毁二叉树
def destroyTree(root):
    if not root:
        return # 如果根节点为空，直接返回
    destroyTree(root.left) # 递归销毁左子树
    destroyTree(root.right) # 递归销毁右子树

# 主函数
if __name__ == "__main__":
    nodes = [1, 2, 3, -1, -1, 4, 5] # 定义二叉树的先序遍历序列
    root = createTree(nodes, 0) # 创建二叉树
    result = preorderTraversal(root) # 进行非递归前序遍历
    print(result) # 输出遍历结果

    destroyTree(root) # 销毁二叉树
阿Q技术站
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树前序遍历-迭代
hhhghh_的博客
03-11 1627
二叉树的前序遍历 对于一颗二叉树，当遍历它的时候使用 递归总是轻而易举的。 这是二叉树前序遍历-使用递归 public void preorderTraversal(TreeNode root){ if(root==null) return; System.out.print(root.data+" "); preorde...
二叉树的前序遍历
CV前沿
04-03 3万+
二叉树的前序遍历的记忆法则是“根左右"，即先遍历根节点，再遍历左子树节点，再遍历右子树节点。 以上图为例，前序遍历的结果是【A, B, D, E, C, F, G】 一、解题思路：递归 递归是我们实现前中后序遍历最常用的方法。 什么问题可以采用递归求解呢？ 需要满足三个条件： 一个问题的解可以分解为若干个子问题的解； 这个问题与分解的子问题，除了数据规模不同外，求解思路相同 存在递归终止条件。 那么在知道一个问题可以采用递归实现之后，如何写出递归代码呢？ 关键在于能写出递归公式，找到终止条件。 在.
C语言经典算法之二叉树的前序遍历（递归实现）
weixin_56154577的博客
01-30 1795
在C语言中，二叉树的前序遍历（Preorder Traversal）递归实现的基本思路是按照“根-左-右”的顺序访问节点。
二叉树前序遍历--递归
he_xin2009的专栏
04-14 2046
二叉树遍历、前序遍历、递归、入栈、出栈
二叉树遍历方法——前、中、后序遍历（图解）
在夜里行走的博客
11-04 14万+
二叉树的前、中、后序遍历的递归与非递归算法
二叉树的遍历-c++-前序、中序、后序
jing0726_的博客
03-25 672
二叉树的三种遍历-前序、中序、后序-c++
【二叉树的三种遍历方式-前序遍历】
HjxShare的博客
01-05 774
二叉树的三种遍历方式-前序遍历
c语言用递归算法前序遍历二叉树,C语言实现二叉树的前序遍历(递归)
weixin_42128537的博客
05-24 1909
C语言实现二叉树的前序遍历(递归)C语言实现二叉树的前序遍历算法实现一： #include #include typedef struct BiTNode//定义结构体{char data;struct BiTNode *lchild,*rchild;}BiTNode,*BiTree;void CreateBiTree(BiTree &T) //前序创建树{char ch;scanf("%...
二叉树前序遍历、中序遍历、后序遍历、层序遍历的直观理解
热门推荐
白夜行的狼
05-23 38万+
0. 写在最前面 希望大家收藏： 本文持续更新地址：https://haoqchen.site/2018/05/23/go-through-binary-tree/     复习到二叉树，看到网上诸多博客文章各种绕，记得头晕。个人觉得数学、算法这些东西都是可以更直观简洁地表示，然后被记住的，并不需要靠死记硬背。 本文的程序基本来源于《大话数据结构》，个人感觉是一本非常好的书，推荐去看。 ...
数据结构----二叉树的遍历-前序-中序-后序-层序(详解)
m0_60565784的博客
05-23 1280
前言 喜欢的老铁留下你们的三连 文章目录1.回顾二叉树的概念2.二叉树遍历有：前序/中序/后序的递归结构遍历2.1 前序2.2中序 1.回顾二叉树的概念 二叉树是： 空树 非空：根节点，根节点的左子树、根节点的右子树组成的。 2.二叉树遍历有：前序/中序/后序的递归结构遍历 前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。 中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）。 后序遍历(Pos
python-leetcode面试题解之第144题二叉树的前序遍历-题解.zip
05-14
对于正在准备求职面试的Python开发者，熟练掌握二叉树的前序遍历是基础技能之一，同时了解如何在LeetCode上解决和提交问题也是必备的能力。通过这样的练习，你可以提升自己的编程技巧，增强对数据结构和算法的理解，...
二叉树前序遍历的非递归算法
09-04
"二叉树前序遍历的非递归算法" 二叉树前序遍历的非递归算法是指在不使用递归函数的情况下，对二叉树进行前序遍历的算法。前序遍历是指先访问根节点，然后访问左子树，最后访问右子树。 在了解非递归算法之前，我们...
二叉树遍历--前序遍历
06-10
二叉树遍历是访问二叉树中所有节点的一种基本操作，常用于搜索、排序和数据组织等问题。本话题主要关注的是“前序遍历”，这是一种重要的遍历策略，常用于复制或打印树的结构。 **前序遍历**（Preorder Traversal）...
操作系统面试真题总结（六）
月伴飞鱼
09-04 884
涉及的任务无法继续执行，因为每个任务都在等待其他任务释放资源，但是没有任务会释放它的资源，因为它们都在等待。这是因为CPU可以通过时间片轮转或其他任务切换策略，在各个任务之间快速切换，给人以它们在同时进行的错觉。这是一种非阻塞调用，也就是说，还没得到结果，就继续做别的事情，不会因为单一操作的等待而阻塞。这是一种阻塞调用，也就是说，进行某项操作的过程中，不得不停下来等待，直到这个操作完成。如果你的电脑有多个核心或处理器，你就可以在多个核心或处理器上同时执行多个线程，这是。，主要取决于具体的需求和场景。
***萌新6：24点（爆搜）
最新发布
2301_80718054的博客
09-04 381
来源：牛客网。
测试基础｜记一次CPU冲高的排查过程！
09-04 434
背景、需求需要计算大容量环境下多个数据库数据的负载，并把分库关系迁移，以实现多个数据库节点负载均衡。现象、执行分库迁移脚本后，脚本执行进度始终保持 10%，组件 CPU 使用率冲到 95% 以上，且后台没有打印出有用的日志。
11. GIS三维建模工程师岗位职责、技术要求和常见面试题
专注GIS软件开发。
09-04 1293
GIS 三维建模工程师负责利用地理信息数据创建逼真的三维地理模型，以实现更直观的地理信息展示和分析。请介绍一下你对地理信息数据安全的理解，以及在三维建模过程中如何保障数据安全？请介绍一下你对三维地理信息系统的用户体验的理解，以及如何提高用户体验？请介绍一下你在三维建模过程中遇到的一个技术难题，以及你是如何解决的？在三维建模过程中，如何考虑模型的可扩展性和兼容性？请介绍一下你对三维建模技术在不同领域的应用的了解。请介绍一下你对三维建模技术的发展趋势的看法。如何进行三维模型的优化，以提高模型的性能？
2024前端面试题-篇章二
weixin_52941842的博客
09-02 985
是指把接收多个参数的函数变换成接收单一参数的函数，嵌套返回直到所有参数都被使用并返回最终结果，函数柯里化之后依旧还是一个函数，只是这个函数返回值依旧是一个函数柯里化的一个主要用处就是实现参数复用也可以叫事件代理，简单解释就是利用时间冒泡的机制将子元素的事件绑定到父元素身上减少事件处理程序的数量简化代码逻辑动态添加跟删除子元素。
如何防止常见的Web应用安全漏洞！
MJH827的博客
09-04 714
Web应用的广泛使用伴随着各种安全威胁。近年来，许多企业因忽视Web应用的安全性而遭受重大损失。本文将介绍几种常见的Web应用安全漏洞，并提供具体的防护方案和实战演练。
二叉树前序遍历算法实现
前序遍历是二叉树遍历的一种常见方法，主要用于访问树中的所有节点。前序遍历的顺序是： 1. 访问根节点 2. 遍历左子树（如果存在） 3. 遍历右子树（如果存在） 对于给定的题目，目标是编写一个函数，接受一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值