树的实现

树：

一种非线性的数据结构

由n（n>=0)个节点组成的有限结合
如果n=0，称为空树
如果n>0,则：
    有意个特殊的节点叫根节点（root），只有直接后继，没有直接前驱
    除了根节点以外其他的节点划分成功m（m>=0)个互不相交的有限


节点的度degree ： 该节点拥有的子树的个数称之为该节点的度
    度为0的节点称之为叶子节点
    度不为0的节点称之为分支节点
树的度定义为节点所有节点的度的最大值

节点的直接后继称之为改节点的孩子
    该节点被称之为改子节点的双亲
节点的孩子的孩子...称之为该节点的子孙
    该节点称之为子孙的祖先
同一个双亲的孩子或称为兄弟


节点的层次
    根为第一层
    根的孩子是第二层
    。。。

树的节点的最大层次数称之为数的高度


如果树中的各个子树之间从左到右是有次序的，子树之间的位置不能互换，则称之为有序树，反之，则是无序树，

森林是由n（n>=0）互补相交的树组成的集合；

---

树的操作：

创建
销毁
清空
插入节点
删除节点
获取节点
获取树的节点数
求树的高度
求树的度

普通的树

//linklist.h

#ifndef __LINKLIST_H__
#define __LINKLIST_H__

typedef struct linklistnode {
    struct linklistnode *next;
    int item;
}LinkListNode;

typedef struct linklist {
    LinkListNode header;
    int length;
}LinkList;

LinkList *LinkList_Create();
void LinkList_Destroy(LinkList *list);
void LinkList_Clear(LinkList *list);
int LinkList_Length(LinkList *list);
int LinkList_Insert(LinkList *list, LinkListNode *node, int pos);
LinkListNode *LinkList_Get(LinkList *list, int pos);
LinkListNode *LinkList_Delete(LinkList *list, int pos);

#endif //__LINKLIST_H__

//linklist.c

#include <stdlib.h>

#include "linklist.h"

LinkList *LinkList_Create()
{
    LinkList *ret = NULL;

    ret = malloc(sizeof(LinkList));

    if ( ret != NULL ) {
        ret->length      = 0;
        ret->header.next = NULL;
    }

    return ret;
}

void LinkList_Destroy(LinkList *list)
{
    free(list);
}

void LinkList_Clear(LinkList *list)
{
    if ( list != NULL ) {
        list->length      = 0;
        list->header.next = NULL;
    }
}

int LinkList_Length(LinkList *list)
{
    int ret = -1;

    if ( list != NULL ) {
        ret = list->length;
    }

    return ret;
}

int LinkList_Insert(LinkList *list, LinkListNode *node, int pos)
{
    int ret = list!=NULL && node!=NULL && pos>=0;

    if ( ret ) {
        int i;
        LinkListNode *cur = (LinkListNode*)list;

        for (i=0; i<pos && cur->next!=NULL; i++) {
            cur = cur->next;
        }
        node->next = cur->next;
        cur->next = node;
        list->length++;
    }

    return ret;
}

LinkListNode *LinkList_Get(LinkList *list, int pos)
{
    LinkListNode *ret = NULL;

    if ( list!=NULL && (0<=pos && pos<list->length) ) {
        int i;
        LinkListNode *cur = (LinkListNode*)list;

        for (i=0; i<pos; i++)
            cur = cur->next;
        ret = cur->next;
    }

    return ret;
}

LinkListNode *LinkList_Delete(LinkList *list, int pos)
{
    LinkListNode *ret = NULL;

    if ( list!=NULL && (0<=pos&&pos<list->length) ) {
        int i;
        LinkListNode *cur = (LinkListNode*)list;

        for (i=0; i<pos; i++)
            cur = cur->next;
        ret = cur->next;
        cur->next = ret->next;
        list->length--;
    }

    return ret;
}

//tree.h

#ifndef __TREE_H__
#define __TREE_H__

#include "linklist.h"

typedef void GTree;
typedef void GTreeData;

typedef struct gtreenode        //树的节点
{
    GTreeData *data;
    struct gtreenode *parent;
    LinkList *child;
}GTreeNode;

typedef struct tlnode       //组织链表     链表节点
{
    LinkListNode header;
    GTreeNode *node;
}TLNode;

GTree *GTree_Create();
void GTree_Destroy(GTree *tree);
void GTree_Clear(GTree *tree);
int GTree_Insert(GTree *tree,GTreeData *data, int pPos);

void GTree_Display(GTree *tree,int gap);
GTreeData *GTree_Delete(GTree *tree, int pos);
GTreeData *GTree_Get(GTree *tree, int pos);
GTreeData *GTree_Root(GTree *tree);
int GTree_Count(GTree *tree);
int GTree_Degree(GTree *tree);
int GTree_Height(GTree *tree);

#endif //__TREE_H__

//tree.c
//在这个模块用到了大量的递归

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

#include "tree.h"

GTree *GTree_Create()
{
    return LinkList_Create();
}

void GTree_Destroy(GTree *tree)
{
    GTree_Clear(tree);
    LinkList_Destroy(tree);
}

void GTree_Clear(GTree *tree)
{
    GTree_Delete(tree,0); 
}

int GTree_Insert(GTree *tree,GTreeData *data, int pPos)
{
    LinkList *list = (LinkList *)tree;
    int ret = list!=NULL && data!=NULL;
    ret = ret && pPos<LinkList_Length(list);//pPos父位置，
    //判断这个在于，pPos永远比length小

    if( ret )
    {
        //指向父节点的组织链表中的节点
        TLNode *pNode =(TLNode *)LinkList_Get(list, pPos);  //pPos为-1返回NULL
        //组织链表中的节点
        TLNode *trNode = malloc(sizeof(TLNode));
        //双亲节点的孩子链表
        TLNode *cldNode = malloc(sizeof(TLNode));
        //新插入的树的节点
        GTreeNode *cNode = malloc(sizeof(GTreeNode));

        ret = ret && trNode!=NULL && cldNode!=NULL;
        ret = ret && cNode!=NULL;

        if( ret )
        {
            //如果插入的是第一个树节点，
            cNode->data = data;
            cNode->parent = NULL;
            cNode->child = LinkList_Create(); //cldNode就在 这个链表中 

            trNode->node = cNode;
            cldNode->node = cNode;  

            LinkList_Insert(list, (LinkListNode *)trNode, LinkList_Length(list));//插入到组织链表中的最后的位置。

            if( pNode!= NULL )
            {
                cNode->parent = pNode->node; 
                LinkList_Insert(pNode->node->child, (LinkListNode *)cldNode, LinkList_Length(pNode->node->child));
                //所以，我们把cldNode放到头节点是pNode->node->child链表中，
            }
            else
            {
                free(cldNode); 
            }
        }
        else
        {
            free(trNode);
            free(cldNode);
            free(cNode);
        }
    }

    return ret;
}


static void recursive_display(GTreeNode *node, int format, int gap)     //format是我们规定的开始的位置
{
    int i;

    for(i=0; i<format; i++)
    {
        printf("%c", ' '); 
    }
    printf("%c", (char)(int)(node->data));
    printf("\n");

    for(i=0; i<LinkList_Length(node->child); i++)
    {
        TLNode *trNode = (TLNode *)LinkList_Get(node->child, i); 
        recursive_display(trNode->node, format+gap, gap);
    }
}


void GTree_Display(GTree *tree, int gap)        //gap是用户规定的每次空几个空格
{
    TLNode *trNode = (TLNode *)LinkList_Get(tree, 0);

    if( trNode != NULL)
    {
        recursive_display(trNode->node, 0, gap); 
    }
}


static void recursive_delete(LinkList *tree , GTreeNode *node)
{
    int i;
    int idx = -1;
    GTreeNode *parent = node->parent;

    for(i=0; i<LinkList_Length(tree); i++)
    {
        TLNode *trNode = (TLNode *)LinkList_Get(tree, i);
        if( node == trNode->node )
        {
            LinkList_Delete(tree, i);
            free(trNode);
            idx = i;
            break;
        }
    }

    if( idx>=0 )
    {
        if( parent!=NULL )
        {
            for(i=0; i<LinkList_Length(parent->child); i++)
            {
                TLNode *trNode = (TLNode *)LinkList_Get(parent->child, i);
                if(trNode->node == node)
                {
                    LinkList_Delete(parent->child, i);
                    free(trNode);
                    break;
                }
            }
        }

        while( LinkList_Length(node->child) >0)
        {
            TLNode *trNode = (TLNode*)LinkList_Get(node->child, 0);
            recursive_delete(tree, trNode->node);
        }

        LinkList_Destroy(node->child);
        free(node);
    }
}


GTreeData *GTree_Delete(GTree *tree, int pos)
{
    TLNode *trNode = (TLNode *)LinkList_Get(tree, pos);
    GTreeData *ret = NULL;

    if( trNode != NULL )
    {
        ret = trNode->node->data;
        recursive_delete(tree, trNode->node);
    }

    return ret;
}

GTreeData *GTree_Get(GTree *tree, int pos)
{
    TLNode *trNode = (TLNode *)LinkList_Get(tree,pos);
    GTreeData *ret=NULL;

    if(trNode!=NULL)
        ret = trNode->node->data;

    return ret;
}

//求树的根节点
GTreeData *GTree_Root(GTree *tree)
{
    return GTree_Get(tree, 0);
}

int GTree_Count(GTree *tree)
{
    return LinkList_Length(tree);
}

static int recursive_degree(GTreeNode *node)
{
    int ret = -1;

    if(node !=NULL)
    {
        int i;
        int subDegree = 0;

        ret = LinkList_Length(node->child);
        for(i=0; i<LinkList_Length(node->child); i++)
        {
            TLNode *trNode = (TLNode *)LinkList_Get(node->child, i);
            subDegree = recursive_degree(trNode->node);
            if( subDegree > ret)
                ret = subDegree;
        }
    }

    return ret;
}

//求数的度
int GTree_Degree(GTree *tree)
{
    TLNode *trNode = (TLNode *)LinkList_Get(tree, 0);
    int ret = -1;

    if(trNode != NULL)
        ret = recursive_degree(trNode->node);

    return ret;
}

static int recursive_height(GTreeNode *node)
{
    int ret = 0;

    if( node!=NULL )
    {
        int i;
        int subHeight = 0;

        for( i=0; i<LinkList_Length(node->child); i++)
        {
            TLNode *trNode = (TLNode *)LinkList_Get(node->child, i);
            subHeight = recursive_height(trNode->node);
            if( ret < subHeight )
                ret = subHeight;
        }

        ret +=1;
    }

    return ret;
}

//树的高度
int GTree_Height(GTree *tree)
{
    TLNode *trNode = (TLNode*)LinkList_Get(tree, 0 );
    int ret = 0;

    if( trNode != NULL )
    {
        ret = recursive_height(trNode->node); 
    }

    return ret;
}

//main.c

#include <stdio.h>

#include "linklist.h"
#include "tree.h"

int main( void )
{
    GTree *tree = GTree_Create();
    GTree_Insert(tree, (GTreeData *)'A', -1);
    GTree_Insert(tree, (GTreeData *)'B',  0);
    GTree_Insert(tree, (GTreeData *)'C',  0);
    GTree_Insert(tree, (GTreeData *)'D',  0);
    GTree_Insert(tree, (GTreeData *)'E',  1);
    GTree_Insert(tree, (GTreeData *)'F',  1);
    GTree_Insert(tree, (GTreeData *)'G',  3);
    GTree_Insert(tree, (GTreeData *)'H',  3);
    GTree_Insert(tree, (GTreeData *)'I',  3);

    printf("degree = %d\n",GTree_Degree(tree));

    GTree_Display(tree,4);

    printf("get=%c\n",GTree_Get(tree, 2));


    GTree_Delete(tree,2);
    printf("after delete C:\n");
    GTree_Display(tree,4);

    printf("get=%c\n",GTree_Get(tree, 2));

    GTree_Delete(tree,1);
    printf("after delete B:\n");
    GTree_Display(tree,4);



    GTree_Destroy(tree);

    return 0;
}

//Makefile

cc :=gcc

main : main.o linklist.o tree.o
    gcc $^ -o $@


.PHONY : main clean

clean:
    rm -rf *.o main

二叉树的实现

二叉数的层次遍历是用队列去实现的。

//linklist.h

#ifndef __LINKLIST_H__
#define __LINKLIST_H__

typedef struct linklistnode {
    struct linklistnode *next;
    int item;       //自身的一些数据和其他的数据
}LinkListNode;

typedef struct linklist {
    LinkListNode header;
    int length;
}LinkList;

LinkList *LinkList_Create();
void LinkList_Destroy(LinkList *list);
void LinkList_Clear(LinkList *list);
int LinkList_Length(LinkList *list);
int LinkList_Insert(LinkList *list, LinkListNode *node, int pos);
LinkListNode *LinkList_Get(LinkList *list, int pos);
LinkListNode *LinkList_Delete(LinkList *list, int pos);

#endif //__LINKLIST_H__

//linklist.c

#include <stdlib.h>

#include "linklist.h"

LinkList *LinkList_Create()
{
    LinkList *ret = NULL;

    ret = malloc(sizeof(LinkList));

    if ( ret != NULL ) {
        ret->length      = 0;
        ret->header.next = NULL;
    }

    return ret;
}

void LinkList_Destroy(LinkList *list)
{
    free(list);
}

void LinkList_Clear(LinkList *list)
{
    if ( list != NULL ) {
        list->length      = 0;
        list->header.next = NULL;
    }
}

int LinkList_Length(LinkList *list)
{
    int ret = -1;

    if ( list != NULL ) {
        ret = list->length;
    }

    return ret;
}

int LinkList_Insert(LinkList *list, LinkListNode *node, int pos)
{
    int ret = list!=NULL && node!=NULL && pos>=0;

    if ( ret ) {
        int i;
        LinkListNode *cur = (LinkListNode*)list;

        for (i=0; i<pos && cur->next!=NULL; i++) {
            cur = cur->next;
        }
        node->next = cur->next;
        cur->next = node;
        list->length++;
    }

    return ret;
}

LinkListNode *LinkList_Get(LinkList *list, int pos)
{
    LinkListNode *ret = NULL;

    if ( list!=NULL && (0<=pos && pos<list->length) ) {
        int i;
        LinkListNode *cur = (LinkListNode*)list;

        for (i=0; i<pos; i++)
            cur = cur->next;
        ret = cur->next;
    }

    return ret;
}

LinkListNode *LinkList_Delete(LinkList *list, int pos)
{
    LinkListNode *ret = NULL;

    if ( list!=NULL && (0<=pos&&pos<list->length) ) {
        int i;
        LinkListNode *cur = (LinkListNode*)list;

        for (i=0; i<pos; i++)
            cur = cur->next;
        ret = cur->next;
        cur->next = ret->next;
        list->length--;
    }

    return ret;
}

//linkstack.h

#ifndef __LINKSTACK_H__
#define __LINKSTACK_H__

typedef struct linkstacknode {
    struct linkstacknode *next;
    void *item;
}LinkStackNode;

typedef void LinkStack;

LinkStack *LinkStack_Create();
void LinkStack_Destroy(LinkStack *stack);
void LinkStack_Clear(LinkStack *stack);
int LinkStack_Push(LinkStack *stack, void *item);
void *LinkStack_Pop(LinkStack *stack);
void *LinkStack_Top(LinkStack *stack);
int LinkStack_Size(LinkStack *stack);

#endif //__LINKSTACK_H__

//linkstack.c

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

#include "linkstack.h"
#include "linklist.h"

LinkStack *LinkStack_Create()
{
    return LinkList_Create();
}

void LinkStack_Destroy(LinkStack *stack)
{
    LinkStack_Clear(stack);
    LinkList_Destroy(stack);
}

void LinkStack_Clear(LinkStack *stack)
{
    while ( LinkStack_Size(stack) > 0 )
        LinkStack_Pop(stack);
}

int LinkStack_Push(LinkStack *stack, void *item)
{
    LinkStackNode *node = malloc(sizeof(LinkStackNode));
    int ret = stack!=NULL && item!=NULL && node!=NULL;

    if ( ret ) {
        memset(node, 0x00, sizeof(*node));
        node->item = item;
        ret = LinkList_Insert(stack, (LinkListNode*)node, 0);
    }

    if ( !ret ) {
        free(node);
    }

    return ret;
}

void *LinkStack_Pop(LinkStack *stack)
{
    LinkStackNode *node = NULL;
    void *ret = NULL;

    node = (LinkStackNode*)LinkList_Delete(stack, 0);//返回要删除的节点，给node

    if ( node != NULL ) {
        ret = node->item;
        free(node);
    }

    return ret;
}

void *LinkStack_Top(LinkStack *stack)
{
    LinkStackNode *node= NULL;
    void *ret = NULL;

    node = (LinkStackNode*)LinkList_Get(stack, 0);

    if ( node != NULL ) {
        ret = node->item;
    }

    return ret;
}

int LinkStack_Size(LinkStack *stack)
{
    return LinkList_Length(stack);
}

//squeue.h

#ifndef __SQUEUE_H__
#define __SQUEUE_H__

#include "linkstack.h"

typedef struct squeue
{
    LinkStack *inStack;
    LinkStack *outStack;
}SQueue;

SQueue *SQueue_Create();
void SQueue_Destroy(SQueue *queue);
void SQueue_Clear(SQueue *queue);
int SQueue_Append(SQueue *queue, void *item);
void *SQueue_Retrieve(SQueue *queue);
void *SQueue_Header(SQueue *queue);
int SQueue_Length(SQueue *queue);

#endif //__SQUEUE_H__

//squeue.c

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

#include "linkstack.h"
#include "squeue.h"

SQueue *SQueue_Create()
{
    SQueue *ret = malloc(sizeof(SQueue));

    if( ret!=NULL )
    {
        ret->inStack = LinkStack_Create();
        ret->outStack = LinkStack_Create();

        if( ret->inStack==NULL || ret->outStack==NULL )
        {
            LinkStack_Destroy(ret->inStack); 
            LinkStack_Destroy(ret->outStack); 
            free(ret);
            ret = NULL;
        }
    }

    return ret;
}

void SQueue_Destroy(SQueue *queue)
{
    SQueue_Clear(queue);
    free(queue);
}

void SQueue_Clear(SQueue *queue)
{
    if( queue!=NULL )
    {
        LinkStack_Clear(queue->inStack); 
        LinkStack_Clear(queue->outStack); 
    }
}

int SQueue_Append(SQueue *queue, void *item)
{
    int ret = queue!=NULL;

    if( ret )
    {
        ret = LinkStack_Push(queue->inStack, item);
    }

    return ret;
}

void *SQueue_Retrieve(SQueue *queue)
{
    void *ret = NULL;

    if( queue != NULL )
    {
        if( LinkStack_Size(queue->outStack) == 0 )  //out为空的时候
        {
            while ( LinkStack_Size(queue->inStack) > 0 )//同时in不为空,那么
            {
                LinkStack_Push(queue->outStack, LinkStack_Pop(queue->inStack)); 
                //从in里面弹出，并进入out里面 
            }
        }

        ret = LinkStack_Pop(queue->outStack); //out不为空的时候，直接让它弹出
    }
    return ret;
}

//队头
void *SQueue_Header(SQueue *queue)
{
    void *ret = NULL;

    if( queue != NULL )
    {
        if( LinkStack_Size(queue->outStack) == 0 )  //out为空的时候
        {
            while ( LinkStack_Size(queue->inStack) > 0 )//同时in不为空,那么
            {
                LinkStack_Push(queue->outStack, LinkStack_Pop(queue->inStack)); 
                //从in里面弹出，并进入out里面 
            }
        }

        ret = LinkStack_Top(queue->outStack); //out不为空的时候，直接让Top取出
    }

    return ret;
}
int SQueue_Length(SQueue *queue)
{
    int ret = -1;

    if( queue != NULL )
    {
        ret = LinkStack_Size(queue->inStack) + LinkStack_Size(queue->outStack); 
    }

    return ret;
}

//btree.h

#define BT_RIGHT 1

typedef struct btnode
{
    struct btnode *left;
    struct btnode *right;
    char v;
}BTreeNode;

typedef struct btree
{
    BTreeNode *root;
    int count;
}BTree;

BTree *BTree_Create();
void BTree_Destroy(BTree *tree);
void BTree_Clear(BTree *tree);
int BTree_Insert(BTree *tree, BTreeNode *node,BTPos pos,int count,int flag);
void BTree_Display(BTree *tree, void (*pf)(BTreeNode*), int gap, char div);
BTreeNode *BTree_Delete(BTree *tree, BTPos pos, int count);
BTreeNode *BTree_Get(BTree *tree, BTPos pos, int count);
BTreeNode *BTree_Root(BTree *tree);
int BTree_Height(BTree *tree);
int BTree_Degree(BTree *tree); 
void pre_oder_travesal(BTreeNode *root);
void mid_oder_travesal(BTreeNode *root);
void pos_oder_travesal(BTreeNode *root);
void leve_order_travesal(BTreeNode *root);

#endif //__BTEE_H__

//btree.c

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

#include "btree.h"
#include "squeue.h"

BTree *BTree_Create()
{
    BTree *ret = malloc (sizeof(BTree));

    if( ret != NULL )
    {
        ret->count = 0;
        ret->root = NULL;
    }

    return ret;
}

void BTree_Destroy(BTree *tree)
{
    free(tree);
}

void BTree_Clear(BTree *tree)
{
    if( tree!=NULL )
    {
        tree->count = 0;
        tree->root = NULL;
    }
}

//count是走的步数，flag是你将来的孩子接那边
int BTree_Insert(BTree *tree, BTreeNode *node,BTPos pos, int count,int flag)
{
    int ret = tree!= NULL && node != NULL;
    ret = ret && (flag==BT_LEFT || flag==BT_RIGHT); //用户给的这个标记要等于1或0的

    if( ret )
    {
        int bit = 0;    //按位相与后的结构
        BTreeNode *parent = NULL;
        BTreeNode *cur = tree->root;
        node->left = NULL;
        node->right = NULL;

        while( count>0 && cur!=NULL )
        {
            bit = pos & 1;  //pos为二进制数
            pos >>= 1;

            parent = cur;
            if( bit == BT_LEFT )
            {
                cur = cur->left;
            }
            else if (bit == BT_RIGHT )
            {
                cur = cur->right;
            }
            count--;        //层数
        }

        if(flag == BT_LEFT )
            node->left = cur;
        else if (flag == BT_RIGHT)
            node->right = cur;
        if(parent == NULL )
        {
            tree->root = node;   //
        }
        else
        {
            if(bit == BT_LEFT)
                parent->left = node;
            else if( bit == BT_RIGHT)
                parent->right =node;
        }
        tree->count++;
    }

    return ret;
}

static void recursive_display(BTreeNode *node , void (*pf)(BTreeNode*), int format, int gap, char div)//gap是每次变几个,div方式是-,format是开始空几个空格
{
    int i;

    if( node!=NULL && pf!=NULL )
    {
        for(i=0; i<format; i++)
            printf("%c", div);

        pf(node);
        printf("\n");
        if(node->left!=NULL || node->right!=NULL)
        {
            recursive_display(node->left, pf, format+gap, gap, div);
            recursive_display(node->right, pf, format+gap, gap, div);
        }
    }
    else
    {
        for(i=0; i<format; i++)
            printf("%c", div);
        printf("\n");
    }

}

//显示
void BTree_Display(BTree *tree, void (*pf)(BTreeNode*), int gap, char div)
{
    if( tree!=NULL )
    {
        recursive_display(tree->root, pf, 0, gap, div); 
    }
}

static int recursive_count(BTreeNode *root)
{
    int ret = 0;

    if( root!=NULL )
    {
        ret = recursive_count(root->left) + recursive_count(root->right)+1; 
    }

    return ret;
}

//删除
BTreeNode *BTree_Delete(BTree *tree, BTPos pos, int count)
{
    BTreeNode *ret = NULL;
    int bit = 0;

    if( tree !=NULL )
    {
        int bit = 0 ;
        BTreeNode *parent = NULL;
        BTreeNode *cur = tree->root;

        while( count>0 && cur!=NULL )
        {
            bit = pos & 1;
            pos >>= 1;
            parent = cur;

            if(bit == BT_LEFT )
                cur = cur->left;
            else
                cur = cur->right;
            count--;
        }

        if( parent == NULL )    //如果删除的是第一个节点，那么就直接让他为空
            tree->root = NULL; 
        else 
        {
            if(bit == BT_LEFT )
                parent->left = NULL;
            else
                parent->right = NULL;
        }

        ret = cur;
        tree->count -= recursive_count(ret);
    }

    return ret;

}

//获得
BTreeNode *BTree_Get(BTree *tree, BTPos pos, int count)
{
    BTreeNode *ret = NULL;

    if( tree!=NULL )
    {
        BTreeNode *cur = tree->root;
        while (count>0 && cur !=NULL )
        {
            int bit = pos & 1;
            pos >>=1;

            if( bit == BT_LEFT )
            {
                cur =cur->right; 
            }
            count--;
        }

        ret = cur;

    }

    return ret;
}

BTreeNode *BTree_Root(BTree *tree)
{
    return BTree_Get(tree, 0x00, 0);
}

static int recursive_height(BTreeNode *node)
{
    int ret = 0;

    if( node!=NULL )
    {
        int lh = recursive_height(node->left);
        int rh = recursive_height(node->right);
        ret = (lh>rh ? lh : rh) + 1;
    }

    return ret;
}

int BTree_Height(BTree *tree)
{
    int ret = 0;

    if( tree!=NULL )
    {
        ret = recursive_height(tree->root);
    }

    return ret;
}

static int recursive_degree(BTreeNode *root)
{
    int ret = 0;

    if( root!=NULL )
    {
        if(root->left!=NULL)
            ret++;
        if(root->right!=NULL)
            ret++;
        if(ret == 1)
        {
            int ld = recursive_degree(root->left); 
            int rd = recursive_degree(root->right); 
            if( ret<ld )
                ret = ld;
            if( ret<rd )
                ret = rd;
        }
    }

    return ret;
}

int BTree_Degree(BTree *tree)
{
    int ret = 0;

    if( tree!=NULL )
    {
        ret = recursive_degree(tree->root); 
    }

    return ret;
}

//前序遍历
void pre_oder_travesal(BTreeNode *root)
{
    if( root!=NULL )
    {
        printf("%c ", root->v); 
        pre_oder_travesal(root->left);
        pre_oder_travesal(root->right);
    }
}

//中序遍历
void mid_oder_travesal(BTreeNode *root)
{
    if( root!=NULL )
    {
        mid_oder_travesal(root->left);
        printf("%c ", root->v); 
        mid_oder_travesal(root->right);
    }
}

//后序遍历
void pos_oder_travesal(BTreeNode *root)
{
    if( root!=NULL )
    {
        pos_oder_travesal(root->left);
        pos_oder_travesal(root->right);
        printf("%c ", root->v); 
    }
}

//层序遍历
//用队列去实现层序遍历，队列又是由两个栈去实现，而栈又是由链表去封装。
void level_order_travesal(BTreeNode *root)
{
    SQueue *queue = SQueue_Create();
    if( root!=NULL )
    {
        if( queue!=NULL )
        {
            SQueue_Append(queue,root);
            while( SQueue_Length(queue ) > 0 )
            {
                BTreeNode *node = SQueue_Retrieve(queue);
                printf("%c ",node->v);
                SQueue_Append(queue, node->left);
                SQueue_Append(queue, node->right);
            }
        }
    }
    SQueue_Destroy(queue);
}

//main.c

//二叉树的实现

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

#include "btree.h"
#include "squeue.h"

void print(BTreeNode *node)
{
    printf("%c", node->v);
}

int main( void )
{
    BTree *tree = BTree_Create();
    BTreeNode na = {NULL,NULL,'A'};
    BTreeNode nb = {NULL,NULL,'B'};
    BTreeNode nc = {NULL,NULL,'C'};
    BTreeNode nd = {NULL,NULL,'D'};
    BTreeNode ne = {NULL,NULL,'E'};
    BTreeNode nf = {NULL,NULL,'F'};

    BTree_Insert(tree, &na, 0x00, 0, 0);
    BTree_Insert(tree, &nb, 0x00, 1, 0);
    BTree_Insert(tree, &nc, 0x01, 1, 0);
    BTree_Insert(tree, &nd, 0x00, 2, 0);
    BTree_Insert(tree, &ne, 0x02, 2, 0);
    BTree_Insert(tree, &nf, 0x02, 3, 0);

    printf("get = %c\n",BTree_Get(tree, 0x00, 1)->v);
    printf("root =  %c\n",BTree_Root(tree)->v);
    printf("height = %d\n",BTree_Height(tree));

    printf("level:\n");
    level_order_travesal(tree->root);
    printf("\n");

    printf("pre:\n");
    pre_oder_travesal(tree->root);
    printf("\n");
    printf("mid:\n");
    mid_oder_travesal(tree->root);
    printf("\n");
    printf("pos:\n");
    pos_oder_travesal(tree->root);
    printf("\n");

    BTree_Delete(tree, 0x01, 1);    //删除C后
    BTree_Display(tree, print, 4, '-');
    printf("degree = %d\n",BTree_Degree(tree));

    BTree_Delete(tree, 0x00, 2);    //删除D后
    BTree_Display(tree, print, 4, '-');
    printf("degree = %d\n",BTree_Degree(tree));

    BTree_Delete(tree,0x00,1);
    printf("after delete b:\n");
    BTree_Display(tree, print, 4, '-');

    BTree_Destroy(tree);

}