层序遍历二叉树

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//Real capacity is CircularQueueMaxSize -1
#define CircularQueueMaxSize 1000
#define MaxSize 1000

typedef int TreeEleType;
typedef struct BinarySearchTreeNode* QueueEleType;

struct BinarySearchTreeNode
{
    TreeEleType Element;
    struct BinarySearchTreeNode *Left;
    struct BinarySearchTreeNode *Right;
};

struct CircularQueue
{
    QueueEleType QueueData[CircularQueueMaxSize];
    int Front;
    int Rear;
};

struct BinarySearchTreeNode *BinarySearchTreeInit()
{
    struct BinarySearchTreeNode *TreeRoot = NULL;

    return TreeRoot;
}

int CircularQueueIsEmpty(struct CircularQueue *Queue)
{
    return (Queue -> Front == Queue -> Rear);
}

int CircularQueueIsFull(struct CircularQueue *Queue)
{
    return ((Queue -> Rear + 1) % CircularQueueMaxSize == Queue -> Front);
}

struct CircularQueue *CircularQueueInit()
{
    struct CircularQueue *Queue;
    Queue = malloc(sizeof(struct CircularQueue));

    Queue -> Front = Queue -> Rear = 0;

    return Queue;
}

//if Queue is full,return 1
int CircularQueueEnqueue(struct CircularQueue *Queue,QueueEleType ToBeEnqueue)
{
    if(CircularQueueIsFull(Queue))
    {
        return 1;
    }
    else
    {
        Queue -> Rear = (Queue -> Rear + 1) % CircularQueueMaxSize;
        Queue -> QueueData[Queue -> Rear] = ToBeEnqueue;
    }
    return 0;
}

//if Queue is empty,return NULL
QueueEleType CircularQueueTop(struct CircularQueue *Queue)
{
    if(CircularQueueIsEmpty(Queue))
    {
        return NULL;
    }
    else
    {
        return Queue -> QueueData[(Queue -> Front + 1) % CircularQueueMaxSize];
    }
    return 0;
}

//if Queue is empty,return 1
int CircularQueueDequeue(struct CircularQueue *Queue)
{
    if(CircularQueueIsEmpty(Queue))
    {
        return 1;
    }
    else
    {
        Queue -> Front = (Queue -> Front + 1) % CircularQueueMaxSize;
        return 0;
    }
}

int MakeCircularQueueEmpty(struct CircularQueue *Queue)
{
    Queue -> Front = Queue -> Rear = 0;

    return 0;
}

int CircularQueueDelete(struct CircularQueue *Queue)
{
    free(Queue);
    Queue = NULL;
    return 0;
}
int BinarySearchTreeDestroy(struct BinarySearchTreeNode *TreeRoot)
{
    if(TreeRoot != NULL)
    {
        BinarySearchTreeDestroy(TreeRoot -> Left);
        BinarySearchTreeDestroy(TreeRoot -> Right);
        free(TreeRoot);
    }
    return 0;
}

struct BinarySearchTreeNode *BinarySearchTreeNodeFind(TreeEleType ToBeFind,struct BinarySearchTreeNode *TreeRoot)
{
    if(TreeRoot==NULL)
    {
        return NULL;
    }

    if(ToBeFind < TreeRoot -> Element)
    {
        return BinarySearchTreeNodeFind(ToBeFind,TreeRoot->Left);
    }
    else if(ToBeFind > TreeRoot -> Element)
    {
        return BinarySearchTreeNodeFind(ToBeFind,TreeRoot->Right);
    }
    else
    {
        return TreeRoot;
    }
}

struct BinarySearchTreeNode *BinarySearchTreeNodeFindMin(struct BinarySearchTreeNode *TreeRoot)
{
    if(TreeRoot==NULL)
    {
        return NULL;
    }
    else if(TreeRoot->Left==NULL)
    {
        return TreeRoot;
    }
    else
    {
        return BinarySearchTreeNodeFindMin(TreeRoot->Left);
    }
}

struct BinarySearchTreeNode *BinarySearchTreeNodeFindMax(struct BinarySearchTreeNode *TreeRoot)
{
    if(TreeRoot==NULL)
    {
        return NULL;
    }
    else if(TreeRoot->Right==NULL)
    {
        return TreeRoot;
    }
    else
    {
        return BinarySearchTreeNodeFindMax(TreeRoot->Right);
    }
}

//be careful of return NULL
struct BinarySearchTreeNode *BinarySearchTreeNodeInsert(TreeEleType ToBeInsert,struct BinarySearchTreeNode *TreeRoot)
{
    if(TreeRoot==NULL)
    {
        TreeRoot = malloc(sizeof(struct BinarySearchTreeNode));
        TreeRoot -> Element = ToBeInsert;
        TreeRoot -> Left = TreeRoot -> Right = NULL;
    }
    else if(ToBeInsert < TreeRoot->Element)
    {
        TreeRoot -> Left = BinarySearchTreeNodeInsert(ToBeInsert,TreeRoot->Left);
    }
    else if(ToBeInsert > TreeRoot->Element)
    {
        TreeRoot -> Right = BinarySearchTreeNodeInsert(ToBeInsert,TreeRoot->Right);
    }
    return TreeRoot;
}

//if doesn't find,return NULL
struct BinarySearchTreeNode *BinarySearchTreeNodeDelete(TreeEleType ToBeDelete,struct BinarySearchTreeNode *TreeRoot)
{
    if(TreeRoot == NULL)
        return NULL;

    struct BinarySearchTreeNode *TmpCell;

    if(ToBeDelete < TreeRoot -> Element)
    {
        TreeRoot -> Left = BinarySearchTreeNodeDelete(ToBeDelete,TreeRoot->Left);
    }
    else if(ToBeDelete > TreeRoot -> Element)
    {
        TreeRoot -> Right = BinarySearchTreeNodeDelete(ToBeDelete,TreeRoot->Right);
    }
    else //if(ToBeDelete == TreeRoot -> Element)
    {
        if(TreeRoot->Left && TreeRoot->Right)
        {
            TmpCell = BinarySearchTreeNodeFindMin(TreeRoot -> Right);
            TreeRoot -> Element = TmpCell -> Element;
            TreeRoot -> Right = BinarySearchTreeNodeDelete(TreeRoot->Element,TreeRoot->Right);
        }
        else
        {
            TmpCell = TreeRoot;
            if(TreeRoot->Left==NULL)
            {
                TreeRoot = TreeRoot -> Right;
            }
            else if(TreeRoot->Right==NULL)
            {
                TreeRoot = TreeRoot -> Left;
            }
            free(TmpCell);
        }
    }
    return TreeRoot;
}

int BinarySearchTreeLevelOrder(struct BinarySearchTreeNode *TreeRoot)
{
    struct CircularQueue *Queue;
    Queue = CircularQueueInit();
    CircularQueueEnqueue(Queue,TreeRoot);
    while(!CircularQueueIsEmpty(Queue))
    {
        struct BinarySearchTreeNode *NodePtr = CircularQueueTop(Queue);
        printf("%d ",NodePtr->Element);
        CircularQueueDequeue(Queue);
        if(NodePtr->Left != NULL)
        {
            CircularQueueEnqueue(Queue,NodePtr->Left);
        }
        if(NodePtr->Right != NULL)
        {
            CircularQueueEnqueue(Queue,NodePtr->Right);
        }
    }
    return 0;
}

int main()
{
    struct BinarySearchTreeNode *TreeRoot = BinarySearchTreeInit();
    TreeRoot = BinarySearchTreeNodeInsert(5,TreeRoot);
    TreeRoot = BinarySearchTreeNodeInsert(6,TreeRoot);
    TreeRoot = BinarySearchTreeNodeInsert(3,TreeRoot);
    TreeRoot = BinarySearchTreeNodeInsert(7,TreeRoot);
    TreeRoot = BinarySearchTreeNodeInsert(2,TreeRoot);
    TreeRoot = BinarySearchTreeNodeInsert(4,TreeRoot);
    TreeRoot = BinarySearchTreeNodeInsert(1,TreeRoot);
    BinarySearchTreeLevelOrder(TreeRoot);
    return 0;
}