二叉树的遍历小结

二叉树的遍历小结

二叉树的非递归方式有不同的写法，今小结了前序、中序、后序三种遍历方式，分别用一到两种非递归方式写出来，还是那句话，要重点理解其思想，还有会快速的实现出来

#include<iostream>
#include<math.h>
#include<stack>

using namespace std;

/**
 *  二叉树相关
 */

struct Node {
    Node *lchild;
    Node *rchild;
    int value;
};

/**
 * 从数组建树
 * 输入：数组
 * 输出：一颗二叉树（小根堆）
 */

/**
 * 二叉查找树的插入操作
 * @param root  根节点
 * @param key 待插入的值
 * @return
 */
Node *insertNode(Node *root, int key) {
    if (root == NULL) {
        Node *p = new Node;
        p->value = key;
        p->lchild = NULL;
        p->rchild = NULL;
        return p;
    }
    if (key < root->value) {
        root->lchild = insertNode(root->lchild, key);
    } else if (key > root->value) {
        root->rchild = insertNode(root->rchild, key);
    }
    return root;
}

/**
 * 建立二叉查找树
 * @param a 输入数组
 * @param n 数组长度
 * @return 二叉查找树
 */
Node *createTree(int *a, int n) {
    Node *root = NULL;
    for (int i = 0; i < n; i++) {
        root = insertNode(root, a[i]);
    }
    return root;
}

/**
 * 前序遍历：递归形式
 */

void preOrder(Node *root) {
    if (root) {
        cout << root->value << " ";
        preOrder(root->lchild);
        preOrder(root->rchild);
    }
}

/**
 * 中序遍历：递归形式
 * @param root
 */
void inOrder(Node *root) {
    if (root) {
        inOrder(root->lchild);
        cout << root->value << " ";
        inOrder(root->rchild);
    }
}

/**
 * 后序遍历：递归形式
 * @param root
 */
void postOrder(Node *root) {
    if (root) {
        postOrder(root->lchild);
        postOrder(root->rchild);
        cout << root->value << " ";
    }
}

/**
 * 前序遍历：非递归形式 1
 * step 1：访问当前节点，当前节点的左孩子全部入栈；一直到没有左孩子
 * step 2：弹出栈顶节点，然后当前节点置为弹出元素右孩子，继续step 1
 *
 */
void preOrder1(Node *root) {
    if (root) {
        stack<Node *> s;
        while (s.size() != 0 || root) {
            while (root) {
                cout << root->value << " ";
                s.push(root);
                root = root->lchild;
            }
            if (s.size() != 0) {
                root = s.top();
                s.pop();
                root = root->rchild;
            }
        }
    }
}

/**
 * 前序遍历：非递归形式 2
 * 借助栈简化
 * step 1：根节点入栈
 * step 2：出栈，访问当前节点，当前节点右孩子入栈，然后当前节点左孩子入栈
 * 直至栈为空结束
 */

void preOrder2(Node * root){
    if(root){
        stack<Node*> s;
        s.push(root);
        while(s.size() != 0){
            root = s.top();
            cout<<root->value<<" ";
            s.pop();
            if(root->rchild){
                s.push(root->rchild);
            }
            if(root->lchild){
                s.push(root->lchild);
            }
        }
    }
}

/**
 * 中序遍历：非递归形式 1
 * step 1：当前节点的左孩子全部入栈，一直到没有左孩子
 * step 2：弹出栈顶节点，访问，然后当前节点置为弹出元素右孩子，继续step 1
 *
 */
void inOrder1(Node *root) {
    if (root) {
        stack<Node *> s;
        while (s.size() != 0 || root) {
            while (root) {
                s.push(root);
                root = root->lchild;
            }
            if (s.size() != 0) {
                root = s.top();
                cout << root->value << " ";
                s.pop();
                root = root->rchild;
            }
        }
    }
}

/**
 * 后序遍历：非递归形式 1
 * 使用一个节点栈和数据值栈
 * 1. 首先将当前节点的右孩子节点压入节点栈，同时将当年节点的值压入数据值栈
 * 2. 然后依次取节点栈，将当前节点置为节点栈顶的左孩子，然后继续step 1
 * 3. 一直到节点栈为空，然后依次遍历数据值栈
 * @return
 */

void postOrder1(Node *root) {
    if (root) {
        stack<Node *> nodeStack;
        stack<int> valueStack;
        while (root || nodeStack.size() != 0) {
            while (root) {
                nodeStack.push(root);
                valueStack.push(root->value);
                root = root->rchild;
            }
            root = nodeStack.top();
            nodeStack.pop();
            root = root->lchild;
        }
        while(valueStack.size()!= 0){
            cout<<valueStack.top()<<" ";
            valueStack.pop();
        }
    }
}

/**
 * 后序遍历：非递归形式 2
 * 后序遍历的顺序是：左 -> 右 -> 根，倒过来就是：根 -> 右 -> 左
 * 和前序遍历的区别在于左右子树的顺序相反，因此和前序非递归遍历几乎一样
 * 需要用到一个栈存放数据，因为数据顺序是倒的
 * @param root
 */
void postOrder2(Node * root){
    if(root){
        stack<Node*> nodeStack;
        stack<int> valueStack;
        nodeStack.push(root);
        while(nodeStack.size() != 0){
            root = nodeStack.top();
            valueStack.push(root->value);
            nodeStack.pop();
            if(root->lchild){
                nodeStack.push(root->lchild);
            }
            if(root->rchild){
                nodeStack.push(root->rchild);
            }
        }
        while(valueStack.size()!= 0){
           cout<<valueStack.top()<<" ";
           valueStack.pop();
        }
    }
}

int main() {
    int a[10] = {5, 3, 6, 1, 7, 9, 8, 0, 2, 4};
    Node *root = createTree(a, 10);
    postOrder(root);
    cout << endl;
    postOrder1(root);
    return 0;
}