树的高度，宽度

//树的孩子兄弟结点定义
typedef struct CSNode
{

    char data;
    CSNode *nextchild,*nextsibling;
} CSNode,*CSTree;



/*
    树的一些递归算法一定要知道
*/

//树的高度
int Height(CSTree bt)
{
    int hl,hr;

    if(bt ==NULL)
        return 0;

    else
    {
        hl = Height(bt->nextchild);
        hr = Height(bt->nextsibling);

        if(hl>hr)
            return hl+1;//

        return hr;
    }
}//end Height


//二叉树的高度(递归)
int Height(Tree T)
{
    if(T == NULL)
        return 0;

    int hl = Height(T->lchild);
    int hr = Height(T->rchild);

    return hl>hr? hl+1: hr+1;
}


/*
    非递归求二叉树的高度(实现方法1)

    思想：层次遍历
    1.用level记录当前结点的层数
    2.设置last，指向当前层的最后一个结点
    3.每次出队时 front-1 = last,若相等则level+1,且last指向下一层最后一个结点
    4.直至遍历玩整颗树

*/
int Height_non_recursion1(Tree T)
{


    if(T == NULL)
        return 0;

    Tree p;

    int front = rear = 0;
    int last = level = 0;//last指向当前层最后一个结点

    Tree Q[maxSize];

    Q[rear] = T;
    rear = (rear+1)%maxSize;//根节点入队


    while(front !=rear)
    {
        p = Q[front];

        front = (front+1)%maxSize;//出队

        if(p->lchild == NULL)//思想同层次遍历
        {
            Q[rear] = p->lchild;
            rear = (rear+1)%maxSize;
        }

        if(p->rchild == NULL)
        {
            Q[rear] = p->rchild;
            rear = (rear+1)%maxSize;
        }

        if(front -1 == last)
        {
            level++;//本层的结点遍历完了层数++
            last = rear;
        }

    }//end while

    return level;


}

/*
    思想：层次遍历
    1.求出每个结点对应的层号
    2.统计每层结点个数(通过层号来确定)
    3.返回求的的最大值
*/
//自定义队列
typedef struct
{
    Tree p;
    int lno;//结点的层号
}St;

int Height_non_recursion2(Tree T)
{
    St que[maxSize];
    Tree q;
    int front = rear =0;
    int i,j,n,max,Lno;//其中Lno记录当前结点的层号

    if(T != NULL)
    {

        que[rear].p = T;//根节点入队列
        que[rear++].lno = 1;//树的根节点的层数设置为1

        while(front != rear)//队列不空
        {
            q = que[front].p;
            Lno = que[front++].lno;

            if(q->lchild !=NULL)//左右孩子结点入队列
            {
                que[rear].p = q->lchild;
                que[rear++].lno = Lno+1;//q的孩子结点层数+1
            }

            if(q->rchild !=NULL)
            {
                que[rear].p = q->rchild;
                que[rear++].lno = Lno+1;//q的孩子结点层数+1
            }

        }//end while

        max =0;
        /*
            其中Lno为本树的高度
        */

        //下面循环求树的宽度
        for(i=1;i<=Lno;i++)
        {
            n = 0;//用于计数
            for(j=0;j<rear;j++)
                if(que[j].lno == i)
                    n++;

            if(max<n)
                max = n;//更新最大宽度
        }

        return max;

    }//end if

    return 0;//空树返回0

}//end