从小白开始刷算法 Tree 树篇先序遍历 leetcode.144

小小大凳子

已于 2023-06-18 13:51:29 修改

阅读量81

点赞数 1

分类专栏： leetcode刷题文章标签：算法 leetcode 链表

于 2023-06-18 12:44:10 首次发布

本文链接：https://blog.csdn.net/weixin_39098935/article/details/131270291

版权

leetcode刷题专栏收录该内容

41 篇文章 0 订阅

订阅专栏

文章目录

序言

虽然算法很难，但不应该就放弃。这是一个学习笔记，希望你们喜欢~

先自己尝试写，大概十几分钟仍然写不出来
看思路，再尝试跟着思路写
仍然写不出来，再看视频
b站up视频推荐：爱学习的饲养员

leetcode其他文章：

数组篇：
从小白开始刷算法数组篇 leetcode.485
从小白开始刷算法数组篇 leetcode.283
从小白开始刷算法数组篇 leetcode.27

链表篇：
从小白开始刷算法 ListNode 链表篇 leetcode.203
从小白开始刷算法 ListNode 链表篇 leetcode.206

队列篇
从小白开始刷算法 ListNode 链表篇 leetcode.933

栈篇
从小白开始刷算法 Stack 栈篇 leetcode.20
从小白开始刷算法 Stack 栈篇 leetcode.496

哈希篇
从小白开始刷算法 Hash 哈希篇 leetcode.217
从小白开始刷算法 Hash 哈希篇 leetcode.705

树篇

难度：简单

题目：

144.二叉树的前序遍历

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

示例1：

1

\

2

/

3

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

示例 2：

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

示例 3：

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

题目来源：力扣（LeetCode）

迭代思路

能否写出：不能写出，需要参考思路

时间：60分钟

思路：这次使用的是迭代算法

// 仅是我的思路代码，leetcode上大神更厉害
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        ArrayList<Integer> result = new ArrayList<>();
        if (root == null) {
            return result;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()) {
            TreeNode pop = stack.pop();
            result.add(pop.val);
            if (pop.right != null) {
                stack.push(pop.right);
            }
            if (pop.left != null) {
                stack.push(pop.left);
            }
        }
        return result;
    }
}

时间复杂度：O(n)

遍历每个节点的次数，对于先序遍历而言，每个节点都需要被访问一次，因此遍历的次数是 O(n)，其中 n 是节点的总数。

空间复杂度：O(n)

迭代算法的空间复杂度为 O(max(h, n))，其中 h 是二叉树的高度，n 是节点的总数。在最坏情况下，即二叉树为链式结构时，空间复杂度为 O(n)。

其他思路：

递归：

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        preorder(root, result);
        return result;
    }
    
    private void preorder(TreeNode node, List<Integer> result) {
        if (node == null) {
            return;
        }
        result.add(node.val); // 访问当前节点
        preorder(node.left, result); // 递归遍历左子树
        preorder(node.right, result); // 递归遍历右子树
    }
}