数据结构严蔚敏 #二叉树 代码复现

#include <stdio.h>
#include <stdlib.h>
#define MAXLEN 100
typedef char TElemType;
typedef TElemType SqBiTree[MAXLEN];     //顺序存储二叉树定义

//链表二叉树结构定义
typedef struct BiTNode{
    TElemType data;                     // ⚠️ 这个数据不是指针型
    struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
//链表二叉树结构定义结束

//栈结构创建
typedef BiTree SElemType;       // ⚠️  栈的数据类型到底该为什么？ 进栈的是树指针，而不是树节点
typedef struct{
    SElemType *base;
    SElemType *top;
    int stacksize;
}SqStack;
//栈结构创建结束

//栈 #初始化    #开始
void StackInit(SqStack *s){
    s->base = (SElemType*)malloc(sizeof(SElemType)*MAXLEN);
    s->top = s->base;
    s->stacksize = MAXLEN;
}
//栈 #初始化    #结束

//栈 #判断空    #开始
int StackEmpty(SqStack s){
    if(s.base == s.top)return 1;
    return 0;
}
//栈 #判断空    #结束

//栈 #进栈     #开始
int Push(SqStack s,SElemType e){
    if(s.top - s.base == s.stacksize)return 0;
    *(s.top++) = e;
    return 1;
}
//栈 #进栈     #结束

//栈 #出栈     #开始
int Pop(SqStack s,SElemType *e){
    if(s.base == s.top)return 0;
    (*e) = *(--s.top);
    return 1;
}
//中序遍历二叉树递归结构函数
void InOrderTraverse(BiTree T){

    if(T){                              //先序，中序，后续的不同仅在于访问的时机，遍历路径相同
        InOrderTraverse( T->lchild);
        printf("%c",T->data);
        InOrderTraverse( T->rchild);
    }
}
//中序遍历二叉树递归结构函数结束

//中序遍历二叉树的非递归算法，利用栈实现
void InOrderTraverse_NonRecursive(BiTree T){
    SqStack s;
    StackInit(&s);
    BiTree q,p = T;
    while(p||!StackEmpty(s)){
        if(p){
            Push(s,p);
            p = p->lchild;
        }else{
            Pop(s,&q);
            printf("%c",q->data);
            p = q->rchild;
        }
    }
}
//中序遍历二叉树的非递归算法，利用栈实现结束
typedef BiTree QElemType;
typedef struct{             //循环队列结构定义
    QElemType *base;
    int front;
    int rear;
}SqQueue;
//层次遍历算法，利用队列，根节点入队，分界点先入队，队非空就出队并访问节点，左孩子和右孩子非空就入队，循环

void QueueInit(SqQueue *q){
    (*q).base = (QElemType*)malloc(sizeof(QElemType)*MAXLEN);
    (*q).front = (*q).rear = 0;
}
int  EnQueue(SqQueue *q,QElemType e){
    if(((*q).rear + 1)%MAXLEN ==(*q).front)return 0;
    (*q).base[(*q).rear++] = e;
    (*q).rear = ((*q).rear+1)%MAXLEN;
    return 1;
}
int DeQueue(SqQueue *q,QElemType *e){
    if((*q).rear == (*q).front)return 0;
    (*e) = (*q).base[--(*q).front];
    (*q).front = ((*q).front + 1)%MAXLEN;
    return 1;
}
int QueueEmpty(SqQueue q){
    if(q.front == q.rear)return 1;
    return 0;
}
void LevelOrder(BiTree T){          //二叉树的层次遍历
    SqQueue q;
    BiTree p;
    QueueInit(&q);
    EnQueue(&q,T);
    while(!QueueEmpty(q)){
        DeQueue(&q,&p);
        printf("%c",p->data);
        if(p->lchild)
            EnQueue(&q,p->lchild);
        if(p->rchild)
            EnQueue(&q,p->rchild);
    }
}
void CreateBiTree(BiTree *T){       //  先序递归创建二叉树  #为空树标志
    char ch;
    scanf("%c",&ch);
    if(ch == '#'){
        (*T) = NULL;
    }else{
        (*T) = malloc(sizeof(BiTNode));
        (*T)->data = ch;
        CreateBiTree(&(*T)->lchild);
        CreateBiTree(&(*T)->rchild);
    }
}

void Copy(BiTree T,BiTree *NewT){               //复制二叉树
    if(T == NULL){(*NewT) = NULL;return;}
    else{
        (*NewT) =(BiTree)malloc(sizeof(BiTNode));
        (*NewT)->data = T->data;
        Copy(T->lchild,&(*NewT)->lchild);
        Copy(T->rchild,&(*NewT)->rchild);
    }
}
int Depth(BiTree T){
    if(T == NULL)return 0;
    else{
        int m = Depth(T->lchild);
        int n = Depth(T->rchild);
        if(m > n)return m+1;
        else return n+1;
    }
}
int NodeCount(BiTree T){
    if(T == NULL)return 0;
    else return NodeCount(T->lchild) + NodeCount(T->rchild)+1;
}
typedef struct BiThrTNode{
    TElemType data;
    struct BiThrTNode *lchild,*rchild;
    int LTag,RTag;
}BiThrTNode,*BiThrTree;
BiThrTree  pre;
void InThreading(BiThrTree p){
    if(p){
        InThreading(p->lchild);
        if(!p->lchild){
            p->LTag = 1;
            p->lchild = pre;
        }
        else p->LTag = 0;
        if(!pre->rchild){
            pre->RTag = 1;
            pre->rchild = p;
        }
        else pre->RTag = 0;
        pre = p;
        InThreading(p->rchild);
    }
}

int main() {
    SqBiTree bt;            //顺序存储二叉树变量

    return 0;
}