CheckBST[1]--C语言

Given a binary tree, you are supposed to tell if it is a binary search tree. If the answer is yes, try to find the K-th largest key, else try to find the height of the tree.

Format of function:

int CheckBST ( BinTree T, int K );

where BinTree is defined as the following:

typedef struct TNode *BinTree;
struct TNode{
int Key;
BinTree Left;
BinTree Right;
};

The function CheckBST is supposed to return the K-th largest key if T is a binary search tree; or if not, return the negative height of T (for example, if the height is 5, you must return −5).

Here the height of a leaf node is defined to be 1. T is not empty and all its keys are positive integers. K is positive and is never more than the total number of nodes in the tree.

Sample program of judge:

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

typedef struct TNode *BinTree;
struct TNode{
    int Key;
    BinTree Left;
    BinTree Right;
};

BinTree BuildTree(); /* details omitted */
int CheckBST ( BinTree T, int K );

int main()
{
    BinTree T;
    int K, out;

    T = BuildTree();
    scanf("%d", &K);
    out = CheckBST(T, K);
    if ( out < 0 )
        printf("No.  Height = %d\n", -out);
    else
        printf("Yes.  Key = %d\n", out);

    return 0;
}
/* 你的代码将被嵌在这里 */

Sample Input 1:(for the following tree)

4

Sample Output 1:

Yes.  Key = 5

Sample Input 2:(for the following tree)

3

Sample Output 2:

No.  Height = 3

Analysis:

用中序遍历得到序列，判断是否二叉树就直接判断序列是否递增，如果不是搜索二叉树，就求树的高度；如果是，则输出倒数第k个数，即为第k大的数。

Notice：

• 输出倒数第k个数，先遍历一遍序列得到该序列一共有count个数，则倒数第k个的表达为(count-k)。
• 如果对中序遍历得到序列还不清楚，可以去看是否二叉搜索树，在这篇文章中我对中序遍历得到序列有具体分析。

Code:

int GetHeight(BinTree T)
{
    int HL,HR;
    int Max=0;
    if(T)
    {
        HL=GetHeight(T->Left);
        HR=GetHeight(T->Right);
        if(HL>HR)
            Max=HL;
        else
            Max=HR;
        return Max+1;
    }
    else
        return 0;
}
int CheckBST ( BinTree T, int K )
{
    int flag=-1;
    //中序法得到顺序序列
    BinTree BT; 
    BinTree a[100]={NULL};
    BinTree b[100]={NULL};
    int ai,bi;
    ai=bi=0;
    BT=T;
    while(BT||ai!=0)
    {
        while(BT)
        {
            a[ai]=BT;
            ai++;
            BT=BT->Left;
        }
        if(a[ai-1]==NULL)
        {
            ai--;
        }
        b[bi]=a[ai-1];
        BT=a[ai-1];
        a[ai-1]=NULL;
        bi++;
        ai--;
        BT=BT->Right;
    }
    //判断是否为二叉树，直接判断序列内的数是否是递增
    for(int i=1;b[i]!=NULL;i++)
    {
        if((b[i-1]->Key)>=(b[i]->Key))
        {
            flag=0;//不是搜索二叉树
            break;
        }
    }
    if(flag==-1)
        flag=1;
    int count=0;
    for(int i=0;b[i]!=NULL;i++)
        count++;
    if(flag==1)
    {
        return b[count-K]->Key;
    }
    else//返回树高
    {
        int H=GetHeight(T);
        return -H;
    }
}