二叉树的遍历(递归，迭代，Morris遍历）

二叉树的遍历：

先序，中序，后序；

二叉树的遍历有三种常见的方法，

最简单的实现就是递归调用，

另外就是飞递归的迭代调用，

最后还有O(1)空间的morris遍历；

二叉树的结构定义：

struct TreeNode {
     int val;
     TreeNode *left;
     TreeNode *right;
     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 };

1.先序遍历：

递归：

void preOrderRecursive(TreeNode *root) {
    if (!root)
        return;
    cout << root->val << " ";
    preOrderRecursive(root->left);
    preOrderRecursive(root->right);
}

迭代：

迭代要用到栈来保存父亲结点，

先序遍历，所有访问过的结点都先输出，

先遍历当前结点和当前结点的左子树，一直到左子树的最左边的结点，

遍历过的这些结点都入栈，左孩子为空时，栈顶元素设为当前结点，出栈，

然后把当前结点设为该节点的右孩子，循环一直到当前结点为空且栈也为空。

void preOrderIterative(TreeNode *root) {
    if (!root)
        return;
    stack<TreeNode*> stk;
    TreeNode *cur = root;
    while (cur || !stk.empty()) {
        while (cur) {
            cout << cur->val << " ";
            stk.push(cur);
            cur = cur->left;
        }
        if (!stk.empty()) {
            cur = stk.top();
            stk.pop();
            cur = cur->right;
        }
    }
}
/* 
 * 模拟递归
 * */
void preOrderIterative1(TreeNode *root) {
    if (!root)
        return;
    stack<TreeNode*> stk;
    stk.push(root);
    while (!stk.empty()) {
        TreeNode* tp = stk.top();
        stk.pop();
        cout << tp->val << " ";
        if (tp->right) 
            stk.push(tp->right);
        if (tp->left)
            stk.push(tp->left);
    }
}

Morris方法：

1.当前结点的左孩子为空，输出当前结点，并设置当前结点的右孩子为当前结点；

2.当前结点的左孩子不为空：

　　a.找到当前结点中序遍历的前驱结点，即为该节点的左孩子的最右边的结点，前驱结点的右孩子为空，则设置前驱结点的右孩子为当前结点，并输出当前结点，设当前结点的左孩子为当前结点；

　　b.前驱结点的右孩子为当前结点，则恢复前驱结点的右孩子为NULL，设当前结点的右孩子为当前结点；

void preOrderMorris(TreeNode *root) {
    if (!root)
        return;
    TreeNode* cur = root;
    TreeNode* pre = NULL;
    while (cur) {
        if (cur->left == NULL) {
            cout << cur->val << " ";
            cur = cur->right;
        }
        else {
            pre = cur->left;
            while (pre->right != NULL && pre->right != cur) 
                pre = pre->right;
            if (pre->right == NULL) {
                cout << cur->val << " ";
                pre->right = cur;
                cur = cur->left;
            }
            else {
                pre->right = NULL;
                cur = cur->right;
            }
        }
    }
}

2.中序遍历：

递归：

void inOrderRecursive(TreeNode *root) {
    if (!root)
        return;
    inOrderRecursive(root->left);
    cout << root->val << " ";
    inOrderRecursive(root->right);
}

迭代：

1.如果当前结点的左孩子不为空，则把当前结点的左孩子入栈，知道当前结点的左孩子为空；

2.如果栈不为空，则出栈，栈顶元素为当前结点，输出当前结点，并把当前结点的右孩子设为当前结点；

重复1，2直到当前结点为NULL且栈也为空；

void inOrderIterative(TreeNode *root) {
    if (!root)
        return;
    stack<TreeNode*> stk;
    TreeNode *cur = root;
    while (cur || !stk.empty()) {
        while (cur) {
            stk.push(cur);
            cur = cur->left;
        }
        if (!stk.empty()) {
            cur = stk.top();
            stk.pop();
            cout << cur->val << " ";
            cur = cur->right;
        }
    }
}

Morris方法：

和先序遍历的过程类似，只不过输出结点的位置不一样，中序遍历是在2.b中，也就是前驱结点的右孩子为当前结点时，即当前结点的左子树都已经遍历完成时，输出当前结点；

void inOrderMorris(TreeNode *root) {
    if (!root)
        return;
    TreeNode* cur = root;
    TreeNode* pre = NULL;
    while (cur) {
        if (cur->left == NULL) {
            cout << cur->val << " ";
            cur = cur->right;
        }
        else {
            pre = cur->left;
            while (pre->right != NULL && pre->right != cur)
                pre = pre->right;
            if (pre->right == NULL) {
                pre->right = cur;
                cur = cur->left;
            }
            else {
                cout << cur->val << " ";
                pre->right = NULL;
                cur = cur->right;
            }
        }
    }
}

3.后序遍历：

递归：

void postOrderRecursive(TreeNode *root) {
    if (!root)
        return;
    postOrderRecursive(root->left);
    postOrderRecursive(root->right);
    cout << root->val << " ";
}

迭代：

后序遍历比先序、中序都要复杂，

第一种迭代方法，可以用两个栈来模拟递归的遍历；

栈1初始化时把根节点入栈，

1.栈1出栈，把出栈的元素加入栈2，然后把该元素的左孩子（如果不为空），右孩子（如果不为空）加入栈1，知道栈1为空；

2.栈2出栈直到空，每次出栈时输出栈顶元素；

通过两个栈，保证了栈2中的元素顺序，

第二种迭代方法，

用一个结点保存访问过的最后一个结点pre，如果pre为栈顶元素的右孩子，则说明栈顶元素的右子树已经遍历过了，直接输出栈顶元素，并把当前结点设为NULL，并更新pre为出栈的元素；

1.如果当前结点存在，则一直向左遍历，入栈遍历的元素，直到结点为空；

2.栈不为空时，出栈，当前结点为栈顶元素，

如果当前结点的右孩子不为空且不为pre，说明当前结点的右子树没有遍历过，设置当前结点为该节点的右孩子，

如果右孩子为空或者为pre，直接输出当前结点，更新pre为当前结点，并设当前结点为NULL，

重复1，2直到当前结点为NULL并且栈为空；

void postOrderIterative(TreeNode *root) {
    if (!root) 
        return;
    stack<TreeNode*> stk;
    TreeNode *cur = root;
    TreeNode *pre = NULL;
    while (cur || !stk.empty()) {
        while (cur) {
            stk.push(cur);
            cur = cur->left;
        }
        if (!stk.empty()) {
            cur = stk.top();
            if (cur->right != NULL && cur->right != pre) {
                cur = cur->right;
            }
            else {
                cout << cur->val << " ";
                pre = cur;
                stk.pop();
                cur = NULL;
            }
        }
    }
}
/*
 * 双栈法
 */
void postOrderIterative1(TreeNode *root) {
    if (!root) 
        return;
    stack<TreeNode*> stk1, stk2;
    TreeNode *cur;
    stk1.push(root);
    while (!stk1.empty()) {
        cur = stk1.top();
        stk1.pop();
        stk2.push(cur);
        if (cur->left)
            stk1.push(cur->left);
        if (cur->right)
            stk1.push(cur->right);
    }
    while (!stk2.empty()) {
        cout << stk2.top()->val << " ";
        stk2.pop();
    }
}

Morris方法：

morris方法的后序遍历较为复杂，因为需要逆序输出右孩子到父亲结点；

遍历过程与先序与中序类似，

当前驱结点的右孩子为当前结点时，左子树已经遍历完成，逆序输出当前结点的左孩子到前驱结点；

类似于链表的反转，不过反转输出之后，记得要反转回来。

void reverse(TreeNode *begin, TreeNode *end) {
    if (begin == end)
        return;
    TreeNode *pre = begin;
    TreeNode *cur = begin->right;
    TreeNode *next;
    while (pre != end) {
        temp = cur->right;
        cur->right = pre;
        pre = cur;
        cur = temp;
    }
}

void traversalReversal(TreeNode *begin, TreeNode *end) {
    reverse(begin, end);
    TreeNode *it = end;
    while (true) {
        cout << it->val << " ";
        if (it == begin)
            break;
        it = it->right;
    }
    reverse(end, begin);
}

void postOrderMorris(TreeNode *root) {
    if (!root)
        return;
    TreeNode dump(0);
    dump.left = root;
    TreeNode *cur = &dump;
    TreeNode *pre = NULL;
    while (cur) {
        if (cur->left == NULL) {
            cur = cur->right;
        }
        else {
            pre = cur->left;
            while (pre->right != NULL && pre->right != cur)
                pre = pre->right;
            if (pre->right == NULL) {
                pre->right = cur;
                cur = cur->left;
            }
            else {
                traversalReverse(cur->left, pre);
                pre->right = NULL;
                cur = cur->right;
            }
        }
    }
}

 参考：

http://www.cnblogs.com/AnnieKim/archive/2013/06/15/MorrisTraversal.html

http://blog.csdn.net/hackbuteer1/article/details/6583988