二叉树节点的插入

全部代码

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

typedef struct node
{
    int nValue;
    struct node *pLeft;
    struct node *pRight;
}BiTree;

typedef struct node2
{
    BiTree *nValue;
    struct node2 *pNext;
}MyQueue;

typedef struct node3
{
    int nCount;
    MyQueue *pHead;
    MyQueue *pTail;
}Queue;

void q_Init(Queue **ppQueue)
{
    assert(ppQueue!=NULL);

    *ppQueue = (Queue*)malloc(sizeof(Queue));
    if(NULL == *ppQueue)
    {
        printf("*ppQueue空间分配失败！
");
        exit(-1);
    }
    (*ppQueue)->nCount = 0;
    (*ppQueue)->pHead = NULL;
    (*ppQueue)->pTail = NULL;
}

void q_Push(Queue *pQueue,BiTree* nNum)
{
    MyQueue *pTemp = NULL;
    
    assert(pQueue!=NULL);

    pTemp = (MyQueue*)malloc(sizeof(MyQueue));
    if(NULL == pTemp)
    {
        printf("pTemp空间分配失败！
");
        exit(-1);
    }
    pTemp->nValue = nNum;
    pTemp->pNext = NULL;

    //队列空
    if(pQueue->pHead == NULL)
    {
        pQueue->pHead = pTemp;
    }
    else
    {
        pQueue->pTail->pNext = pTemp;
    }
    pQueue->pTail = pTemp;

    //更新队列元素
    ++pQueue->nCount;
}

BiTree *q_Pop(Queue *pQueue)
{
    BiTree* nNum= NULL;
    MyQueue *pDel = NULL;
    
    assert(pQueue!=NULL && pQueue->pHead!=NULL);
    
    pDel = pQueue->pHead ;
    nNum = pDel->nValue;

    pQueue->pHead = pQueue->pHead->pNext;
    free(pDel);
    pDel = NULL;

    --pQueue->nCount;

    //队列在删除后为空  尾置空
    if(pQueue->nCount == 0)
    {
        pQueue->pTail =NULL;
    }

    return nNum;
}

int q_IsEmpty(Queue *pQueue)
{
    assert(pQueue!=NULL);

    return pQueue->nCount == 0 ?1:0;
}

BiTree *CreateBiTree()
{
    BiTree *pRoot = NULL;
    
    //根
    pRoot = (BiTree*)malloc(sizeof(BiTree));
    pRoot->nValue = 1;

    //根的左
    pRoot->pLeft = (BiTree*)malloc(sizeof(BiTree));
    pRoot->pLeft->nValue = 2;

    //左的左    
    pRoot->pLeft->pLeft = (BiTree*)malloc(sizeof(BiTree));
    pRoot->pLeft->pLeft->nValue = 4;
    pRoot->pLeft->pLeft->pLeft = NULL;
    pRoot->pLeft->pLeft->pRight = NULL;

    //左的右
    pRoot->pLeft->pRight= (BiTree*)malloc(sizeof(BiTree));
    pRoot->pLeft->pRight->nValue = 5;
    pRoot->pLeft->pRight->pLeft = NULL;
    pRoot->pLeft->pRight->pRight = NULL;

    //根的右
    pRoot->pRight = (BiTree*)malloc(sizeof(BiTree));
    pRoot->pRight->nValue = 3;

    //右的左
    pRoot->pRight->pLeft = (BiTree*)malloc(sizeof(BiTree));
    pRoot->pRight->pLeft->nValue = 6;
    pRoot->pRight->pLeft->pLeft = NULL;
    pRoot->pRight->pLeft->pRight = NULL;

    //右的右
    pRoot->pRight->pRight = NULL;
    
    return pRoot;
}

BiTree *LevelSearch(BiTree *pRoot,int nNum)
{
    Queue *pQueue = NULL;
    BiTree *pTemp = NULL;

    assert(pRoot!=NULL);

    //初始化辅助队列
    q_Init(&pQueue);

    //根 入队
    q_Push(pQueue,pRoot);

    //队列为空  遍历结束
    while(!q_IsEmpty(pQueue))
    {
        pTemp = q_Pop(pQueue);
        //查找到该结点
        if(pTemp->nValue == nNum)
        {
            return pTemp;
        }
        
        if(pTemp->pLeft != NULL)
        {
            q_Push(pQueue,pTemp->pLeft);
        }
        if(pTemp->pRight != NULL)
        {
            q_Push(pQueue,pTemp->pRight);
        }
    }

    //查找失败
    return NULL;
}

enum DIRECTION{LEFT,RIGHT};

void InsertNode(BiTree *pRoot, int nValue, int nNum, int nDirection)
{
    BiTree *pNode = NULL;
    BiTree *pTemp = NULL;

    assert(pRoot!=NULL);

    //查找
    pNode = LevelSearch(pRoot,nValue);

    if(NULL == pNode)
    {
        return;
    }

    pTemp = (BiTree*)malloc(sizeof(BiTree));
    if(NULL == pTemp)
    {
        printf("pTemp空间分配失败！
");
        exit(-1);
    }
    pTemp->nValue = nNum;
    pTemp->pLeft = NULL;
    pTemp->pRight = NULL;

    if(LEFT == nDirection)
    {
        pNode->pLeft = pTemp;
    }
    else
    {
        pNode->pRight = pTemp;
    }
}

void Traversal(BiTree *pRoot)
{
    if(NULL == pRoot)
    {
        return;
    }

    printf("%d
",pRoot->nValue);
    Traversal(pRoot->pLeft);
    Traversal(pRoot->pRight);
}

int main(void)
{
    BiTree *pRoot = NULL;
    
    pRoot = CreateBiTree();
    InsertNode(pRoot,2,10000,0);
    Traversal(pRoot);

    return 0;
}