数据结构之二叉树

lxzlife

已于 2023-06-04 20:42:37 修改

阅读量253

点赞数

分类专栏：数据结构文章标签：数据结构 c++ c语言

于 2022-05-14 21:21:22 首次发布

本文链接：https://blog.csdn.net/weixin_45050132/article/details/124774322

版权

数据结构专栏收录该内容

6 篇文章 0 订阅

订阅专栏

源码

linklist1.h

// 单向链表
// 头节点无数据域只有指针域

#ifndef _LINKLIST1_H

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

	#define TRACE(str) printf("%s\n",str)

	struct LinkNode
	{
		void* pData;
		struct LinkNode* next;
	};

	struct LinkList
	{
		struct LinkNode head;
		int length;
	};


	//创建链表
	struct LinkList* CreatLinkList(void);

	//按位置往链表插入节点
	void InsertToLinlkListByPos(struct LinkList*pLinkList, int position, void* pData);

	//往链表头插入节点
	void InsertToLinkListHead(struct LinkList*pLinkList, void* pData);

	//往链表尾插入节点
	void InsertToLinkListTail(struct LinkList*pLinkList, void* pData);

	//遍历链表
	void TraverseLinkList(struct LinkList* pLinkList, void(*printCallback)(void*));

	//按位置获取链表节点的数据指针
	void *GetDataPointerOfNodeInLinkListByPos(struct LinkList* pLinkList,int pos);

	//获取链表第一个节点的数据指针
	void *GetDataPointerOfFirstNodeInLinkList(struct LinkList* pLinkList);

	//获取链表最后一个节点的数据指针
	void *GetDataPointerOfLastNodeInLinkList(struct LinkList* pLinkList);

	//按位置删除链表的节点
	void DeleteNodeOFLinkListByPosition(struct LinkList* pLinkList, int position);

	//删除链表的第一个节点
	void DeleteFirstNodeOfLinkList(struct LinkList* pLinkList);

	//删除链表的最后一个节点
	void DeleteLastNodeOfLinkList(struct LinkList* pLinkList);

	//按数据指针删除链表内节点
	void DeleteNodeOFLinkListByValue(struct LinkList* pLinkList, void* data, int(*comparecallback)(void* data1, void* data2));

	//清空链表
	void ClearLinkList(struct LinkList* pLinkList);

	//摧毁链表
	void DestroyLinkList(struct LinkList* linklistpointer);

	//链表去重(删除数据域相同的节点)
	void QuCHongLiskList(struct LinkList*pLinkList,int(*CompareCallBack)(void*,void*));

	//链表逆序
	void ReverseLinkList(struct LinkList*pLinkList);

#endif

linklist1.c

#include"linklist1.h"


struct LinkList* CreatLinkList(void)
{
	struct LinkList* pLinkList;
	
	pLinkList = (struct LinkList*)malloc(sizeof(struct LinkList));
	
	if (pLinkList == NULL)
	{
		return(NULL);
	}
	
	pLinkList->head.pData = NULL;
	
	pLinkList->head.next = NULL;
	
	pLinkList->length = 0;
	
	return(pLinkList);
}

void ClearLinkList(struct LinkList* pLinkList)
{
	if (pLinkList == NULL)
	{
		return;
	}
	if (pLinkList->length < 1)
	{
		return;
	}
	int length = pLinkList->length;
	for (int i = 0; i < length; i++)
	{
		//用尾删函数删除链表节点
		DeleteLastNodeOfLinkList(pLinkList);
	}
}

void InsertToLinlkListByPos(struct LinkList*pLinkList,int position,void*pData)
{
	
	if (pLinkList == NULL)
	{
		return;
	}
	if (pData == NULL)
	{
		return;
	}
	
	if (position < 0 || position > pLinkList->length)
	{
		
		return;
	}
	
	struct LinkNode* pFrontNode = &pLinkList->head;
	
	for (int i = 0; i < position; i ++)
	{
		pFrontNode = pFrontNode->next;
	}
	
	struct LinkNode* pNewNode = (struct LinkNode*)malloc(sizeof(struct LinkNode));
	pNewNode->pData = pData;
	pNewNode->next = NULL;
	
	pNewNode->next = pFrontNode->next;
	pFrontNode->next = pNewNode;
	
	pLinkList->length++;
}

void InsertToLinkListHead(struct LinkList*pLinkList, void* pData)
{
	if (pLinkList == NULL)
	{
		return;
	}
	if (pData == NULL)
	{
		return;
	}
	InsertToLinlkListByPos(pLinkList,0,pData);
}

void InsertToLinkListTail(struct LinkList*pLinkList, void* pData)
{
	if (pLinkList == NULL)
	{
		return;
	}
	if (pData == NULL)
	{
		return;
	}
	InsertToLinlkListByPos(pLinkList,pLinkList->length,pData);
}

void TraverseLinkList(struct LinkList*pLinkList,void(*printCallback)(void*))
{
	if (pLinkList == NULL)
	{
		return;
	}
	struct LinkNode* pCurNode = &pLinkList->head;
	for (int i = 0; i < pLinkList->length; i++)
	{
		pCurNode = pCurNode->next;
		printCallback(pCurNode->pData);
	}
}

void *GetDataPointerOfNodeInLinkListByPos(struct LinkList* pLinkList,int pos)
{
	if (pLinkList == NULL)
	{
		return(NULL);
	}
	if (pos < 0)
	{
		return(NULL);
	}
	if (pos >= pLinkList->length)
	{
		return(NULL);
	}
	struct LinkNode *pNode = &pLinkList->head;
	for (int i = 0; i <= pos; i ++)
	{
		pNode = pNode->next;
	}
	return(pNode->pData);
}

//获取链表第一个节点的数据指针
void *GetDataPointerOfFirstNodeInLinkList(struct LinkList* pLinkList)
{
	if (pLinkList == NULL)
	{
		return(NULL);
	}
	if (pLinkList->length < 1)
	{
		return(NULL);
	}
	void *pData;
	pData = GetDataPointerOfNodeInLinkListByPos(pLinkList,0);
	return(pData);
}

//获取链表最后一个节点的数据指针
void *GetDataPointerOfLastNodeInLinkList(struct LinkList* pLinkList)
{
	if (pLinkList == NULL)
	{
		return(NULL);
	}
	if (pLinkList->length < 1)
	{
		return(NULL);
	}
	void *pData;
	pData = GetDataPointerOfNodeInLinkListByPos(pLinkList,pLinkList->length - 1);
	return(pData);
}

void DeleteNodeOFLinkListByPosition(struct LinkList*pLinkList,int position)
{
	if (pLinkList == NULL)
	{
		return;
	}
	if (position < 0 || position >= pLinkList->length)
	{
		return;
	}
	
	struct LinkNode* pCurNode;
	pCurNode = &pLinkList->head;
	for (int i = 0; i < position; i++)
	{
		pCurNode = pCurNode->next;
	}
	
	struct LinkNode* pDeleteNode;
	pDeleteNode = pCurNode->next;

	pCurNode->next = pDeleteNode->next;
	
	free(pDeleteNode);
	
	pLinkList->length--;
}

void DeleteFirstNodeOfLinkList(struct LinkList* pLinkList)
{
	if (pLinkList == NULL)
	{
		return;
	}
	DeleteNodeOFLinkListByPosition(pLinkList,0);
}

void DeleteLastNodeOfLinkList(struct LinkList* pLinkList)
{
	if (pLinkList == NULL)
	{
		return;
	}
	DeleteNodeOFLinkListByPosition(pLinkList,pLinkList->length - 1);
}

void DeleteNodeOFLinkListByValue(struct LinkList* pLinkList, void* pDataIn, int(*comparecallback)(void* data1, void* data2))
{
	if (pLinkList == NULL)
	{
		return;
	}
	if (pDataIn == NULL)
	{
		return;
	}

	for (int i = 0; i < pLinkList->length; i ++)
	{
		void *pData;
		pData = GetDataPointerOfNodeInLinkListByPos(pLinkList,i);
		if (comparecallback(pData,pDataIn) == 0)
		{
			DeleteNodeOFLinkListByPosition(pLinkList,i);
			i --;
		}
	}
}

void DestroyLinkList(struct LinkList* pLinkList)
{
	if (pLinkList == NULL)
	{
		return;
	}
	ClearLinkList(pLinkList);
	free(pLinkList);
}

void QuCHongLiskList(struct LinkList*pLinkList,int(*compareCallBack)(void*,void*))
{
	if (pLinkList == NULL)
	{
		return;
	}

	int length = pLinkList->length;
	if (length < 2)
	{
		return;
	}

	if (compareCallBack == NULL)
	{
		return;
	}

	void **ppData = (void **)malloc(sizeof(void *) * length);
	int sameCount = 0;

	void *pDataI;
	void *pDataJ;
	
	for (int i = 0; i < pLinkList->length; i ++)
	{
		pDataI = GetDataPointerOfNodeInLinkListByPos(pLinkList,i);
		for (int j = i + 1; j < pLinkList->length; j ++)
		{
			pDataJ = GetDataPointerOfNodeInLinkListByPos(pLinkList,j);
			if (compareCallBack(pDataI,pDataJ) == 0)
			{
				*(ppData + sameCount) = pDataJ;
				sameCount ++;
			}
		}
	}

	for (int i = 0; i < sameCount; i ++)
	{
		DeleteNodeOFLinkListByValue(pLinkList,*(ppData + i),compareCallBack);
	}

	free(ppData);
}

void ReverseLinkList(struct LinkList*pLinkList)
{
	//思路：顺序删除，逆序插入
	if (pLinkList == NULL)
	{
		return;
	}

	if (pLinkList->length < 2)
	{
		return;
	}

	int num = pLinkList->length;
	void **ppData = (void *)malloc(sizeof(void *) * num);

	for (int i = 0; i < num; i ++)
	{
		*(ppData + i) = GetDataPointerOfNodeInLinkListByPos(pLinkList,i);
	}

	for (int i = 0; i < num; i ++)
	{
		DeleteLastNodeOfLinkList(pLinkList);
	}

	for (int i = 0; i < num; i ++)
	{
		InsertToLinkListTail(pLinkList,*(ppData + num - i - 1));
	}
}

Queue.h

#ifndef QUEUE_H

    #define QUEUE_H

    #include "linklist1.h"

    #ifdef __cplusplus
    extern "C"
    {
    #endif

    //创建队列
    void *CreatQueue(void);

    //入队
    void PushQueue(void *pQueue,void *pData);

    //出队
    void PopQueue(void *pQueue);

    //获取队列头元素
    void *GetQueueHead(void *pQueue);

    //清空队列
    void ClearQueue(void *pQueue);

    //判断队列是否为空
    bool IsQueueEmpty(void *pQueue);

    //销毁队列
    void DestroyQueue(void *pQueue);

    #ifdef __cplusplus
    }
    #endif

#endif

Queue.c

#include "Queue.h"

//创建队列
void *CreatQueue(void)
{
    struct LinkList *pLinkList;
    pLinkList = CreatLinkList();
    if (pLinkList == NULL)
    {
        return(NULL);
    }
    else 
    {
        return(pLinkList);
    }
}

//入队
void PushQueue(void *pQueue,void *pData)
{
    if (pQueue == NULL)
    {
        return;
    }
    if (pData == NULL)
    {
        return;
    }

    struct LinkList *pLinkList;
    pLinkList = (struct LinkList *)pQueue;
    
    //入队即将数据指针插入到链表的尾节点
    InsertToLinkListTail(pLinkList,pData);
}

//出队
void PopQueue(void *pQueue)
{
    if (pQueue == NULL)
    {
        return;
    }

    struct LinkList *pLinkList;
    pLinkList = (struct LinkList *)pQueue;

    if (pLinkList->length < 1)
    {
        return;
    }

    //出队即删除链表的头节点
    DeleteFirstNodeOfLinkList(pLinkList);
}

//获取队列头元素
void *GetQueueHead(void *pQueue)
{
    if (pQueue == NULL)
    {
        return(NULL);
    }

    struct LinkList *pLinkList;
    pLinkList = (struct LinkList *)pQueue;

    if (pLinkList->length < 1)
    {
        return(NULL);
    }

    //获取队列头元素即获取链表头节点的数据指针
    void *pData;
    pData = GetDataPointerOfFirstNodeInLinkList(pLinkList);

    return(pData);
}

//清空队列
void ClearQueue(void *pQueue)
{
    if (pQueue == NULL)
    {
        return;
    }

    struct LinkList *pLinkList;
    pLinkList = (struct LinkList *)pQueue;

    if (pLinkList->length < 1)
    {
        return;
    }

    ClearLinkList(pLinkList);
}

//判断队列是否为空
bool IsQueueEmpty(void *pQueue)
{
    if (pQueue == NULL)
    {
        return(true);
    }

    struct LinkList *pLinkList;
    pLinkList = (struct LinkList *)pQueue;

    if (pLinkList->length < 1)
    {
        return(true);
    }
    else 
    {
        return(false);
    }
}

//销毁队列
void DestroyQueue(void *pQueue)
{
    if (pQueue == NULL)
    {
        return;
    }

    struct LinkList *pLinkList;
    pLinkList = (struct LinkList *)pQueue;

    DestroyLinkList(pLinkList);
}

BinaryTree.h

#ifndef BINARYTREE_H

    #define BINARYTREE_H

    #include "Queue.h"

    #ifdef __cplusplus
    extern "C"
    {
    #endif 

    struct BinaryNode
    {
        void *pData;                //数据域
        struct BinaryNode *pLeft;   //左孩子
        struct BinaryNode *pRight;  //右孩子
    };

    struct BinaryTree
    {
        struct BinaryNode *pRoot;
        int size;
    };

    void PrintValCallBack(void *pData);

    //创建二叉树
    struct BinaryTree *CreatBinaryTree(void);

    //上下左右顺序往二叉树插入数据指针
    void InsertToBinaryTree(struct BinaryTree *,void *);

    //往二叉搜索树插入数据指针(左边小，右边大)
    void InsertToBinarySearchTree(struct BinaryTree *,void *);
    
    //递归遍历二叉树
    //先序遍历：根左右
    //中序遍历：左根右
    //后序遍历：左右根(深度优先)
    void TraverseTreeRootFirst(struct BinaryTree *,void (*printCallBack)(void*));
    void TraverseTreeRootSecond(struct BinaryTree *,void (*printCallBack)(void*));
    void TraverseTreeRootThird(struct BinaryTree *,void (*printCallBack)(void*));

    //使用队列层序遍历(广度优先)
    void TraverseTreeSameLavel(struct BinaryTree *,void (*printCallBack)(void*));

    //输出叶子节点
    void PrintLeaves(struct BinaryTree *,void (*printCallBack)(void*));
    
    //求树高
    int GetBinaryTreeHeight(struct BinaryTree *);

    //销毁二叉树
    void DestroyBinaryTree(struct BinaryTree * );

    #ifdef __cplusplus
    }
    #endif 

#endif

BinaryTree.c

#include "BinaryTree.h"

void PrintValCallBack(void *pData)
{
    int *pInt = (int *)pData;
    printf("cur val = %d\n",*pInt);
}

//创建二叉树
struct BinaryTree *CreatBinaryTree(void)
{
    struct BinaryTree *pTree;
    pTree = (struct BinaryTree *)malloc(sizeof(struct BinaryTree));
    if (pTree == NULL)
    {
        return(NULL);
    }

    pTree->pRoot = NULL;
    pTree->size = 0;
    return(pTree);
}

//上下左右顺序往二叉树插入数据指针
void InsertToBinaryTree(struct BinaryTree *pTree,void *pData)
{
    if (pTree == NULL)
    {
        return;
    }
    if (pData == NULL)
    {
        return;
    }

    //创建新节点
    struct BinaryNode *pNewNode;
    pNewNode = (struct BinaryNode *)malloc(sizeof(struct BinaryNode));
    if (pNewNode == NULL)
    {
        return;
    }
    //新节点初始化
    pNewNode->pData = pData;
    pNewNode->pLeft = NULL;
    pNewNode->pRight = NULL;

    // PrintCallBack(pData);

    //使用队列实现上下左右插入
    //队列节点的数据指针为数的节点指针
    //树无根节点
    if (pTree->pRoot == NULL)
    {
        pTree->pRoot = pNewNode;
        pTree->size ++;
        return;
    }

    //树有根节点
    void *pQueue;
    pQueue = CreatQueue();
    PushQueue(pQueue,pTree->pRoot);
    while (1)
    {  
        //当前节点为队列头节点的数据指针
        struct BinaryNode *p = (struct BinaryNode *)GetQueueHead(pQueue);

        // PrintCallBack(p->pData);

        //当前节点无左孩子
        if (p->pLeft == NULL)
        {
            p->pLeft = pNewNode;
            break;
        }
        else 
        {
            PushQueue(pQueue,p->pLeft);
        }

        //当前节点无右孩子
        if (p->pRight == NULL)
        {
            p->pRight = pNewNode;
            break;
        }
        else 
        {
            PushQueue(pQueue,p->pRight);
        }

        PopQueue(pQueue);
    }

    DestroyQueue(pQueue);
    
    pTree->size ++;

}

//获取数据域数值较大的节点
static struct BinaryNode *GetLargerNode(struct BinaryNode *p0,struct BinaryNode *p1)
{
    int *pData0,*pData1;
    pData0 = (int *)(p0->pData);
    pData1 = (int *)(p1->pData);

    if (*pData0 > *pData1)
    {
        return(p0);
    }
    else 
    {
        return(p1);
    }
}

static int InsertBinarySearchTree(struct BinaryNode *pNode,struct BinaryNode *pNewNode)
{
    if (pNode == NULL)
    {
        return(-1);
    }
    if (pNewNode == NULL)
    {
        return(-1);
    }

    //获取数据域数值比较大的节点
    struct BinaryNode *pLargerNode;
    pLargerNode = GetLargerNode(pNode,pNewNode);

    //新节点的数据域数值比当前节点的小
    if (pLargerNode == pNode)
    {
        //当前节点无左孩子
        if (pNode->pLeft == NULL)
        {
            pNode->pLeft = pNewNode;
            return(0);
        }
        //当前节点有左孩子
        else 
        {
            InsertBinarySearchTree(pNode->pLeft,pNewNode);
        }
    }
    //新节点的数据域数值比当前节点的大
    else if (pLargerNode == pNewNode)
    {
        //当前节点无右孩子
        if (pNode->pRight == NULL)
        {
            pNode->pRight = pNewNode;
            return(0);
        }
        //当前节点有右孩子
        else 
        {
            InsertBinarySearchTree(pNode->pRight,pNewNode);
        }
    }
}

//往二叉搜索树插入数据指针(左边小，右边大)
void InsertToBinarySearchTree(struct BinaryTree *pTree,void *pData)
{
    if (pTree == NULL)
    {
        return;
    }
    if (pData == NULL)
    {
        return;
    }

    //创建新节点
    struct BinaryNode *pNewNode;
    pNewNode = (struct BinaryNode *)malloc(sizeof(struct BinaryNode));
    if (pNewNode == NULL)
    {
        return;
    }
    //新节点初始化
    pNewNode->pData = pData;
    pNewNode->pLeft = NULL;
    pNewNode->pRight = NULL;

    //树无根节点
    if (pTree->pRoot == NULL)
    {
        pTree->pRoot = pNewNode;
        pTree->size ++;
        return;
    }

    //树有根节点
    //递归插入
    int ret = InsertBinarySearchTree(pTree->pRoot,pNewNode);
    if (ret == 0)
    {
        pTree->size ++;
    }
}

//对节点先序遍历的递归实现
static void RootFirst(struct BinaryNode *pRoot,void (*printCallBack)(void*))
{
    if (pRoot == NULL)
    {
        return;
    }
    if (printCallBack == NULL)
    {
        return;
    }

    printCallBack(pRoot);

    RootFirst(pRoot->pLeft,printCallBack);

    RootFirst(pRoot->pRight,printCallBack);
}

//先序遍历
void TraverseTreeRootFirst(struct BinaryTree *pTree,void (*printCallBack)(void*))
{
    if (pTree == NULL)
    {
        return;
    }
    if (printCallBack == NULL)
    {
        return;
    }
    RootFirst(pTree->pRoot,printCallBack);
}

//对节点中序遍历的递归实现
static void RootSecond(struct BinaryNode *pRoot,void (*printCallBack)(void*))
{
    if (pRoot == NULL)
    {
        return;
    }
    if (printCallBack == NULL)
    {
        return;
    }

    RootSecond(pRoot->pLeft,printCallBack);

    printCallBack(pRoot);

    RootSecond(pRoot->pRight,printCallBack);
}

//中序遍历
void TraverseTreeRootSecond(struct BinaryTree *pTree,void (*printCallBack)(void*))
{
    if (pTree == NULL)
    {
        return;
    }
    if (printCallBack == NULL)
    {
        return;
    }

    RootSecond(pTree->pRoot,printCallBack);
}

//对节点后序遍历的递归实现
static void RootThird(struct BinaryNode *pRoot,void (*printCallBack)(void*))
{
    if (pRoot == NULL)
    {
        return;
    }
    if (printCallBack == NULL)
    {
        return;
    }

    RootThird(pRoot->pLeft,printCallBack);

    RootThird(pRoot->pRight,printCallBack);

    printCallBack(pRoot);
}

//后序遍历
void TraverseTreeRootThird(struct BinaryTree *pTree,void (*printCallBack)(void*))
{
    if (pTree == NULL)
    {
        return;
    }
    if (printCallBack == NULL)
    {
        return;
    }

    RootThird(pTree->pRoot,printCallBack);
}

//使用队列层序遍历(广度优先)
void TraverseTreeSameLavel(struct BinaryTree *pTree,void (*printCallBack)(void*))
{
    if (pTree == NULL)
    {
        return;
    }
    if (printCallBack == NULL)
    {
        return;
    }

    if (pTree->pRoot == NULL)
    {
        return;
    }

    void *pQueue;
    pQueue = CreatQueue();
    PushQueue(pQueue,pTree->pRoot);

    //队列实现同层遍历
    while (1)
    {
        if (IsQueueEmpty(pQueue)== true)
        {
            break;
        }

        struct BinaryNode *pNode;
        pNode = (struct BinaryNode *)GetQueueHead(pQueue);

        //打印当前节点
        printCallBack(pNode);

        if (pNode->pLeft != NULL)
        {
            PushQueue(pQueue,pNode->pLeft);
        }
        if (pNode->pRight != NULL)
        {
            PushQueue(pQueue,pNode->pRight);
        }

        PopQueue(pQueue);
    }

    DestroyQueue(pQueue);
}

static void PrintLeavesNode(struct BinaryNode *pNode,void (*printCallBack)(void*))
{
    if (pNode == NULL)
    {
        return;
    }
    if (printCallBack == NULL)
    {
        return;
    }

    //使用先序递归遍历打印叶子节点
    if ((pNode->pLeft == NULL) && (pNode->pRight == NULL))
    {
        printCallBack(pNode);
        return;
    }
    PrintLeavesNode(pNode->pLeft,printCallBack);
    PrintLeavesNode(pNode->pRight,printCallBack);
}

//输出叶子节点
void PrintLeaves(struct BinaryTree *pTree,void (*printCallBack)(void*))
{
    if (pTree == NULL)
    {
        return;
    }
    if (printCallBack == NULL)
    {
        return;
    }
    PrintLeavesNode(pTree->pRoot,printCallBack);
}

//后序遍历求树高
static int GetHeight(struct BinaryNode *pNode)
{
    //通过后序遍历实现求树的高度
    int h = 0, hl = 0, hr = 0;
	if (pNode==NULL)
    {
		return 0;
	}
    else
    {
		hl = GetHeight(pNode->pLeft);//递归遍历左子树
		hr = GetHeight(pNode->pRight);//递归遍历右子树
		h = (hr > hl) ? (hr) : (hl);
		return (h + 1);
	}
}

//求树高
int GetBinaryTreeHeight(struct BinaryTree *pTree)
{
    int ret;
    if (pTree == NULL)
    {
        ret = 0;
    }
    else 
    {
        ret = GetHeight(pTree->pRoot);
    }
    return(ret);
}

//销毁二叉树
//使用链表暂存节点、并释放对应内存
void DestroyBinaryTree(struct BinaryTree *pTree)
{
    if (pTree == NULL)
    {
        return;
    }

    //树上无根节点
    if (pTree->pRoot == NULL)
    {
        free(pTree);
        return;
    }

    struct LinkList *pLinkList;
    pLinkList = CreatLinkList();
    if (pLinkList == NULL)
    {
        return;
    }

    InsertToLinkListHead(pLinkList,pTree->pRoot);

    int size = pTree->size;

    while (1)
    {
        if (size == 0)
        {
            break;
        }

        struct BinaryNode *pNode;
        pNode = (struct BinaryNode *)GetDataPointerOfFirstNodeInLinkList(pLinkList);

        if (pNode->pLeft != NULL)
        {
            InsertToLinkListTail(pLinkList,pNode->pLeft);
        }

        if (pNode->pRight != NULL)
        {
            InsertToLinkListTail(pLinkList,pNode->pRight);
        }

        free(pNode);
        size --;
    }

    DestroyLinkList(pLinkList);

    free(pTree);
}