学习c++对二叉树的基本操作（王道数据结构二叉树基本操作）

//二叉树的顺序存储
#define MaxSize 100
struct TreeNode{
ElemType value;
bool isEmpty;
}
TreeNode t[MaxSize]
for(int i = 0;i<MaxSize;i++)
{
    t[i].isEmpty = true;
}
//二叉树的链式存储
struct ElemType{
    int value;
}
typedef struct BiTNode{
    ElemType data;
    struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
BiTree root = NULL;
root  = (BiTree)malloc(sizeof(BiTNode));
root->data = {1};
root->lchild = NULL;
root->rchild = NULL;
BiTNode *p = (BiTNode *)malloc(sizeof(BiTNode));
p->data = {2};
p->lchild = NULL;
p->rchild = NULL;
root->lchild = p;//作为根节点的左孩子    
//为了容易找到父节点我们可以再定义一个父节点指针 ，这线索化二叉树多开了一个结点指针
typedef struct BiTNode{
    ElemType data;
    struct BiTNode *lchild,*rchild;
    struct BiTNode *parent;
}BiTNode,*BiTree;
//先序遍历
void PreOrder(BiTree T)//T是指针
{
    if(T! = NULL){
        visit(T);
        PreOrder(T->lchild);
        PreOrder(T->rchild);
    }
}
//中序遍历
void MidOrder(BiTree T)
{
    if(T!=NULL)
    {
        MidOrder(T->lchild);
        visit(T);
        MidOrder(T->rchild);
    }
}
//后序遍历
void PostOrder(BiTree T)
{
    if(T！=NULL)
    {
        PostOrder(T->lchild);
        PostOrder(T->rchild);
        visit(T);
    }
}
//树的深度的应用
int treeDepth(BiTree T)
{
    if(T == NULL)
    {
        return  0;
    }
    else
    {
        int l = treeDepth(T->lchild);
        int r = treeDepth(T->rchild);
        return l>r ?l+1:r+1;
    }
}
void LevelOrder(BiTree T)//树的根节点指针
{
    LinkQueue Q;
    InitQueue(Q);
    BiTree p;//定义节点指针，这个p是在下面DeQueue（）中，赋了值。
    EnQueue(Q,T);
    while(!IsEmpty(Q))
    {
        DeQueue(Q,p);
        visit(p);
        if(p->lchild!=NULL)
            EnQueue(Q,p->lchild);
        if(p->rchild!=NULL)
            EnQueue(Q,p->rchild);
    }
}
//二叉树的结点（链式存储）
typedef struct BiTNode
{
    char data;
    struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
//链式队列结点
typedef struct LinkNode
{
    BiTNode *data ;
    struct LinkNode *next;
}LinkNode;
typedef struct
{
    LinkNode *front,*rear;
}LinkQueue;
//递归找前驱   遍历嘛   q记录 pre  比较  q = pre 找到遍历结束
void InOrder(BiTree T)
{
    BiNode *p;//p指向目标结点
    BiNode *pre = NULL;//指向当前访问结点前驱
    BiNode *final = NULL;//用于记录最终结果
    if(T!=NULL)
    {
        InOrder(T->lchild);
        visit(T);
        InOrder(T->rchild);
    }
}
void visit(BiTNode *q)
{
    if(q==p)
        final = pre;
    else
        pre = p;
}
//线索二叉树结点
typedef struct ThreadNode
{
    ElemType data;
    struct ThreadNode *lchild,*rchild;
    int ltag,rtag;
} ThreadNode,*ThreadTree;
ltag=1指前驱，ltag = 0指左孩子
rtag = 0指后继，rtag = 0指右孩子
//中序线索化
ThreadNode *pre =  NULL;
//线索化在visit(ThreadNode *q)中完成
void visit(ThreadNode *q)
{
    if(q->lchild==NULL)
    {
        q->lchild = pre;
        q->ltag = 1;
    }
    else(pre!=NULL && pre->rchild == NULL)
    {
        pre->rchild = q;
        pre->rtag = 1;
    }
    pre = q;//要准备访问下一个结点了  所以把现在pre指向q指的那个结点
} 
void CreateInThread(ThreadTree T)
{
    pre = NULL;
    if(T!=NULL)//非空二叉树的线索化
    {
        InThread(T);//中序线索化二叉树
        if(pre->rchild ==NULL)
            pre->rtag = 1;//处理编列的最后一个结点
    }
}

//先序遍历线索化
void PreThread(ThreadTree T)
{
    if(T!=NULL)
    {
        visit(T);
        if(T->ltag==0)//判断是不是真正的指向左孩子
             PreThread(T->lchild);//如果不做判断就会出现爱的魔力转圈圈问题
        PreThread(T->rchild);
    }
}
void visit(ThreadNode *p)
{
    if(q->lchild==NULL)
    {
        q->lchild = pre;
        q->ltag = 1;
    }
    if(pre!=NULL&&pre->rchild == NULL)
    {
        pre->rchild = q;
        pre->rtag = 1;
    }
    pre = q;
}
void CreateInThread(ThreadTree T)
{
    pre = NULL;
    if(T!=NULL)//非空二叉树的线索化
    {
        PreThread(T);//中序线索化二叉树
        if(pre->rchild ==NULL)
            pre->rtag = 1;//处理编列的最后一个结点
    }
}
//后序遍历线索化visit()和CreatePostThread()和中序没区别


//线索二叉树找后继
//中序线索二叉树找中序后继
//后继指出现在右子树
//找到以p为根的子树中，第一个被中序遍历的点
ThreadNode *Firstnode(ThreadNode *p)
{
    while(p->ltag==0)//当有左子树时
        p = p->lchild;//一直找到最左下的结点
        return p;
}
//中序二叉树中找结点p的后继，就是找右子树中最左下的结点
ThreadNode *Nextnode(ThreadNode *p)
{
    if(p->rtag ==0)//有右子树
        return Firstnode(p->rchild);
    else 
        return p->rchild;//无右子树，直接返回后继线索
}
//中序线索二叉树的中序遍历，利用线索实现非递归算法
void Inorder(ThreadNode *T)
{
    for(ThreadNode *p = FirstNode(T);p!=NULL;p=Nextnode(p))//左根右的规则，给出根找到最左下    
                                                           //结点
                                                           //就是给出根结点一直找后继
                                                           //  ，找到后访问就可以了
        visit(p);
}
//中序线索二叉树找前驱
//找到以p为根，左子树中最右下的结点，（即左子树中最后访问的结点）
ThreadNode *Lastnode(ThreadNode *P)
{
    while(p->rtag == 0)
        p= p->rchild;
        return p;
}
//在中序线索二叉树中找到结点p的前驱结点
ThreadNode *Prenode(ThreadNode *p)
{
    if(p->ltag == 0)
        return Lastnode(p->lchild);
    else return p->lchild;//直接返回前驱线索
}
//对中序线索二叉树的逆向中序遍历
void RevInorder(ThreadNode *T)
{
    for(ThreadNode *p= Lastnode(T);p!=NULL;p = Prenode(p))
        visit(p);
//在先序线索二叉树中找前驱     
//在后序线索二叉树中找后继  土办法或者  给结点加一个父结点指针
}

过段时间补充