二叉树的遍历

二叉树的存储结构：

　　

struct BinaryTreeNode {
        int     val;
        BinaryTreeNode *left;
        BinaryTreeNode *right;

        BinaryTreeNode(int v, BinaryTreeNode *l = NULL, BinaryTreeNode *r = NULL): 
        val(v), left(l), right(r){}
    };

前序遍历：

　　根节点->左子树->右子树

　　

　　递归方法：

　　

void PreOrder(BinaryTreeNode* root) {
    if (root != NULL) {
        std::cout<<root->val；
        PreOrder(root->left);
        PreOrder(root->right);
    }
}

　　迭代方法：

　　

void PreOrder(BinaryTreeNode* root) {
    BinaryTreeNode* p = root;
    std::stack<BinaryTreeNode*> s;

    while (p!= NULL || !s.empty()) {
        if (p != NULL) {
            std::cout<<p->val;
            s.push(p);
            p = p->left;
        } else {
            p = s.top();
            s.pop();
            p = p->right;
        }
    }
}

中序遍历：

　　左子树->根节点->右子树

　　

　　递归方法：

　　

void InOrder(BinaryTreeNode *root) {
    if (root != NULL) {
        InOrder(root->left);
        std::cout<<p->val;
        InOrder(root->right);

    }
}

　　迭代方法：

　　

void Inorder(BinaryTreeNode* root) {
    BinaryTreeNode* p = root;
    std::stack<BinaryTreeNode*> s;

    while (p != NULL || !s.empty()) {
        if (p != NULL) {
            s.push(p);
            p = p->left;
        } else {
            p = s.top();
            std::cout<<p->val;
            s.pop();
            p=p->right;
        }
    }
}

后序遍历：

　　左子树->根节点->右子树

　　

　　递归方法：

　　

void Postorder(BinaryTreeNode* root) {
    if (root != NULL) {
        PostorderRecur(root->left);
        PostorderRecur(root->right);
        std::cout<<root->val;
    }
}

　　迭代方法：

　　因为后序非递归遍历二叉树的顺序是先访问左子树，再访问右子树，最后访问根节点。当用栈来保存节点，必须分清返回根节点时，是从左子树返回的，还是从右子树返回的。所以，使用辅助指针r，其指向最近访问过的节点。

void BinaryTree::Postorder() {
    BinaryTreeNode* p = root;
    BinaryTreeNode* r = NULL;
    std::stack<BinaryTreeNode*> s;

    while (p!= NULL && !s.empty()) {
        if (p != NULL) {
            s.push(p);
            p = p->left;
        } else {
            p = s.top();
            if (p->right != NULL && p->right != r) {
                p = p->right;16             
　　　　　　　　　} else {
                s.pop();
                std::cout<<p->val<<" ";
                r = p;
                p = NULL;
            }
        }
    }
}

层次遍历：

　　

void Levelorder() {
    BinaryTreeNode *p = root;
    std::queue<BinaryTreeNode*> q;

    if (p != NULL) {
        q.push(p);
    }

    while (!q.empty()) {
        p = q.front();
        q.pop();
        std::cout<<p->val;

        if (p->left != NULL) {
            q.push(p->left);
        }
        if (p->right != NULL) {
            q.push(p->right);
        }
    }
}