数据结构--二叉树

#include<stdio.h>
#include<stdbool.h>
#include<malloc.h>

#define QUEUE_SIZE 5

typedef struct BTNode{
    // 存储二叉树结点的数据元素
    char element;
    // 指向二叉树的左子树结点
    struct BTNode* left;
    // 右子树结点
    struct BTNode *right;
}BTNode,*BTNodePtr;

typedef struct BTNodePtrQueue//队列
{
    BTNodePtr* nodePtrs;
    // 指向队列头部的指针
    int front;
    // 指向队列尾部的指针
    int rear;
}BTNodePtrQueue,*QueuePtr;

QueuePtr initQueue()
{
    // 初始化队列
    QueuePtr resultQueuePtr=(QueuePtr)malloc(sizeof(struct BTNodePtrQueue));
    // 给队列分配空间
    resultQueuePtr->nodePtrs=(BTNodePtr*)malloc(QUEUE_SIZE*sizeof(BTNodePtr));
    // 初始化队头指针和队尾指针
    //将队列的头部指针和尾部指针都设置为0
    resultQueuePtr->front=0;
    resultQueuePtr->rear=1;
    return resultQueuePtr;
}
// 检查队列是否为空
bool isQueueEmpty(QueuePtr paraQueuePtr)
{
    // 如果队列的首尾指针相加为QUEUE_SIZE，则队列为空
    /*
    if((// 判断队列是否为空
paraQueuePtr->front +1)%QUEUE_SIZE==paraQueuePtr->rear)
    {
        return true;
    }
    return false;*/
    if(paraQueuePtr->front==paraQueuePtr->rear)
    {
        return true;
    }
    return false;
}

void enqueue(QueuePtr paraQueuePtr,BTNodePtr paraBTNodePtr)
{
    // 输出队列的前后指针
    printf("front = %d,rear=%d.\r\n",paraQueuePtr->front,paraQueuePtr->rear);
    // 判断队列是否已满
    if((paraQueuePtr->rear+1)%QUEUE_SIZE==paraQueuePtr->front%QUEUE_SIZE)
    {
        printf("Error,trying to enqueue %c.queue full.\r\n",paraBTNodePtr->element);
        return;
    }
    // 将节点指针放入队列
    //将一个新的参数二叉树节点（paraBTNodePtr）添加到参数队列的末尾。
    paraQueuePtr->nodePtrs[paraQueuePtr->rear]=paraBTNodePtr;
    // 更新队列的后指针
    //更新规则是将其加1后对队列大小（QUEUE_SIZE）取模，因为队列的后指针始终指向队列的下一个可用位置。
    //当队尾指针到达队列的末尾时，它将回到队列的起始位置，从而实现队列的循环操作。
    paraQueuePtr->rear=(paraQueuePtr->rear+1)%QUEUE_SIZE;
    printf("enqueue %c ends.\r\n",paraBTNodePtr->element);
}

BTNodePtr dequeue(QueuePtr paraQueuePtr)
{
    if(isQueueEmpty(paraQueuePtr))
    {
        printf("Error,empty queue\r\n");
        return NULL;
    }
    paraQueuePtr->front=(paraQueuePtr->front+1)%QUEUE_SIZE;
    printf("dequeue %c ends.\r\n",paraQueuePtr->nodePtrs[paraQueuePtr->front]->element);
    return paraQueuePtr->nodePtrs[paraQueuePtr->front];
}
BTNodePtr constructBTNode(char paraChar)
{
    BTNodePtr resultPtr = (BTNodePtr)malloc(sizeof(BTNode));
    resultPtr->element=paraChar;
    resultPtr->left=NULL;
    resultPtr->right=NULL;
    return resultPtr;

}

BTNodePtr stringToBTree(char * paraString)
{
    int i;
    char ch;
    QueuePtr tempQueuePtr=initQueue();
    BTNodePtr resultHeader;
    BTNodePtr tempParent,tempLeftChild,tempRightChild;
    i=0;
    ch=paraString[i];
    resultHeader=constructBTNode(ch);
    enqueue(tempQueuePtr,resultHeader);

    while(!isQueueEmpty(tempQueuePtr))
    {
        tempParent =dequeue(tempQueuePtr);
        i++;
        ch=paraString[i];
        if(ch=='#')
        {
            tempParent->left=NULL;
        }
        else{
            tempLeftChild=constructBTNode(ch);
            enqueue(tempQueuePtr,tempLeftChild);
            tempParent->left=tempLeftChild;
        }
    }
    return resultHeader;
}

void levelwise(BTNodePtr paraTreePtr)
{
    char tempString[100];
    int i=0;
    QueuePtr tempQueuePtr=initQueue();
    BTNodePtr tempNodePtr;
    enqueue(tempQueuePtr,paraTreePtr);
    while(!isQueueEmpty(tempQueuePtr))
    {
        tempNodePtr=dequeue(tempQueuePtr);
        tempString[i]=tempNodePtr->element;
        i++;
        if(tempNodePtr->left!=NULL)
        {
            enqueue(tempQueuePtr,tempNodePtr->left);
        }
        if(tempNodePtr->right!=NULL)
        {
            enqueue(tempQueuePtr,tempNodePtr->right);
        }
    }
    tempString[i]='\0';
    printf("Levelwise:%s\r\n",tempString);
}
void preorder(BTNodePtr tempPtr)
{
    if(tempPtr==NULL)
    {
        return;
    }
    printf("%c",tempPtr->element);
    preorder(tempPtr->left);
    preorder(tempPtr->right);
}
void inorder(BTNodePtr tempPtr)
{
    if(tempPtr==NULL)
    {
        return;
    }
    inorder(tempPtr->left);
    printf("%c",tempPtr->element);
    inorder(tempPtr->right);
}

void postorder(BTNodePtr  tempPtr){
    if(tempPtr==NULL)
    {
        return;
    }
    postorder(tempPtr->left);
    postorder(tempPtr->right);
    printf("%c",tempPtr->element);
}
int main(){
    BTNodePtr tempHeader;
    tempHeader=constructBTNode('c');
    printf("There is only one node.Preorder visit;");
    preorder(tempHeader);
    printf("\r\n");

    char* tempString="acde#bf#####";

    tempHeader=stringToBTree(tempString);
    printf("preorder :");
    preorder(tempHeader);
    printf("\r\n");
    printf("Inorder: ");
	inorder(tempHeader);
	printf("\r\n");
	printf("Postorder: ");
	postorder(tempHeader);
	printf("\r\n");
	printf("Levelwise: ");
	levelwise(tempHeader);
	printf("\r\n");

    return 1;

}