二叉树叶子节点迭代器

开始的想法是先将叶子节点放入到一个vector中，然后依次next

下面的解法类似，但是只有在Next操作时才寻找下一个叶子节点

template <typename T>
class Iterator
{
        public:
        Iterator(T *root)
        {
                if(root == NULL) return;
                st.push(root);
                probe();
        }
        bool hasNext() { return (st.size() > 0); }
        T *next()
        {
                T *node = st.top();
                st.pop();
                if(!st.empty())
                        probe();
                return node;
        }
        private:
        stack<T *> st;
        bool leaf(T *node)
        {
                return (node->leftChild() == NULL && node->rightChild() == NULL);
        }
        void probe()
        {
                T *now = st.top();
                while(!leaf(now)) {
                        st.pop();
                        if(now->rightChild())
                                st.push(now->rightChild());
                        if(now->leftChild())
                                st.push(now->leftChild());
                        now = st.top();
                }
        }
};

不用空间的方法是，记录上一次迭代到的叶子节点curr, 下一个叶子节点必须是经过curr的下一个叶子节点

struct NODE 
{
        int nVal;
        NODE* pLft;
        NODE* pRgt;

        NODE(int n) : nVal(n), pLft(NULL), pRgt(NULL)
        {}
};

void _inner_get_next(NODE* pNode, NODE* pIter, bool& bFlag, NODE*& pNext)
{
        if (NULL == pNode) return;
        _inner_get_next(pNode->pLft, pIter, bFlag, pNext);

        if (NULL != pNext) return;
        if (bFlag && NULL == pNode->pLft && NULL == pNode->pRgt)
        {
                pNext = pNode;
                return;
        }

        if (pIter == pNode) bFlag = true;

        _inner_get_next(pNode->pRgt, pIter, bFlag, pNext);
}

NODE* GetNext(NODE* pRoot, NODE* pIter)
{
        if (NULL == pRoot || NULL == pIter)
                return NULL;

        NODE* pNext = NULL;
        bool bFlag = false;
        _inner_get_next(pRoot, pIter, bFlag, pNext);

        return pNext;
}