[leetcode]173. Binary Search Tree Iterator

最新推荐文章于 2025-02-03 15:37:10 发布

xiaocong1990

最新推荐文章于 2025-02-03 15:37:10 发布

阅读量191

点赞数

CC 4.0 BY-SA版权

分类专栏： leetcode

本文链接：https://blog.youkuaiyun.com/xiaocong1990/article/details/60138414

leetcode 专栏收录该内容

473 篇文章

订阅专栏

本文介绍了一种二叉搜索树(BST)迭代器的实现方法，该迭代器可在平均O(1)的时间复杂度内返回BST中的下一个最小值，并使用O(h)的空间复杂度，其中h为树的高度。提供了三种不同的实现方案，包括利用栈进行中序遍历的迭代器设计。

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

题目链接：https://leetcode.com/problems/binary-search-tree-iterator/?tab=Description

Implement an iterator over a binary search tree (BST). Your iterator will be initialized with the root node of a BST.

Calling next() will return the next smallest number in the BST.

Note: next() and hasNext() should run in average O(1) time and uses O(h) memory, where h is the height of the tree.

方法一：

class BSTIterator {
public:
    BSTIterator(TreeNode *root) {
        while(root)
        {
            stk.push(root);
            root=root->left;
        }
    }

    /** @return whether we have a next smallest number */
    bool hasNext() {
        if(!stk.empty())
        {
            TreeNode* top=stk.top();
            stk.pop();
            nextmin=top->val;
            TreeNode* cur=top->right;
            if(cur)
            {
                stk.push(cur);
                cur=cur->left;
                while(cur)
                {
                    stk.push(cur);
                    cur=cur->left;
                }
            }
            return true;
        }
        else
            return false;

    }

    /** @return the next smallest number */
    int next() {
        return nextmin;
    }
private:
    stack<TreeNode *> stk;
    int nextmin;

};

方法二：

class BSTIterator {  
public:  
    BSTIterator(TreeNode *root) {  
        while(root)  
        {  
            stk.push(root);  
            root=root->left;  
        }  
    }  
  
    /** @return whether we have a next smallest number */  
    bool hasNext() {  
        if(!stk.empty())  
        {  
            TreeNode* top=stk.top();  
            stk.pop();  
            nextmin=top->val;  
            TreeNode* cur=top->right;  
            while(cur)  
            {  
                stk.push(cur);  
                cur=cur->left;  
            }  
            return true;  
        }  
        else  
            return false;  
  
    }  
  
    /** @return the next smallest number */  
    int next() {  
        return nextmin;  
    }  
private:  
    stack<TreeNode *> stk;  
    int nextmin;  
  
};

方法三：

lass BSTIterator{
public:
    BSTIterator(TreeNode *root){
        bucket=inordertraverse(root);
    }

    bool hasNext(){
        if(k<bucket.size())
            return true;
        return false;
    }

    int next(){
        return bucket[k++];
    }
private:
    vector<int> bucket;
    int k=0;
    vector<int> inordertraverse(TreeNode *root)
    {
        vector<int> res;
        stack<TreeNode*> sta;
        TreeNode *p=root;
        while(p!=NULL || !sta.empty())
        {
            while(p!=NULL)
            {
                sta.push(p);
                p=p->left;
            }
            if(!sta.empty())
            {
                TreeNode *tmp=sta.top();
                res.push_back(tmp->val);
                sta.pop();
                p=tmp->right;
            }
        }
        return res;
    }
};