二叉树迭代器算法

二叉树(Binary Tree)的前序、中序和后续遍历是算法和数据结构中的基本问题,基于递归的二叉树遍历算法更是递归的经典应用。

假设二叉树结点定义如下:

struct Node { 


    int value; 


    Node *left; 


    Node *right; 


} 
void inorder_traverse(Node *node) { 


    if (NULL != node->left) { 


        inorder_traverse(node->left); 


    } 


    do_something(node); 


    if (NULL != node->right) { 


        inorder_traverse(node->right); 


    } 


} 


 

前序和后序遍历算法类似。

但是,仅有遍历算法是不够的,在许多应用中,我们还需要对遍历本身进行抽象。假如有一个求和的函数sum,我们希望它能应用于链表,数组,二叉树等等不同的数据结构。这时,我们可以抽象出迭代器(Iterator)的概念,通过迭代器把算法和数据结构解耦了,使得通用算法能应用于不同类型的数据结构。我们可以把sum函数定义为:

int sum(Iterator it) 

链表作为一种线性结构,它的迭代器实现非常简单和直观,而二叉树的迭代器实现则不那么容易,我们不能直接将递归遍历转换为迭代器。究其原因,这是因为二叉 树递归遍历过程是编译器在调用栈上自动进行的,程序员对这个过程缺乏足够的控制。既然如此,那么我们如果可以自己来控制整个调用栈的进栈和出栈不是就达到 控制的目的了吗?我们先来看看二叉树遍历的非递归算法:

void inorder_traverse_nonrecursive(Node *node) { 


    Stack stack; 


    do { 


        // node代表当前准备处理的子树,层层向下把左孩子压栈,对应递归算法的左子树递归 


        while (NULL != node) { 


            stack.push(node); 


            node = node->left; 


        } 


        do { 


            Node *top = stack.top(); 


            stack.pop(); //弹出栈顶,对应递归算法的函数返回 


            do_something(top); 


            if (NULL != top->right) { 


                node = top->right; //将当前子树置为刚刚遍历过的结点的右孩子,对应递归算法的右子树递归 


                break; 


            } 


        } 


        while (!stack.empty()); 


    } 


    while (!stack.empty()); 


} 

通过基于栈的非递归算法我们获得了对于遍历过程的控制,下面我们考虑如何将其封装为迭代器呢? 这里关键在于理解遍历的过程是由栈的状态来表示的,所以显然迭代器内部应该包含一个栈结构,每次迭代的过程就是对栈的操作。假设迭代器的接口为:

class Iterator { 


    public: 


        virtual Node* next() = 0; 


}; 

下面是一个二叉树中序遍历迭代器的实现:

class InorderIterator : public Iterator { 


    public: 


        InorderIterator(Node *node) { 


            Node *current = node; 


            while (NULL != current) { 


                mStack.push(current); 


                current = current->left; 


            } 


        } 


        virtual Node* next() { 


            if (mStack.empty()) { 


                return NULL; 


            } 


            Node *top = mStack.top(); 


            mStack.pop(); 


            if (NULL != top->right) { 


                Node *current = top->right; 


                while (NULL != current) { 


                    mStack.push(current); 


                    current = current->left; 


                } 


            } 


            return top; 


         } 


    private: 


        std::stack<Node*> mStack; 


}; 

下面我们再来考察一下这个迭代器实现的时间和空间复杂度。很显然,由于栈中最多需要保存所有的结点,所以其空间复杂度是O(n)的。那么时间复杂度 呢?一次next()调用也最多会进行n次栈操作,而整个遍历过程需要调用n次next(),那么是不是整个迭代器的时间复杂度就是O(n^2)呢?答案 是否定的!因为每个结点只会进栈和出栈一次,所以整个迭代过程的时间复杂度依然为O(n)。其实,这和递归遍历的时空复杂度完全一样。

除了上面显式利用栈控制代码执行顺序外,在支持yield语义的语言(C#, Python等)中,还有更为直接的做法。下面基于yield的二叉树中序遍历的Python实现:

// Python 


def inorder(t): 


    if t: 


        for x in inorder(t.left): 


            yield x 


        yield t.label 


        for x in inorder(t.right): 


            yield x 

相关推荐