后序线索化二叉树

void Tree::_postTree(Node * root, Node *&pre) {
    if (root == NULL) {        // 空值不操作
        return;
    }
    else {
        _postTree(root->lchild, pre);    // 递归左树，首先是递归到左子树的最左下的结点
        _postTree(root->rchild, pre);    // 递归右树，首先是递归到左子树的最左下的第一个右结点
        // 对当前结点进行操作，只对含有空指针的结点指针域操作
        if (root->lchild == NULL) {        // 左孩子为空，操作的是前驱，前驱是 pre
            root->ltag = nChild;
            root->lchild = pre;
        }
        // 首先要判断 pre 是否为空，后才能判断他的指针域，因为第一次的 pre在未执行下面语句 pre = root 时是NULL 值， 指针为 NULL值的没有访问其他内存空间的权限
        if (pre != NULL && pre->rchild == NULL) {    // 右孩子为空，操作的是后继， pre是前驱的话，那么root不就是后继吗？
            pre->rtag = nChild;
            pre->rchild = root;
        }
        pre = root;
    }
}

void Tree::Show_postTree(Node * root) {
    cout << "后序线索化遍历(最大使用栈暂存元素个数 100)：";
    Node * Stack[100];    // 后序遍历需要用到栈，所以该方法有局限性
    int top = -1;
    Node * p = root;
    Node * pre = NULL;            // 作为前驱，保留上一次访问过的指针域
    do {
        while (p != NULL) {        // 将当前结点的左孩子全部入栈，一直走到最左边的左孩子
            Stack[++top] = p;
            p = p->lchild;
            if (p == pre) {        // 防止对叶子结点操作中， p = p->rchild 导致 p 不为 NULL, 在执行上面一条语句 p = p->lchild时再次访问了已访问过的结点
                break;
            }
        }
        p = Stack[top];            // 将 p 指向栈顶指针域，进行操作当前结点
        if (p->rtag == nChild || p->rchild == pre) {    // 当前结点没有右孩子 或者 它的右孩子已经被访问过
            cout << p->data << " ";
            top--;        // 输出一个结点，就出栈一个指针域
            pre = p;
            p = NULL;    // p 为 NULL，目的是为了使其不满足第一个while，防止再次访问已访问过的结点，转去操作下一个结点
        }
        else {
            p = p->rchild;
        }
    } while (top != -1 && pre != NULL);
    cout << endl;
}

Tree::~Tree() {
    Node * Queue[100];
    int rear = -1, front = -1;
    if(root != NULL) {
        Queue[++rear] = root;
    } 
    Node * p = NULL;
    while (rear != front) {
        p = Queue[front+1];
        if(p->ltag == Child) {            // 有左孩子就进队，没有就不管，判断有无孩子 是看它的标志
            Queue[++rear] = p->lchild;
        }
        if(p->rtag == Child) {            // 有右孩子入队
            Queue[++rear] = p->rchild;
        }
        cout << "析构：" << p->data << endl;
        delete p;                        // 删除队头所指向的那一块存储空间
        front++;                        // 出队一个 front+1
    }
    system("pause");
}

#include <iostream>
using namespace std;

enum flag{ Child, nChild };    // Child 表示有孩子 nChild 即 not Child 没有孩子

struct Node {
    char data;
    Node * lchild;
    Node * rchild;
    flag ltag, rtag;    // Child 表示是左或右孩子  nChild 表示前驱或后继
};

class Tree {
public:
    Tree();
    ~Tree();
    Node * getRoot();
    void Show_postTree(Node *);    // 后序遍历输出
private:
    Node * root;
    Node * Create();                    // 供构造函数调用初始化二叉树
    void _postTree(Node *, Node *&);    // 后序 线索化
};

int main() {
    cout << "以先序方式输入二叉树('#'代表NULL):";

    Tree T;

    T.Show_postTree(T.getRoot());

    system("pause");
    return 0;
}

Tree::Tree() {
    root = Create();        // 先创建一个默认的二叉树
    Node * pre = NULL;
    _postTree(root, pre);
}

Tree::~Tree() {
    Node * Queue[100];
    int rear = -1, front = -1;
    if(root != NULL) {
        Queue[++rear] = root;
    } 
    Node * p = NULL;
    while (rear != front) {
        p = Queue[front+1];
        if(p->ltag == Child) {            // 有左孩子就进队，没有就不管，判断有无孩子 是看它的标志
            Queue[++rear] = p->lchild;
        }
        if(p->rtag == Child) {            // 有右孩子入队
            Queue[++rear] = p->rchild;
        }
        cout << "析构：" << p->data << endl;
        delete p;                        // 删除队头所指向的那一块存储空间
        front++;                        // 出队一个 front+1
    }
    system("pause");
}

Node * Tree::Create() {
    Node * root;
    char ch;
    cin >> ch;
    if (ch == '#') {
        root = NULL;
    }
    else {
        root = new Node();
        root->data = ch;
        root->ltag = root->rtag = Child;        //  默认设置左右指针域 为孩子
        root->lchild = Create();
        root->rchild = Create();
    }
    return root;
}

Node * Tree::getRoot() {
    return root;
}

void Tree::_postTree(Node * root, Node *&pre) {
    if (root == NULL) {        // 空值不操作
        return;
    }
    else {
        _postTree(root->lchild, pre);    // 递归左树，首先是递归到左子树的最左下的结点
        _postTree(root->rchild, pre);    // 递归右树，首先是递归到左子树的最左下的第一个右结点
        // 对当前结点进行操作，只对含有空指针的结点指针域操作
        if (root->lchild == NULL) {        // 左孩子为空，操作的是前驱，前驱是 pre
            root->ltag = nChild;
            root->lchild = pre;
        }
        // 首先要判断 pre 是否为空，后才能判断他的指针域，因为第一次的 pre在未执行下面语句 pre = root 时是NULL 值， 指针为 NULL值的没有访问其他内存空间的权限
        if (pre != NULL && pre->rchild == NULL) {    // 右孩子为空，操作的是后继， pre是前驱的话，那么root不就是后继吗？
            pre->rtag = nChild;
            pre->rchild = root;
        }
        pre = root;
    }
}

void Tree::Show_postTree(Node * root) {
    cout << "后序线索化遍历(最大使用栈暂存元素个数 100)：";
    Node * Stack[100];
    int top = -1;
    Node * p = root;
    Node * pre = NULL;            // 作为前驱，保留上一次访问过的指针域
    do {
        while (p != NULL) {        // 将当前结点的左孩子全部入栈，一直走到最左边的左孩子
            Stack[++top] = p;
            p = p->lchild;
            if (p == pre) {        // 防止对叶子结点操作中， p = p->rchild 导致 p 不为 NULL, 在执行上面一条语句 p = p->lchild时再次访问了已访问过的结点
                break;
            }
        }
        p = Stack[top];            // 将 p 指向栈顶指针域，进行操作当前结点
        if (p->rtag == nChild || p->rchild == pre) {    // 当前结点没有右孩子 或者 它的右孩子已经被访问过
            cout << p->data << " ";
            top--;        // 输出一个结点，就出栈一个指针域
            pre = p;
            p = NULL;    // p 为 NULL，目的是为了使其不满足第一个while，防止再次访问已访问过的结点，转去操作下一个结点
        }
        else {
            p = p->rchild;
        }
    } while (top != -1 && pre != NULL);
    cout << endl;
}