(原)----2叉查找树 in C

 

 　　2叉树（Binary Tree）：是每个结点最多有左右两棵子2叉树相连接的树结构。

性质：

• 高度（height）¹：根节点在第0层，树中节点层数的最大值，即外部结点层数的最大值。
• 一棵有N个内部节点的2叉树有N+1个外部节点。

图1

关于2叉树的高度，维基百科²中说的深度，根节点的深度为1。深度为k的2叉树，最多有2^k-1个结点。具体以自己参考书为准。

下面来看看用的比较多的2叉搜索树（图1）

　　2叉搜索树（Binary Search Tree）³:也称有序二叉树（ordered binary tree）,排序二叉树（sorted binary tree），是指一棵空树或者具有下列性质的2叉树：

1. 若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
2. 任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
3. 任意节点的左、右子树也分别为二叉查找树。
4. 没有键值相等的节点（no duplicate nodes）。

树的遍历（见图1）：

• 前序（preorder）：我们访问该结点，然后访问该结点的左子树和右子树。10、6、4、3、5、8、7、9、12、11、13

//递归前序遍历，中序和后序只需将PRINT（）函数放到中间和后面即可
PRE-TRAVERSE(p_node)

    IF p_node!=NIL

        THEN

            PRINT(p_node)

            PRE-TRAVERSE(p_node_L_child)

            PRE-TRAVERSE(p_node_R_child)    

• 中序（inorder）：我们访问该结点的左子树，然后访问该结点，最后访问右子树。3、4、5、6、7、8、9、10、11、12、13（结果为递增哦）

//非递归中序,前序和后序将压入tmp_node的顺序换下即可
NONREC-INTRAVERSE(p_node)
    STACK-PUSH(p_node)
    WHILE STACK!=NIL
        p_node <- STACK-POP()
        IF p_node是树不是数据项
            将p_node结点数据项赋值给tmp_node
            STACK-PUSH(p_node_R_child)
            STACK-PUSH(tmp_node)
            STACK-PUSH(p_node_L_child)
        ELSE
            PRINT(p_node)

• 后序（postorder）：我们访问该结点的左子树和右子树，然后访问该节点。3、5、4、7、9、8、6、11、13、12、10
• 层序（level-order）:从上到下，从左到右的遍历树的结点。10、6、12、4、8、11、13、3、5、7、9

//层次遍历
LEVEL-TRAVERSE(p_node)
    QUEUE-IN(p_node)
    WHILE QUEUE != NIL
        p_node <- QUEUE-OUT()
        PRINT(p_node)
        QUEUE-IN(p_node_L_child)
        QUEUE-IN(p_node_R_child)

CODE：

#include<stdio.h>
#include<stdlib.h>
#define N 15    
int const *p;    /*指向数组s[]的指针*/
/*************************************************
**树的定义、初始化、插入节点
**前序递归遍历树(中序、后序)
**叶子数、深度、每层结点数
**version:1.0
*************************************************/
/*树的结点*/
typedef struct node
{
    int item;
    struct node *l,*r;
}tree_node;
typedef struct
{
    tree_node tn[N];
    int cur;
}m_arr_tree;
/*初始化树*/
void treeInit(m_arr_tree **mat)
{
    *mat=(m_arr_tree *)calloc(1,sizeof(m_arr_tree));
    (*mat)->cur=0;
}
/*储存树*/
tree_node * treePush(m_arr_tree *mat,int item)
{
    mat->tn[mat->cur].item=item;
    return mat->tn+mat->cur++;    /*返回该节点的地址，并使数组下标加1*/
}
/*前序插入树的节点*/
tree_node *treePreInsert(m_arr_tree *mat)
{
    tree_node *node=NULL;
    if(*p==0)    
        ++p;
    else
    {
        node=treePush(mat,*p++);
        node->l=treePreInsert(mat);
        node->r=treePreInsert(mat);
    }
    return node;
}
/*打印树*/
void printNode(int c,int width)
{
    while(width-->0)
        printf("#");
    printf("%d
",c);

}
/*递归前序遍历，中序和后序只需将打印函数放到中间和后面*/
void preTraverse(tree_node *node,int width)
{
    if(node==NULL)
    {
        printNode(0,width);    /* 打印叶子节点是左右孩子都是0 */
        return;
    }
    printNode(node->item,width);
    preTraverse(node->l,width+1);
    preTraverse(node->r,width+1);
}
/*树的叶子个数*/
int treeLeaves(tree_node * node)
{
    if(node==NULL)
        return 0;
    if(node->l==NULL && node->r==NULL)
        return 1;
    int l_count=treeLeaves(node->l);
    int r_count=treeLeaves(node->r);
    return l_count+r_count;
}
/*树的深度*/
int treeDepth(tree_node * node)
{
    if(node==NULL)
        return 0;
    int l_depth=treeDepth(node->l);
    int r_depth=treeDepth(node->r);
    if(l_depth>r_depth)
        return l_depth+1;
    else
        return r_depth+1;

}
/*树的每层结点个数*/
void treeLevelNode(tree_node *node,int lev,int lev_num[])
{
    if(node==NULL)
        return;
    lev_num[lev]++;
    treeLevelNode(node->l,lev+1,lev_num);
    treeLevelNode(node->r,lev+1,lev_num);
}
/*************************************************
**队列的定义、初始化、入队列、出队列、判断为空
**层次遍历
**version:1.0
*************************************************/
/*定义队列*/
typedef struct 
{
    tree_node * que[N];    /*存放树结点的指针*/
    int front,tail;
}m_queue;
/*初始化队列*/
void queueInit(m_queue **mq)
{
    *mq=(m_queue *)malloc(sizeof(m_queue));
    (*mq)->front=0;(*mq)->tail=0;
}
/*入队列*/
void queueIn(m_queue *mq,tree_node *node)
{
    mq->tail=(mq->tail+1)%N;
    mq->que[mq->tail]=node;
}
/*出队列*/
tree_node* queueOut(m_queue *mq)
{
    mq->front=(mq->front+1)%N;
    return mq->que[mq->front];
}
/*队列是否为空*/
int queueEmpty(m_queue *mq)
{
    if(mq->front == mq->tail)
        return 1;
    return 0;
}
/*利用队列层次遍历*/
void levelTraverse(tree_node *node)
{
    m_queue * mq;    /*声明队列*/
    queueInit(&mq);queueIn(mq,node);    /*初始化和向队列放入根结点*/
    int node_count=0,node_level_num=2;    /*深度为k，满足2^k-1个结点时，换行*/
    while(!queueEmpty(mq))
    {
        node=queueOut(mq);
        printf("%d ",node->item); ++node_count;
        if(node_count >= node_level_num-1)
        {
            putchar('
');
            node_level_num<<=1;
        }
        if(node->l)queueIn(mq,node->l);    /*压入弹出结点的左右孩子*/
        if(node->r)queueIn(mq,node->r);
    }
    putchar('
');
    free(mq);
}

/*************************************************
**栈的定义、初始化、压栈、弹栈、判断为空
**非递归中序遍历（前序、后序）
**version:1.0
*************************************************/
/*定义栈*/
typedef struct
{
    tree_node * sta[N];
    int cur;
}m_stack;
/*初始化*/
void stackInit(m_stack **ms)
{
    *ms=(m_stack *)malloc(sizeof(m_stack));
    (*ms)->cur=0;
}
/*压栈*/
void stackPush(m_stack * ms,tree_node * node)
{
    ms->sta[ms->cur++]=node;
}
/*弹出栈*/
tree_node *stackPop(m_stack *ms)
{
    return ms->sta[--ms->cur];
}
/*判断为空*/
int stackEmpty(m_stack *ms)
{
    if(ms->cur==0)
        return 1;
    return 0;
}
/*非递归中序遍历栈，弹出元素为数据项，访问它；为一棵树，按希望的顺序压栈*/
void nonRecInTraverse(tree_node *node)
{
    m_arr_tree *tmp_mat;    /*存放弹出的数据项*/
    treeInit(&tmp_mat);

    m_stack *ms;    /*按希望的顺序保存数据项的栈*/
    stackInit(&ms);
    stackPush(ms,node);
    while(!stackEmpty(ms))
    {
        node=stackPop(ms);    
        if(node->l || node->r)    /*是树继续压栈，否则打印该数据项*/
        {
            tree_node *new_node=treePush(tmp_mat,node->item);    
            if(node->r)stackPush(ms,node->r);
            stackPush(ms,new_node);
            if(node->l)stackPush(ms,node->l);
        }
        else
            printf("%d ",node->item);
    }
    putchar('
');
    free(tmp_mat);
    free(ms);
}

int main()
{
    /*0代表外部结点*/
    int s[]={10,6,4,3,0,0,5,0,0,8,7,0,0,9,0,0,12,11,0,0,13,0,0};
    p=s;    /*将全局指针指向数组s，方便前序初始化树*/
    m_arr_tree *head;
    treeInit(&head);
    treePreInsert(head);
//    preTraverse(head->tn,0);    /*递归前序遍历*/
//    levelTraverse(head->tn);    /*层次遍历*/
//    nonRecInTraverse(head->tn);    /*非递归中序遍历*/
//    printf("
number of leaves:%d
",treeLeaves(head->tn));    /*叶子结点数*/
    int d=treeDepth(head->tn);    /*树的深度*/
    printf("
 depth of tree : %d
",d);
    int lev_num[N]={0};    /*每层的节点数*/
    treeLevelNode(head->tn,0,lev_num);
    while(--d>=0)    /*打印每层节点数*/
        printf(" The %d level number of node :%d
",d,lev_num[d]);
    free(head);
    return 0;
}

参考资料：

1. Robert Sedgewick，《算法：C语言实现》，中文版
2. http://zh.wikipedia.org/wiki/%E4%BA%8C%E5%8F%89%E6%A0%91
3. http://zh.wikipedia.org/wiki/%E4%BA%8C%E5%85%83%E6%90%9C%E5%B0%8B%E6%A8%B9
4. http://www.zdyi.com/blog/binary-tree/792

转载请注明：

作者：Timothy_T

地址：http://www.cnblogs.com/jhooon