（二叉搜索树6-8）CheckBST[3]--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 0. 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 = 2

Analysis:

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

Notice：

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

Code:

//先判断是否为搜索二叉树，如果是就返回第K大的结点数值；不是就返回负值的树高（叶结点的定义高度为0）
int GetHeight(BinTree T)
{
    int HL,HR,Max;
    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=T; 
    BinTree a[100]={NULL},b[100]={NULL};
    int ai=0,bi=0;
    while(BT||ai!=0)
    {
        //先处理左子树
        while(BT)//一路找到左子树最后一个元素，并把经过的结点压入堆栈
        {
            a[ai++]=BT;
            BT=BT->Left;
        }
        if(a[ai-1]==NULL)
            ai--;
        int top=--ai;//取栈顶元素的下标
        b[bi++]=a[top];//把栈顶元素储存在b[]数组里
        BT=a[top];//重新赋值BT，相当于中序遍历里的输出根结点数据
        a[top]=NULL;//删除栈顶元素（与上面的if(a[ai-1]==NULL)一起构成）
        BT=BT->Right;//转向右子树
    }
    //判断是否为二叉树，直接判断序列内的数是否是递增
    //从下标为1的结点开始判断：前一个结点的Key是否大于当前结点的Key，是的话则该序列不可能为递增
    for(int i=1;b[i]!=NULL;i++)
    {
        if((b[i-1]->Key)>=(b[i]->Key))
        {
            flag=0;//不是搜索二叉树
            break;
        }
    }
    if(flag==1)//如果是搜索二叉树就返回第K大的数
        return b[bi-K]->Key;
    else//否则，返回负值的树高
        return -(GetHeight(T)-1);
}