二叉樹的遍歷小結

二叉樹的遍歷小結

二叉樹的非遞歸方式有不同的寫法，今小結了前序、中序、後序三種遍歷方式，分別用一到兩種非遞歸方式寫出來，還是那句話，要重點理解其思想，還有會快速的實現出來

#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;
}