线索二叉树

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <vector>
#include <stack>
#include <algorithm>
using namespace std;

typedef enum{
    Thread,
    Link
}Tag;

typedef struct Node
{
    int data;
    struct Node * lchild;
    struct Node * rchild;
    Tag rtag;
    Tag ltag;
} Node;

Node *createNode(int data, Node * l = NULL, Node * r = NULL)
{
    Node * res = (Node *)malloc(sizeof(Node));
    res->data = data;
    res->lchild = l;
    res->rchild = r;
    res->rtag = Link;
    res->ltag = Link;
    return res;
}


Node * createTree(Node * &root, int x)
{
    if (root == NULL){
        root = createNode(x, NULL, NULL);
        return root;
    }
    Node * p = root;
    Node * q = NULL;
    while(p != NULL){
        q = p;
        if ( x > p->data ){
            p = p->rchild;
        }
        else {
            p = p->lchild;
        }
    }
    if ( x > q->data) q->rchild = createNode(x);
    else q->lchild = createNode(x);
    return root;
}

void print(Node * root)
{
    if (root == NULL) return;
    print(root->lchild);
    printf("%d\n", root->data);
    print(root->rchild);
}

void mprint(Node * root)
{
    Node * p = root;
    stack<Node *> st;
    st.push(root);
    while (!st.empty()) {
        if (st.top() == NULL) {
            st.pop();
            if (!st.empty()) {
                printf("%d\n", st.top()->data);    
                Node * temp = st.top();
                st.pop();
                st.push(temp->rchild);
            }
        }
        else {
            st.push(st.top()->lchild);
        }
    }
}

void threadTree(Node *&prev, Node *root) {
    if (root == NULL) return;
    threadTree(prev, root->lchild);
    if (root->lchild == NULL) {
        root->lchild = prev;
        root->ltag = Thread;
    }
    if (prev != NULL && prev->rchild == NULL) {
        prev->rchild = root;
        prev->rtag = Thread;
    }
    prev = root;
    threadTree(prev, root->rchild);
}


int inThreadTreePrint(Node * root) {
    Node * p = root;
    while(p) {
        if (p->lchild != NULL && p->ltag != Thread)
            p = p->lchild;
        else {
            printf("%d\n", p->data);
            while (p->rchild != NULL && p->rtag == Thread) {
                p = p->rchild;
                printf("%d\n", p->data);
            }
            p = p->rchild;
        }
    }
}



int main(void)
{
    Node *root = NULL;
    createTree(root, 5);
    createTree(root, 4);
    createTree(root, 9);
    createTree(root, 7);
    createTree(root, 1);
    createTree(root, 2);
    Node * prev = NULL;
    threadTree(prev, root);
    printf("%d ", root->lchild->data);
    if (root->lchild->lchild) printf("%d ", root->lchild->lchild->data);
    else printf("NULL ");
    if (root->rchild->lchild->rchild) printf("%d ", root->rchild->lchild->rchild->data);
    else printf("NULL ");
    printf("\n");
    printf("----------------------------------------------------\n");
    inThreadTreePrint(root);
    return 0;
}