谈一谈二叉搜索树中序迭代器的关键设计

之前在完成TinySTL项目中二叉搜索树的设计时发现要想完成其中序迭代器的设计,关键的一步是完成迭代器的++操作,当实现了这个操作时那么这个迭代器的90%的操作都可以很快的完成了。

下面先来看看node的定义:

        struct node{
            typedef T value_type;
            T data_;
            node *left_;
            node *right_;
            explicit node(T d = T(), node *l = 0, node *r = 0)
                :data_(d), left_(l), right_(r){}
        };

在二叉树中有:

下面来看看我是怎样实现++操作的。

首先是初始化迭代器:

 1         template<class T>
 2         bst_iter<T>::bst_iter(const T *ptr, cntrPtr container)
 3             :ptr_(ptr), container_(container){
 4             if (!ptr_)
 5                 return;
 6             auto temp = container_->root_;
 7             while (temp && temp != ptr_ && temp->data_ != ptr_->data_){
 8                 parent_.push(temp);
 9                 if (temp->data_ < ptr_->data_){
10                     //temp向右走说明temo指向的父节点不需要再次访问了
11                     visited_.insert(temp);//add 2015.01.14
12                     temp = temp->right_;
13                 }
14                 else if (temp->data_ > ptr_->data_){
15                     temp = temp->left_;
16                 }
17             }
18         }

在初始化的过程中传入任意的树中节点指针ptr,然后从root开始沿着向下的方向用一个栈parent_来依次记录节点的父节点,同时我用一个set visited_来记录父节点相对于这个节点来说是否是已经访问过的状态,当节点处于这个父节点的右子树中时这个节点被记录。根据中序遍历的定义来看,当要访问任意节点的下一个节点的时候,如果节点还有右子树未访问则跳转到右子树的最小节点,当节点没有右子树的时候我们需要沿着父节点的顺序后退,此时不是所有的父节点都需要访问的,只有当节点处于父节点的左子树时,此时这个父节点才需要访问。

 1         template<class T>
 2         bst_iter<T>& bst_iter<T>::operator ++(){
 3             visited_.insert(ptr_);//此node被访问
 4             if (ptr_->right_){//此node还有右子树
 5                 //rvisited_.insert(ptr_);
 6                 parent_.push(ptr_);
 7                 ptr_ = ptr_->right_;
 8                 while (ptr_ && ptr_->left_){
 9                     parent_.push(ptr_);
10                     ptr_ = ptr_->left_;
11                 }
12             }else{//node无右子树则只能向父节点路径移动
13                 ptr_ = 0;//add 2015.01.14
14                 while (!parent_.empty()){
15                     ptr_ = parent_.top();
16                     parent_.pop();
17                     if (visited_.count(ptr_) == 0){//父节点尚未访问,此时ptr_指向此节点
18                         visited_.insert(ptr_);
19                         break;
20                     }
21                     ptr_ = 0;//设为哨兵
22                 }//end of while
23             }//end of if
24             return *this;
25         }

第4-11行代码处理节点有右子树的情况。第12-23行代码处理节点无右子树需要向父节点移动的情况。

时间: 2024-12-24 06:46:54

谈一谈二叉搜索树中序迭代器的关键设计的相关文章

[LeetCode] 285. Inorder Successor in BST 二叉搜索树中的中序后继节点

Given a binary search tree and a node in it, find the in-order successor of that node in the BST. Note: If the given node has no in-order successor in the tree, return null. 给一个二叉搜索树和它的一个节点,找出它的中序后继节点,如果没有返回null. 解法1: 用中序遍历二叉搜索树,当找到root.val = p.val的时

二叉搜索树中的常用方法

1 package Tree; 2 3 import org.junit.Test; 4 5 class TreeNode { 6 7 int val = 0; 8 TreeNode left = null; 9 TreeNode right = null; 10 11 public TreeNode(int val) { 12 this.val = val; 13 14 } 15 16 } 17 18 public class BinarySearchTree { 19 20 /** 21 *

leetcode 二叉搜索树中第K小的元素 python

二叉搜索树中第K小的元素 给定一个二叉搜索树,编写一个函数 kthSmallest 来查找其中第 k 个最小的元素. 说明:你可以假设 k 总是有效的,1 ≤ k ≤ 二叉搜索树元素个数. 示例 1: 输入: root = [3,1,4,null,2], k = 1 3 / 1 4   2 输出: 1 示例 2: 输入: root = [5,3,6,2,4,null,null,1], k = 3 5 / 3 6 / 2 4 / 1 输出: 3 进阶:如果二叉搜索树经常被修改(插入/删除操作)并且

[Swift]LeetCode450. 删除二叉搜索树中的节点 | Delete Node in a BST

Given a root node reference of a BST and a key, delete the node with the given key in the BST. Return the root node reference (possibly updated) of the BST. Basically, the deletion can be divided into two stages: Search for a node to remove. If the n

230. 二叉搜索树中第K小的元素

230. 二叉搜索树中第K小的元素 题意 给定一个二叉搜索树,编写一个函数 kthSmallest 来查找其中第 k 个最小的元素. 你可以假设 k 总是有效的,1 ≤ k ≤ 二叉搜索树元素个数. 解题思路 中序遍历,利用Python3中提供的生成器方法: 中序遍历,判断存储结点值的数组是否到到k,则表明访问的一个结点就是第k个最小的元素: 先获取跟结点处于的位置(第几个最小的元素),如果它比k小,则从右子结点中找,如果它比k大,则从左子节点中找: 实现 class Solution:    

Leetcode 701. 二叉搜索树中的插入操作

题目链接 https://leetcode.com/problems/insert-into-a-binary-search-tree/description/ 题目描述 给定二叉搜索树(BST)的根节点和要插入树中的值,将值插入二叉搜索树. 返回插入后二叉搜索树的根节点. 保证原始二叉搜索树中不存在新值. 注意,可能存在多种有效的插入方式,只要树在插入后仍保持为二叉搜索树即可. 你可以返回任意有效的结果. 例如, 给定二叉搜索树: 4 / 2 7 / 1 3 和 插入的值: 5 你可以返回这个

算法dfs——二叉搜索树中最接近的值 II

901. 二叉搜索树中最接近的值 II 中文 English 给定一棵非空二叉搜索树以及一个target值,找到 BST 中最接近给定值的 k 个数. 样例 样例 1: 输入: {1} 0.000000 1 输出: [1] 解释: 二叉树 {1},表示如下的树结构: 1 样例 2: 输入: {3,1,4,#,2} 0.275000 2 输出: [1,2] 解释: 二叉树 {3,1,4,#,2},表示如下的树结构: 3 / 1 4 2 挑战 假设是一棵平衡二叉搜索树,你可以用时间复杂度低于O(n)

二叉搜索树中第K小的元素

给定一个二叉搜索树,编写一个函数 kthSmallest 来查找其中第 k 个最小的元素. 说明:你可以假设 k 总是有效的,1 ≤ k ≤ 二叉搜索树元素个数. 示例 1: 输入: root = [3,1,4,null,2], k = 1 3 / 1 4   2 输出: 1 示例 2: 输入: root = [5,3,6,2,4,null,null,1], k = 3 5 / 3 6 / 2 4 / 1 输出: 3 一个中序遍历的搜索,递归或者栈. /** * Definition for a

【剑指Offer-树】二叉搜索树中的众数

题目描述 给定一个有相同值的二叉搜索树(BST),找出 BST 中的所有众数(出现频率最高的元素). 假定 BST 有如下定义: 结点左子树中所含结点的值小于等于当前结点的值 结点右子树中所含结点的值大于等于当前结点的值 左子树和右子树都是二叉搜索树 示例: 例如: 给定 BST [1,null,2,2], 1 2 / 2 返回[2]. 题目链接: https://leetcode-cn.com/problems/find-mode-in-binary-search-tree/ 思路 二叉搜索树