BST即搜索二叉树中序遍历的三种方法（两种递归，一种栈迭代）

最新推荐文章于 2025-01-24 11:46:34 发布
最新推荐文章于 2025-01-24 11:46:34 发布
阅读量455 收藏 1
点赞数 1
文章标签： 二叉树 java 数据结构 redis leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/EdwardWH/article/details/107074178
版权
本文详细介绍了搜索二叉树（BST）的中序遍历方法，包括两种递归方式和一种栈迭代实现。通过具体代码展示，从简单的Node类递归到传入root节点的递归方法，再到栈迭代的复杂实现，帮助读者深入理解BST的遍历操作。

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

1、Node类中建立的递归（Easy）：

见toString和Node.class中的inOrder方法

package tree;

import java.util.ArrayList;
import java.util.Deque;
import java.util.LinkedList;
import java.util.List;


/**
 * 排序二叉树
 * 		E extends Comparable<E>指的是
 * 		E这个类型要实现Comparable接口，这样方便比较大小
*@author  Edward
*@date  2020年7月1日---上午11:33:51
*/
public class Tree <E extends Comparable<E>>{
   
	// root存放根节点的引用
	private Node root;
	public Node getRoot() {
   
		return root;
	}

	public void setRoot(Node root) {
   
		this.root = root;
	}
	/*
	 *  Node类用于描述二叉树中的某个节点，其中，
	 *  data用于存放数据（元素）,left和right分别
	 *  存放其左右子树的引用。
	 */
	class Node{
   
		E data;
		Node left;
		Node right;
		Node(E e) {
   
			data = e;
		}
		public boolean append(E e) {
   
			// 相等不用添加（排序二叉树不允许重复元素）
			if (data.compareTo(e)==0) {
   
				return false;
			}
			
			// 如果要添加的元素比根节点元素小，则添加到左子树
			if (data.compareTo(e
最低0.47元/天 解锁文章
EdwardWH
关注
中序遍历BST的算法及实现
愿君出走半生，归来时仍是少年
07-15 1010
问题描述：在二叉树中，一个节点的后续是在中序遍历过程中，在它之后访问的下一个节点，如果某节点是中序遍历的最后一个节点，那么它的后续为 NULL。 在 BST 中，给定节点的后续节点就是大于该节点的最小结点，这个性质对于查找比某元素大的下一个元素时非常有用。 如上图，8 的后续是 10，10 的后续是 12，14 的后续是 20。 现给定一个节点，请设计算法查找中序遍历中，该节点的后续节点。 解法一：使用双亲指针 这种解法需要每个节点都有指向双亲的指针，算法可分成两种情况来处理： （1）.
中序遍历的三种方式(递归，非递归，非递归常数空间)
lovekjl的博客
09-14 3856
目录 1.递归：思路与算法 2.非递归(使用栈来模拟递归):思路与算法 3.非递归的常数空间：思路与算法 1.递归：思路与算法 首先我们需要了解什么是二叉树的中序遍历：按照访问左子树——根节点——右子树的方式遍历这棵树，而在访问左子树或者右子树的时候我们按照同样的方式遍历，直到遍历完整棵树。因此整个遍历过程天然具有递归的性质，我们可以直接用递归函数来模拟这一过程。 class Solution { public List<Integer> middleTraversa.
BST中序遍历（Iterative）
ToBeTrue
03-19 4364
首先来看下 recursive 的版本： void inorder(TreeNode* node) { if (node != NULL) { inorder(node->left); //左子树 print(node->val); //当前节点 inorder(node->right); //右子树
java bst的中序遍历
weixin_38038479的博客
07-21 374
直接上代码，仅递归实现了BST的插入，递归与循环方式实现了中序遍历；`import java.util.Stack; public class BinarySearchTree { class TreeNode { K value; TreeNode leftChild; TreeNode rightChild; boolean hasPrint = false; public TreeNode(K value, TreeNode<K> leftChild, TreeNode<K&
中序遍历二叉树（关键词：树/二叉树/中序遍历/中根遍历/中序搜索/中根搜索）
Henry1991back的博客
12-10 579
中序遍历二叉树 递归算法 def inorderTraversal(root): f = self.inorderTraversal return f(root.left)+[root.val]+f(root.right) if root else [] 非递归算法 def inorderTraversal(root): stack, res = [(root, False)], [] ...
C语言经典算法之二叉树的中序遍历(递归实现)
weixin_56154577的博客
01-30 2438
二叉树的中序遍历（Inorder Traversal）是深度优先遍历策略的一种，对于一个二叉搜索树（BST），中序遍历可以得到一个递增的有序序列。
js代码-二叉树中序遍历
07-15
在JavaScript中实现二叉树的中序遍历，一般有两种方法：递归和非递归（迭代）。 1. **递归实现**： 递归是最直观的方式，通过在函数内部调用自身来完成遍历。以下是一个简单的递归实现： ```javascript ...
94.二叉树的中序遍历 python
sysu63的博客
01-24 299
中序遍历（Inorder Traversal）是二叉树的一种遍历方式，其遍历顺序为：先访问左子树，然后访问根节点，最后访问右子树。对于每个子树来说，也是遵循相同的访问顺序。这种遍历方法特别适用于二叉搜索树（BST），因为在BST中进行中序遍历会按照升序访问节点。给定一个二叉树的根节点 root ，返回 它的 中序 遍历。输入：root = [1,null,2,3]树中节点数目在范围 [0, 100] 内。输入：root = [1]输入：root = []输出：[1,3,2]
js代码-11.3 中序遍历（迭代）
07-16
中序遍历有三种常见实现方式：递归、栈辅助的非递归（迭代）和 Morris遍历。这里我们重点讨论迭代方法，即标题提到的“js代码-11.3 中序遍历（迭代）”。 在迭代中序遍历的过程中，我们可以利用一个栈来帮助我们...
【二叉树】BST中序遍历【99. Recover Binary Search Tree】
wlxsq的专栏
07-14 442
题目链接：https://leetcode.com/problems/recover-binary-search-tree/#/description /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *righ
BST(或者普通树)的中序遍历非递归版本
lizhi389的专栏
11-19 1857
写了一下中序的迭代版本。用了昨天的BST测试了一下。对栈的使用得深刻理解。 void inorder(BSTnode* root) { BSTnode* p = root; sq.push_back(p); p = p->m_left; while(!sq.empty()) { while(p) { sq.push_back(p); p = p->m_left;
BST树 非递归中序遍历 | 中序线索化 | AVL树
专注于C/C++/Linux领域创作
04-14 303
带父指针的BST树。 typedef int Type; typedef struct BSTreeNode{ Type key; // 关键字(键值) struct BSTreeNode *left; // 左孩子 struct BSTreeNode *right; // 右孩子 struct BSTreeNode *parent; // 父结点 }BstNode, *BSTree; BstNode * First(BstNode *
二叉搜索树(BST)与中序遍历-Leetcode 94, 98, 501
weixin_43260026的博客
03-27 278
二叉树的中序遍历(Inorder Traversal) 递归法 class Solution { public List <Integer> inorderTraversal(TreeNode root) { List <Integer> res = new ArrayList <> (); helper(root, re...
BST树的经典问题——前、中、后序遍历
weixin_44836685的博客
07-04 1939
BST树的经典问题——前、中、后序遍历 树的前中后序遍历是三种遍历打印BST的方式。 1、前序遍历是先打印根节点开始继续向下。先打印父节点，再以前序遍历的方式遍历下面的节点 如图是一个BST树，现在当对他进行前序遍历的时候，应该打印出如下数组 58 23 12 18 35 47 82 69 74 87 95 前序遍历特点：每一次都是先对根节点进行打印，即可以判断其根节点 代码实现如下： publ...
BST/二叉树层序遍历
Peggy_Chang的博客
03-17 696
利用队列的FIFO特性来实现层序遍历。 初始化：创建队列q，root入队。 只要队列不为空：存队首元素，把队首元素pop出来，打印队首元素。判断它是否有左孩子，如果有，则左孩子入队；判断是否有右孩子，如果有，则右孩子入队（先判断左孩子再右孩子是因为这里一层中遍历假定从左到右）。 有点像利用栈的前序遍历，但是栈是LIFO，因此假如要进行前序遍历，则入栈的时候是先判断并入右孩子”go” comm...
中序遍历
xxlucas的博客
08-16 5544
中序遍历是十分重要的遍历算法。针对ＢＳＴ而言，中序遍历给定了一个次序，将二叉树变成了一种线性结构，而且正好是升序排列（在ＢＳＴ中，语义规范不存在关键值相同的节点）。 仿照先序遍历的递归版 template<typename T,typename VST>void travIn_R(BinNodePosi(T) x,VST& visit){ if(!x) return; travIn_
leetcode-二叉搜索树-BST-【中序遍历 、升序遍历、降序遍历】
catgray的博客
10-27 966
2022年10月27日 14点18分二叉搜索树并不算复杂，但它可以算是数据结构领域的半壁江山，直接基于 BST 的数据结构有 AVL 树，红黑树等等，拥有了自平衡性质，可以提供 logN 级别的增删查改效率；还有 B+ 树，线段树等结构都是基于 BST 的思想来设计的。
二叉树前中后序遍历——迭代和栈方式实现
热门推荐
1024
03-08 1万+
二叉树前中后序遍历——迭代和栈方式实现用递归实现三种遍历方式只需改变递归顺序就可以实现任一顺序的遍历。而使用栈方式，则不同情况需要进行不同的考虑。首先，定义一个简单的二叉树节点的数据结构类：class Node {    int val;    Node left;    Node right;    public Node(int val) {        this.val = val;   ...
二叉搜索树 (BST) 的创建以及遍历
波波诸葛伟
12-10 730
  https://www.cnblogs.com/yaolin1228/p/7820515.html 二叉搜索树(Binary Search Tree) ： 属于二叉树，其中每个节点都含有一个可以比较的键（如需要可以在键上关联值）， 且每个节点的键都大于其左子树中的任意节点而小于右子树的任意节点的键。 1、BST 的总体结构： 主要的几种变量以及方法如上图所示，主要有插入、排序、删除...
搜索二叉树中序遍历
最新发布
04-16
<think>好的，用户想了解二叉搜索树中序遍历的实现和原理。首先，我需要回顾一下中序遍历的基本概念，以及它在二叉搜索树中的特殊作用。根据之前的回答和引用内容，中序遍历二叉搜索树会得到一个升序序列，这是由二叉搜索树的性质决定的。 用户提供的引用中有多个关于中序遍历的实现，包括递归和非递归的方法，比如使用栈来模拟递归过程。例如，引用2中的Java代码通过栈实现了中序遍历，并在遍历过程中检查序列是否升序，从而验证是否为有效的二叉搜索树。引用5则展示了C++中使用栈的非递归实现。 接下来，我需要整理这些信息，确保覆盖递归和非递归两种实现方式，并解释其原理。同时，要强调中序遍历在二叉搜索树中的应用，比如验证BST的有效性、合并两棵BST的元素等，这些在引用3和引用4中都有提到。 用户可能想知道为什么中序遍历的结果是升序的，这需要联系二叉搜索树的定义：左子树节点值小于根，根小于右子树节点值。因此，按照左-根-右的顺序遍历，自然形成升序序列。 还需要注意用户可能存在的疑问，例如中序遍历的时间复杂度和空间复杂度，以及如何处理非递归实现中的栈操作。此外，引用4中的例子展示了如何结合中序遍历和归并排序来合并两棵BST的元素，这也是一个实际应用，可以适当提及。 最后，确保回答结构清晰，分点说明实现方法和原理，并给出代码示例，同时解答相关问题，比如应用场景和性能分析。需要检查引用是否正确对应，例如引用2和5提供了具体的代码实现，引用1、3解释了BST的性质，引用4展示了应用实例。</think>#### 二叉搜索树中序遍历的实现与原理详解 --- ### 一、中序遍历核心原理 **二叉搜索树（BST）的中序遍历特性**： 由于BST遵循 **左子树节点值 < 根节点值 < 右子树节点值** 的规则，**中序遍历（左-根-右）** 会按升序输出所有节点值。这是验证BST有效性（引用[2][^2]、[3][^3]）和提取有序数据的基础。 **数学表达**： 若BST的中序遍历序列为$[a_1, a_2, ..., a_n]$，则满足： $$ a_1 < a_2 < ... < a_n $$ --- ### 二、中序遍历实现方法 #### 1. 递归实现（直接体现遍历逻辑） ```cpp void InOrder(Node* root) { if (root == nullptr) return; InOrder(root->left); // 遍历左子树 cout << root->key << " "; // 访问根节点 InOrder(root->right); // 遍历右子树 } ``` - **原理**：通过递归隐式维护调用栈，天然实现左-根-右的顺序。 - **时间复杂度**：$O(n)$，每个节点访问一次。 - **空间复杂度**：$O(h)$（$h$为树高，递归栈深度）[^5]。 #### 2. 非递归实现（显式用栈模拟递归） ```cpp void InOrder_NonRecursive(Node* root) { stack<Node*> stk; Node* cur = root; while (!stk.empty() || cur != nullptr) { // 向左遍历到底，模拟递归压栈 while (cur != nullptr) { stk.push(cur); cur = cur->left; } // 弹栈访问节点，转向右子树 Node* top = stk.top(); stk.pop(); cout << top->key << " "; cur = top->right; } } ``` - **核心步骤**： 1. **压栈左链**：将左子树节点全部入栈，直到最左叶子。 2. **弹栈访问**：栈顶节点为当前最小未访问节点。 3. **转向右子树**：处理右子树的左链（循环回到步骤1）。 - **优势**：避免递归栈溢出风险，适用于深度较大的树[^5]。 --- ### 三、中序遍历核心应用 #### 1. 验证BST有效性（引用[2][^2]） - **实现逻辑**：中序遍历时记录前驱节点值，若当前节点值 ≤ 前驱值，则树无效。 - **代码片段（Java）**： ```java public boolean isValidBST(TreeNode root) { Deque<TreeNode> stack = new LinkedList<>(); double prev = -Double.MAX_VALUE; // 初始化为极小值 while (!stack.isEmpty() || root != null) { while (root != null) { // 压左链 stack.push(root); root = root.left; } root = stack.pop(); if (root.val <= prev) return false; // 检查升序 prev = root.val; root = root.right; // 转向右子树 } return true; } ``` #### 2. 合并两棵BST（引用[4][^4]） - **步骤**： 1. 对两棵树分别中序遍历，得到两个升序列表。 2. 使用归并排序合并两个有序列表，时间复杂度优化至$O(m+n)$。 - **应用场景**：数据库多索引联合查询、日志时间戳合并。 --- ### 四、性能与优化 | 实现方式 | 时间复杂度 | 空间复杂度 | 适用场景 | |-------------|------------|------------------|------------------------| | 递归 | $O(n)$ | $O(h)$（栈深度） | 树高较小、代码简洁场景 | | 非递归（栈）| $O(n)$ | $O(h)$（显式栈） | 避免栈溢出、需控制内存 | --- ### 五、相关问题 1. **如何通过中序遍历实现BST的升序迭代器？** - 参考非递归实现，用栈维护遍历状态，每次调用`next()`时弹栈并处理右子树。 2. **中序遍历能否用于BST的降序输出？** - 调整遍历顺序为 **右-根-左**，即可得到降序序列。 3. **中序遍历在红黑树中的应用有何不同？** - 红黑树本质是平衡BST，中序遍历逻辑相同，但插入/删除后需通过旋转维护平衡性[^1]。 --- [^1]: 二叉搜索树性质与平衡树基础 [^2]: 中序遍历验证BST有效性 [^4]: 中序遍历合并两棵BST [^5]: 非递归中序遍历栈实现
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值