在BST中实现前向迭代器

什么是BST

BST(Binary Search Tree)是一种基于二分查找的数据结构，它满足以下性质：

1. 每个节点最多有两个子节点
2. 左子树中所有节点的值小于等于节点的值
3. 右子树中所有节点的值大于等于节点的值
4. 没有重复的节点

由于BST的性质，我们可以使用BST来实现有序集合和有序映射等数据结构。

什么是前向迭代器

前向迭代器是一种迭代器，它可以遍历一个集合，并按照一定的顺序访问其中的元素。在BST中，前向迭代器按照节点值的递增顺序访问集合中的元素。

如何实现前向迭代器

在BST中实现前向迭代器需要进行以下步骤：

1. 定义一个指针类型，用于指向当前节点
2. 实现迭代器的构造函数，将指针指向根节点
3. 实现迭代器的'++'运算符重载函数，将指针指向下一个节点

下面是实现前向迭代器的代码：

template<typename T>
class BST {
private:
    struct Node {
        T val;
        Node *left;
        Node *right;
        Node(T x) : val(x), left(nullptr), right(nullptr) {}
    };

public:
    // BST的其它成员函数

    class Iterator; // 前向迭代器

    // 前向迭代器的定义
    class Iterator {
    private:
        Node *cur;

    public:
        Iterator() : cur(nullptr) {}

        Iterator(Node* node) : cur(node) {}

        T operator*() { return cur->val; }

        bool operator==(const Iterator& other) const { return cur == other.cur; }

        bool operator!=(const Iterator& other) const { return cur != other.cur; }

        Iterator& operator++() {
            if (cur->right != nullptr) {
                cur = cur->right;
                while (cur->left != nullptr) {
                    cur = cur->left;
                }
            } else {
                Node *p = cur->parent;
                while (p != nullptr && p->right == cur) {
                    cur = p;
                    p = cur->parent;
                } 
                cur = p;
            }
            return *this;
        }

        friend class BST;
    };

    // BST的其它成员函数

    Iterator begin() {
        if (root == nullptr) {
            return Iterator(nullptr);
        }
        Node *cur = root;
        while (cur->left != nullptr) {
            cur = cur->left;
        }
        return Iterator(cur);
    }

    Iterator end() {
        return Iterator(nullptr);
    }

    // BST的其它成员变量

private:
    Node *root;

};

如何使用前向迭代器

使用前向迭代器需要进行以下步骤：

1. 构建BST
2. 创建前向迭代器，并将其初始化为BST的'begin'迭代器
3. 使用'++'运算符访问下一个节点，直到到达末尾

下面是使用前向迭代器的代码：

#include "BST.h"
#include <iostream>

using namespace std;

int main() {
    BST<int> bst;
    bst.insert(3);
    bst.insert(1);
    bst.insert(4);
    bst.insert(2);
    bst.insert(5);

    for (auto it = bst.begin(); it != bst.end(); ++it) {
        cout << *it << " ";
    }
    cout << endl;

    return 0;
}

输出结果为：'1 2 3 4 5'

总结

通过实现前向迭代器，我们可以方便地遍历BST中的元素。由于BST的性质，我们可以保证遍历的元素是按照值的递增顺序访问的。使用前向迭代器，我们可以完成很多基于BST的算法，例如搜索、排序和统计等等。