程序员经验分享-hwhale

LeetCode：二叉树的遍历方式（13道经典题目）

2023-11-16

LeetCode：二叉树的遍历方式（13道经典题目）

本文带来与二叉树的遍历方法有关的经典题目，主要实现是C++。

2.1 深度优先遍历

2.1.1 递归遍历

144. 二叉树的前序遍历 

class Solution {
public:
	vector<int> preorderTraversal(TreeNode* root) {
		vector<int> vec;
		traversal(root, vec);
		return vec;
	}

	void traversal(TreeNode* root, vector<int>& vec) {
		if (root == nullptr) return;
		vec.push_back(root->val);  // 中
		traversal(root->left, vec);
		traversal(root->right, vec);
	}
};

class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        path = []

        def traversal(root):
            if not root: return 
            path.append(root.val)
            traversal(root.left)
            traversal(root.right)
        
        traversal(root)
        return path

145. 二叉树的后序遍历 

class Solution {
public:
	vector<int> postorderTraversal(TreeNode* root) {
		vector<int> vec;
		traversal(root, vec);
		return vec;
	}

	void traversal(TreeNode* root, vector<int>& vec) {
		if (root == nullptr) return;
		traversal(root->left, vec);
		traversal(root->right, vec);
		vec.push_back(root->val);
	}
};

94. 二叉树的中序遍历 

class Solution {
public:
	vector<int> inorderTraversal(TreeNode* root) {
		vector<int> vec;
		traversal(root, vec);
		return vec;
	}

	void traversal(TreeNode* root, vector<int>& vec) {
		if (root == nullptr) return;
		traversal(root->left, vec);
		vec.push_back(root->val);
		traversal(root->right, vec);
	}
};

2.1.2 迭代法

递归的实现就是：每一次递归调用都会把函数的局部变量、参数值和返回地址等压入调用栈中，然后递归返回的时候，从栈顶弹出上一次递归的各项参数，所以这就是递归为什么可以返回上一层位置的原因。所以我们可以通过迭代实现深度优先遍历。

144. 二叉树的前序遍历 

class Solution {
public:
	vector<int> preorderTraversal(TreeNode* root) {
		stack<TreeNode*> st;
		vector<int> vec;
		if (root == nullptr)return vec;
		st.push(root);
		while (!st.empty()) {
			TreeNode* node = st.top();
			st.pop();
			vec.push_back(node->val);
			if (node->right) st.push(node->right);
			if (node->left) st.push(node->left);
		}
		return vec;
	}
};

class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        result = []
        if not root: return result

        st = []
        st.append(root)

        while st:
            node = st.pop()
            result.append(node.val)
            if node.right:
                st.append(node.right)
            if node.left:
                st.append(node.left)
            
        return result

94. 二叉树的中序遍历

迭代法前序遍历和中序遍历后序遍历的代码不通用！

因为前序遍历的顺序是中左右，先访问的元素是中间节点，要处理的元素也是中间节点，所以刚刚才能写出相对简洁的代码，因为要访问的元素和要处理的元素顺序是一致的，都是中间节点。

那么再看看中序遍历，中序遍历是左中右，先访问的是二叉树顶部的节点，然后一层一层向下访问，直到到达树左面的最底部，再开始处理节点（也就是在把节点的数值放进result数组中），这就造成了处理顺序和访问顺序是不一致的。

那么在使用迭代法写中序遍历，就需要借用指针的遍历来帮助访问节点，栈则用来处理节点上的元素。

class Solution {
public:
	vector<int> inorderTraversal(TreeNode* root) {
		vector<int> vec;
		stack<TreeNode*> st;
		TreeNode* cur = root;
		while (cur != nullptr || !st.empty()) {
			if (cur != nullptr) {  // 指针来访问节点，访问到最底层
				st.push(cur);  // 将访问的节点放进栈
				cur = cur->left;  // 左
			}
			else {
				cur = st.top(); // 从栈里弹出的数据，就是要处理的数据
				st.pop();
				vec.push_back(cur->val);  // 中
				cur = cur->right;  // 右
			}
		}
		return vec;
	}
}; 

class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        result = []
        if not root: return result

        st = []
        cur = root

        while cur or st:
            if cur:
                st.append(cur)
                cur = cur.left
            else:
                cur = st.pop()
                result.append(cur.val)
                cur = cur.right
        
        return result

145. 二叉树的后序遍历

前序：中左右 --> 中右左 --> 左右中(reverse)

class Solution {
public:
	vector<int> postorderTraversal(TreeNode* root) {
		vector<int> vec;
		stack<TreeNode*> st;
		if (root == nullptr) return vec;
		st.push(root);
		while (!st.empty()) {
			TreeNode* node = st.top();
			st.pop();
			vec.push_back(node->val);
			if (node->left) st.push(node->left);
			if (node->right) st.push(node->right);
		}
		reverse(vec.begin(), vec.end());
		return vec;
	}
};

class Solution:
    def postorderTraversal(self, root: TreeNode) -> List[int]:
        result = []
        if not root: return result

        st = []
        st.append(root)
        while st:
            node = st.pop()
            result.append(node.val)
            if node.left: st.append(node.left)
            if node.right: st.append(node.right)
        
        return result[::-1]

2.1.3 二叉树的统一迭代法

注意这里是栈， 先进后出，顺序相反

以中序遍历为例，使用栈的话，无法同时解决访问节点（遍历节点）和处理节点（将元素放进结果集）不一致的情况。那我们就将访问的节点放入栈中，把要处理的节点也放入栈中但是要做标记。

如何标记呢，就是要处理的节点放入栈之后，紧接着放入一个空指针作为标记。 这种方法也可以叫做标记法。

144. 二叉树的前序遍历 

class Solution {
public:
	vector<int> preorderTraversal(TreeNode* root) {
		vector<int> vec;
		stack<TreeNode*> st;
		if (root != nullptr) st.push(root);
		while (!st.empty()) {
			TreeNode* node = st.top();
			if (node != nullptr) {
				st.pop();
				if (node->right) st.push(node->right);
				if (node->left) st.push(node->left);
				st.push(node);
				st.push(nullptr);
			}
			else {
				st.pop();
				node = st.top();
				st.pop();
				vec.push_back(node->val);
			}
		}
		return vec;
	}
};

class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        result = []
        st = []
        if root: st.append(root)

        while st:
            node = st.pop()
            if node:
                 if node.right: st.append(node.right)
                 if node.left: st.append(node.left)
                 st.append(node)
                 st.append(None)
            else:
                node = st.pop()
                result.append(node.val)
        return result

94. 二叉树的中序遍历 

class Solution {
public:
	vector<int> inorderTraversal(TreeNode* root) {
		vector<int> vec;
		stack<TreeNode*> st;
		if (root != nullptr) st.push(root);
		while (!st.empty()) {
			TreeNode* node = st.top();
			if (node != nullptr) {
				st.pop();  // 将该节点弹出，避免重复操作，下面再将右中左节点添加到栈中
				if (node->right) st.push(node->right);  // 添加右节点（空节点不入栈）
				st.push(node);        // 添加中节点
				st.push(nullptr);     // 中节点访问过，但是还没有处理，加入空节点做为标记。
				if (node->left) st.push(node->left);    // 添加左节点（空节点不入栈）
			}
			else {  // 只有遇到空节点的时候，才将下一个节点放进结果集
				st.pop();   // 将空节点弹出
				node = st.top(); // 重新取出栈中元素
				st.pop();
				vec.push_back(node->val); // 加入到结果集
			}
		}
		return vec;
	}
};

class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        result = []
        st = []
        if root: st.append(root)

        while st:
            node = st.pop()
            if node:
                if node.right: st.append(node.right)
                st.append(node)
                st.append(None)
                if node.left: st.append(node.left)
            else:
                node = st.pop()
                result.append(node.val)
        return result

145. 二叉树的后序遍历 

class Solution {
public:
	vector<int> postorderTraversal(TreeNode* root) {
		vector<int> vec;
		stack<TreeNode*> st;
		if (root != nullptr) st.push(root);
		while (!st.empty()) {
			TreeNode* node = st.top();
			if (node != nullptr) {
				st.pop();

				st.push(node);
				st.push(nullptr);
				if (node->right) st.push(node->right);
				if (node->left) st.push(node->left);
			}
			else {
				st.pop();
				node = st.top();
				st.pop();
				vec.push_back(node->val);
			}
		}
		return vec;
	}
};

class Solution:
    def postorderTraversal(self, root: TreeNode) -> List[int]:
        result = []
        st = []
        if root: st.append(root)

        while st:
            node = st.pop()
            if node:
                st.append(node)
                st.append(None)
                if node.right: st.append(node.right)
                if node.left: st.append(node.left)
            else:
                node = st.pop()
                result.append(node.val)
        return result

2.2 层次遍历

层序遍历一个二叉树。就是从左到右一层一层的去遍历二叉树。需要借用一个辅助数据结构即队列来实现，队列先进先出，符合一层一层遍历的逻辑，而是用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。

这种层序遍历方式就是图论中的广度优先遍历，只不过我们应用在二叉树上。

迭代求法：

102. 二叉树的层序遍历 

class Solution {
public:
	vector<vector<int>> levelOrder(TreeNode* root) {
		queue<TreeNode*> que;
		if (root != nullptr) que.push(root);
		vector<vector<int>> result;
		while (!que.empty()) {
			// 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
			int size = que.size();
			vector<int> vec;
			for (int i = 0; i < size; i++) {
				TreeNode* node = que.front();
				que.pop();
				vec.push_back(node->val);

				if (node->left) que.push(node->left);
				if (node->right) que.push(node->right);
			}
			result.push_back(vec);
		}
		return result;
	}
};

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        result = []
        if not root: return result

        from collections import deque
        deq = deque([root])

        while deq:
            res = []
            n = len(deq)
            for i in range(n):
                node = deq.popleft()
                res.append(node.val)
                if node.left: deq.append(node.left)
                if node.right: deq.append(node.right)
            result.append(res)
        return result

这是一个模板！！！以下题目都可以用这个模板求解。

递归求法：

class Solution {
public:
	vector<vector<int>> levelOrder(TreeNode* root) {
		vector<vector<int>> result;
		traversal(root, 0, result);
		return result;
	}

	void traversal(TreeNode* root, int depth, vector<vector<int>>& vec) {
		if (root == nullptr) return;
		if (vec.size() == depth) vec.push_back({});
		vec[depth].push_back(root->val);
		if (root->left) traversal(root->left, depth + 1, vec);
		if (root->right) traversal(root->right, depth + 1, vec);
	}
};

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        result = []
        
        def helper(root, depth):
            if not root: return []
            if len(result) == depth: result.append([])
            result[depth].append(root.val)
            if root.left: helper(root.left, depth + 1)
            if root.right: helper(root.right, depth + 1)
        
        helper(root, 0)
        return result

107. 二叉树的层序遍历 II

给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

class Solution {
public:
	vector<vector<int>> levelOrderBottom(TreeNode* root) {
		vector<vector<int>> result;
		queue<TreeNode*> que;
		if (root != nullptr) que.push(root);
		while (!que.empty()) {
			int size = que.size();
			vector<int> vec;
			for (int i = 0; i < size; i++) {
				TreeNode* node = que.front();
				que.pop();
				vec.push_back(node->val);
				if (node->left) que.push(node->left);
				if (node->right) que.push(node->right);
			}
			result.push_back(vec);
		}
		reverse(result.begin(), result.end());
		return result;
	}
};

199. 二叉树的右视图

给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

class Solution {
public:
	vector<int> rightSideView(TreeNode* root) {
		vector<int> result;
		queue<TreeNode*> que;
		if (root != nullptr) que.push(root);
		while (!que.empty()) {
			int size = que.size();
			for (int i = 0; i < size; i++) {
				TreeNode* node = que.front();
				que.pop();
				if (node->left)que.push(node->left);
				if (node->right)que.push(node->right);
				if (i == size - 1) result.push_back(node->val);
			}
		}
		return result;
	}
};

637. 二叉树的层平均值

给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10-5 以内的答案可以被接受。

class Solution {
public:
	vector<double> averageOfLevels(TreeNode* root) {
		vector<double> vec;
		queue<TreeNode*> que;
		if (root != nullptr) que.push(root);
		while (!que.empty()) {
			int size = que.size();
			double sum = 0;
			for (int i = 0; i < size; i++) {
				TreeNode* node = que.front();
				que.pop();
				sum += node->val;
				if (node->left) que.push(node->left);
				if (node->right) que.push(node->right);
			}
			vec.push_back(sum / size);
		}
		return vec;
	}
};

429. N 叉树的层序遍历

给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。树的序列化输入是用层序遍历，每组子节点都由 null 值分隔。

// Definition for a Node.
class Node {
public:
	int val;
	vector<Node*> children;
	Node(){}
	Node(int val) :val(val) {}
	Node(int val, vector<Node*> children) :val(val), children(children) {}
};

class Solution {
public:
	vector<vector<int>> levelOrder(Node* root) {
		vector<vector<int>> result;
		queue<Node*> que;
		if (root != nullptr) que.push(root);
		while (!que.empty()) {
			int size = que.size();
			vector<int> vec;
			for (int i = 0; i < size; i++) {
				Node* node = que.front();
				que.pop();
				vec.push_back(node->val);
				for (vector<Node*>::iterator it = node->children.begin(); it != node->children.end(); it++) {
					if (*it != nullptr) {
						que.push(*it);
					}
				}
			}
			result.push_back(vec);
		}
		return result;
	}
};

515. 在每个树行中找最大值

给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。

class Solution {
public:
	vector<int> largestValues(TreeNode* root) {
		vector<int> vec;
		queue<TreeNode*> que;
		if (root != nullptr) que.push(root);
		while (!que.empty()) {
			int size = que.size();
			int max_num = INT32_MIN;
			for (int i = 0; i < size; i++) {
				TreeNode* node = que.front();
				que.pop();
				max_num = (max_num > node->val) ? max_num : node->val;
				if (node->left) que.push(node->left);
				if (node->right) que.push(node->right);
			}
			vec.push_back(max_num);
		}
		return vec;
	}
};

116. 填充每个节点的下一个右侧节点指针

给定一个 **完美二叉树 **，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：

struct Node {
    int val;
    Node *left;
    Node *right;
    Node *next;
}

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。初始状态下，所有 next 指针都被设置为 NULL。

class Node {
public:
	int val;
	Node* left;
	Node* right;
	Node* next;

	Node() : val(0), left(NULL), right(NULL), next(NULL) {}
	Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}
	Node(int _val, Node* _left, Node* _right, Node* _next)
		: val(_val), left(_left), right(_right), next(_next) {}
};

class Solution {
public:
	Node* connect(Node* root) {
		queue<Node*> que;
		if (root != nullptr) que.push(root);
		while (!que.empty()) {
			int size = que.size();
			Node* nodePre;
			Node* node;
			for (int i = 0; i < size; i++) {
				if (i == 0) {
					nodePre = que.front();
					que.pop();
					node = nodePre;
				}
				else {
					node = que.front();
					que.pop();
					nodePre->next = node;
					nodePre = nodePre->next;
				}
				
				if (node->left) que.push(node->left);
				if (node->right) que.push(node->right);
			}
			node->next = nullptr;
		}
		return root;
	}
};

117. 填充每个节点的下一个右侧节点指针 II

给定一个二叉树

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。初始状态下，所有 next 指针都被设置为 NULL。

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if (root != nullptr) que.push(root);
        while (!que.empty()) {
            int size = que.size();
            Node* nodePre;
            Node* node;
            for (int i = 0; i < size; i++) {
                if (i == 0) {
                    nodePre = que.front();
                    que.pop();
                    node = nodePre;
                }
                else {
                    node = que.front();
                    que.pop();
                    nodePre->next = node;
                    nodePre = nodePre->next;
                }
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            nodePre->next = nullptr;
        }
        return root;
    }
};

104. 二叉树的最大深度

给定一个二叉树，找出其最大深度。二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。说明: 叶子节点是指没有子节点的节点。

class Solution {
public:
	int maxDepth(TreeNode* root) {
		int depth = 0;
		queue<TreeNode*> que;
		if (root != nullptr) que.push(root);
		while (!que.empty()) {
			int size = que.size();
			depth++;
			for (int i = 0; i < size; i++) {
				TreeNode* node = que.front();
				que.pop();
				if (node->left) que.push(node->left);
				if (node->right) que.push(node->right);
			}
		}
		return depth;
	}
};

111. 二叉树的最小深度

给定一个二叉树，找出其最小深度。最小深度是从根节点到最近叶子节点的最短路径上的节点数量。说明：叶子节点是指没有子节点的节点。

class Solution {
public:
	int minDepth(TreeNode* root) {
		int depth = 0;
		queue<TreeNode*> que;
		if (root != nullptr) que.push(root);
		while (!que.empty()) {
			int size = que.size();
			depth++;
			for (int i = 0; i < size; i++) {
				TreeNode* node = que.front();
				que.pop();
				if (node->left) que.push(node->left);
				if (node->right) que.push(node->right);
				if (!node->left && !node->right) return depth;
			}
		}
		return depth;
	}
};

以上题解大多来自【代码随想录】，在此基础上做了一定总结，并附带一些自己的理解。

后续题目，随缘更新，有错误请指出！

END

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

Leetcode

算法

c

python

LeetCode：二叉树的遍历方式（13道经典题目） 的相关文章

随机推荐

  • JavaScript引擎，V8引擎的原理

    为什么需要JavaScript引擎 高级的编程语言都是需要转成最终的机器指令来执行 我们所编写的js无论h是交给浏览器或者node执行 最后都是需要被CPU执行的 CPU只认识自己的指令集 机器语言 才能被CPU所执行 所以我们需要js引擎

  • 关于ngx_rtmp_hls_append_sps_pps造成的hls: error appenging SPS/PPS NALs错误

    关于ngx rtmp hls append sps pps造成的hls error appenging SPS PPS NALs错误 一giao我哩giao 今天在调试同rtmp配合nginx推流的时候 发现推live可以推成功 结果在推h

  • 多因素认证与身份验证：分析不同类型的多因素认证方法，介绍如何在访问控制中使用身份验证以增强安全性

    随着数字化时代的到来 信息安全问题变得愈发重要 在网络世界中 用户的身份往往是保护敏感数据和系统免受未经授权访问的第一道防线 单一的密码已经不再足够 多因素认证 MFA 应运而生 成为提升身份验证安全性的重要工具之一 本文将深入探讨不同类型

  • rpm常用命令记录

    文章目录 1 常用rpm命令 2 rpm参数 1 常用rpm命令 rpm ivh xxx rpm 安装rpm rpm Uvh xxx rpm 升级rpm rpm e xxx rpm 删除rpm rpm qi xxx rpm 查看安装包的信息

  • node.js 数据实现分页问题(后端)

    最近在写项目时 碰到的问题 let arr let rows for let e 0 e

  • TCP 和 UDP 的 Socket 调用

    在网络层 Socket 函数需要指定到底是 IPv4 还是 IPv6 分别对应设置为 AF INET 和 AF INET6 另外 还要指定到底是 TCP 还是 UDP TCP 协议是基于数据流的 所以设置为 SOCK STREAM 而 UD

  • live555学习之一整体说明

    live555 是一套采用rtsp协议作为其核心 可以用来传输接收多媒体包括H264 H265 音频等多媒体数据的开源架构代码集 通过扩展一些类的方式 实现rtsp server 和client端的功能 并且提供源码 其源码 可以是从官网

  • python程序封装成exe_手把手教你给Python程序写图形界面，并且打包成exe文件

    环境配置 官网下载Python3 LZ的配置环境是Python3 6 PyCharm 2017 2 1 pip3 install PyQt5 下载PyQt5pip install PyQt5 tools i http pypi douban

  • 【嵌入式Linux】开发环境搭建

    一 概述 在进行某一个芯片平台开发前 一般都需要在电脑上安装一系列软件 然后在这些软件上阅读 编写 编译和调试在该平台上运行的代码 最后将编写好的代码通过某种方式烧录到该芯片的对应地址运行 在电脑上安装的这一系列软件的过程 就是开发环境的搭

  • Python数据类型——字符串、列表、元组

    文章目录 一 字符串 二 列表 三 元组 四 字符串 列表和元组的常用方法 一 字符串 在Python中 可以使用单引号或者双引号来创建字符串 单引号或者双引号没有任何区别 字符串也可以赋值给变量 字符串 str1 字符串 str2 字符串

  • Android Studio使用常见问题（一）

    一 无法成功build 1 出现如下错误 Error Unable to tunnel through proxy Proxy returns HTTP 1 1 400 Bad Request 2 原因分析 本地gradle版本与项目制定的

  • php代码学习（二）绕过空白过滤

    绕过空白过滤

  • 华为OD社招面试（技术二面完）--总结复盘

    2020年4月22日 华为OD社招面试复盘总结 一 华为OD简介 首先来解释一下什么是华为OD面试 OD一般是指的是华为的 外包 公司 比如像德科这种 网上其实有很多人都吐槽过这个招聘模式 因为招进去的人不直接是华为内部的人 挂在德科名下或

  • windows批处理：if else的踩坑点及排版优化

    参考 https www jianshu com p f0bde7d355a4 总结 见参考文章

  • python提取excel一列或多列数据另存为新表(1)

    系列文章目录 文章目录 系列文章目录 前言 一 python提取excel指定一列保存到新表 二 python提取excel指定两列保存到新表 总结 前言 一 python提取excel指定一列保存到新表 原数据举例如下 提取B列另存到新表

  • DFS深度优先搜索

    目录 一 DFS的概念 DFS的定义 DFS的搜索方式 DFS采用的数据结构 DFS的特点 二 DFS的实战应用 1 排列数字 2 n 皇后问题 一 DFS的概念 DFS的定义 DFS Depth First Search 深度优先搜索 是

  • 阈值分割法

    阈值分割法可以说是图像分割中的经典方法 它利用图像中要提取的目标与背景在灰度上的差异 通过设置阈值来把像素级分成若干类 从而实现目标与背景的分离 一般流程 通过判断图像中每一个像素点的特征属性是否满足阈值的要求 来确定图像中的该像素点是属于

  • chatGPT插件是什么，chatGPT插件作用介绍

    简介 openAI团队已经在 ChatGPT 中实现了对插件的初步支持 插件是专门为以安全为核心原则的语言模型设计的工具 可帮助 ChatGPT 访问最新信息 运行计算或使用第三方服务 目前体验与开发需要先加入等候名单 官网介绍链接 htt

  • java中如何导入同一个包下其他类文件中的方法，举个例子

    在 Java 中 可以使用 import 关键字导入同一个包下的其他类文件中的方法 例如 假设在同一个包 com example 下有两个类 ClassA 和 ClassB 那么可以在 ClassB 中导入 ClassA 中的方法 代码如下

  • LeetCode：二叉树的遍历方式（13道经典题目）

    LeetCode 二叉树的遍历方式 13道经典题目 本文带来与二叉树的遍历方法有关的经典题目 主要实现是C 144 二叉树的前序遍历 94 二叉树的中序遍历 145 二叉树的后序遍历 102 二叉树的层序遍历 107 二叉树的层序遍历 II

热门标签