数据结构学习【线索二叉树C++ 先序&中序遍历（不使用栈）】

本次实现的是线索二叉树。插入方式采用的是二叉排序树的插入方式。实现了二叉树的先序&中序遍历(采用线索来遍历，而不是借助栈)。

之所以不实现后序遍历，是因为后序线索二叉树对于rtag=0的结点（即右指针指向的是右孩子的结点）难以找到其后继结点，除非使用三叉链表。故此处只实现了后序线索二叉树的建立，但是未实现后序遍历。

#include <iostream>
using namespace std;

typedef struct ThreadNode
{
    
    
    int data;
    struct ThreadNode *lchild, *rchild;
    int ltag,rtag;
} ThreadNode,*ThreadTree;

bool Insert(ThreadTree &root, int data);  // 根据二叉排序树插入
//先序构造线索二叉树
void CreatPreThread(ThreadTree root);  
void PreThread(ThreadTree root,ThreadNode* &pre);
//中序构造线索二叉树
void CreatInThread(ThreadTree root);  
void InThread(ThreadTree root,ThreadNode* &pre);
//后序构造线索二叉树
void CreatPostThread(ThreadTree root);  
void PostThread(ThreadTree root,ThreadNode* &pre);


void Traversal(ThreadNode *root, int type); // 0: 先序, 1: 中序, (采用线索二叉树的方式遍历，无需栈)

void PreorderTraversal(ThreadNode *root);
ThreadNode* NextPreNode(ThreadNode* p);

void InorderTraversal(ThreadNode *root);
ThreadNode* NextInNode(ThreadNode* p);

// Code

int main()
{
    
    
    ThreadTree root = nullptr;
    Insert(root, 6);
    Insert(root, 4);
    Insert(root, 5);
    Insert(root, 8);
    Insert(root, 7);
    Insert(root, 9);
    
    printf("二叉排序树");

    CreatPreThread(root);
    printf("\n先序：");
    Traversal(root,0);

    // CreatInThread(root);
    // printf("\n中序：");
    // Traversal(root,1);

    //CreatPostThread(root);

    system("pause");
}
// 根据二叉排序树插入
bool Insert(ThreadTree &p, int data)
{
    
    
    if (p == nullptr)
    {
    
    
        p = (ThreadNode *)malloc(sizeof(ThreadNode));
        p->data = data;
        p->lchild = nullptr;
        p->rchild = nullptr;
        p->ltag=0;
        p->rtag=0;
        return true;
    }
    if (data < p->data)
    {
    
    
        return Insert(p->lchild, data);
    }
    else if (data > p->data)
    {
    
    
        return Insert(p->rchild, data);
    }
    else
    {
    
    
        return false;
    }
}
//先序构造线索二叉树
void CreatPreThread(ThreadTree root){
    
    
    ThreadNode* pre=nullptr;
    if(root!=nullptr){
    
    
        PreThread(root,pre);
        if(pre->rchild==nullptr)
            pre->rtag=1;
    }
} 
void PreThread(ThreadTree root,ThreadNode* &pre){
    
    
    if(root!=nullptr){
    
    
        // 建立前驱线索
        if(root->lchild==nullptr){
    
    
            root->ltag=1;
            root->lchild=pre;
        }
        // 建立后继线索
        if(pre!=nullptr&&pre->rchild==nullptr){
    
    
            pre->rtag=1;
            pre->rchild=root;
        }
        pre=root;
        if(root->ltag==0)//避免循环
            PreThread(root->lchild,pre);
        PreThread(root->rchild,pre);
    }
}
//中序构造线索二叉树
void CreatInThread(ThreadTree root){
    
    
    ThreadNode* pre=nullptr;
    if(root!=nullptr){
    
    
        InThread(root,pre);
        if(pre->rchild==nullptr)
            pre->rtag=1;
    }
}
void InThread(ThreadTree root,ThreadNode* &pre){
    
    
    if(root!=nullptr){
    
    
        InThread(root->lchild,pre);
        // 建立前驱线索
        if(root->lchild==nullptr){
    
    
            root->ltag=1;
            root->lchild=pre;
        }
        // 建立后继线索
        if(pre!=nullptr&&pre->rchild==nullptr){
    
    
            pre->rtag=1;
            pre->rchild=root;
        }
        pre=root;
        InThread(root->rchild,pre);
    }
}
//后序构造线索二叉树
void CreatPostThread(ThreadTree root){
    
    
    ThreadNode* pre=nullptr;
    if(root!=nullptr){
    
    
        PostThread(root,pre);
        if(pre->rchild==nullptr)
            pre->rtag=1;
    }
}
void PostThread(ThreadTree root,ThreadNode* &pre){
    
    
    if(root!=nullptr){
    
    
        PostThread(root->lchild,pre);
        PostThread(root->rchild,pre);
        // 建立前驱线索
        if(root->lchild==nullptr){
    
    
            root->ltag=1;
            root->lchild=pre;
        }
        // 建立后继线索
        if(pre!=nullptr&&pre->rchild==nullptr){
    
    
            pre->rtag=1;
            pre->rchild=root;
        }
        pre=root;
    }
}

// 0: 先序, 1: 中序
void Traversal(ThreadNode *root, int type)
{
    
    
    switch (type)
    {
    
    
    case 0:
        PreorderTraversal(root);
        break;
    case 1:
        InorderTraversal(root);
        break;
    default:
        break;
    }
}
// 先序
void PreorderTraversal(ThreadNode *root){
    
    
   for(ThreadNode* p=root;p!=nullptr;p=NextPreNode(p)){
    
    
       visit(p);
   }
}
ThreadNode* NextPreNode(ThreadNode* p){
    
    
    if(p->rtag==1) return p->rchild;
    else{
    
    
        if(p->lchild!=nullptr&&p->ltag==0) return p->lchild;
        else return p->rchild;
    }
}
// 中序
void InorderTraversal(ThreadNode *root){
    
    
    // 找到第一个结点
    ThreadNode* tmp=root;
    while (tmp->ltag==0)
    {
    
    
        tmp=tmp->lchild;
    }
    // 遍历
    for(ThreadNode* p=tmp;p!=nullptr;p=NextInNode(p)){
    
    
       visit(p);
   }
}
ThreadNode* NextInNode(ThreadNode* p){
    
    
    if(p->rtag==1) return p->rchild;
    else{
    
    
        ThreadNode* tmp=p->rchild;
        while(tmp->ltag==0) tmp=tmp->lchild;
        return tmp;
    }
}


//访问结点
void visit(ThreadNode* p){
    
    
    printf("%d ",p->data);
}

本文插入数据形成的二叉树如图