用c语言编写一个函数实现判定二叉树是否为二叉排序树，status JudgeBiTree(BiTree T)，判定以二叉链表存储的二叉树是否为二叉排序树，是则返回YES，不是返回NO。

好的，这是一个比较基础的二叉树题目，下面是实现代码：

typedef struct BiTNode{
    int data;
    struct BiTNode *lchild, *rchild;
}BiTNode, *BiTree;

int JudgeBST(BiTree T, int min, int max){
    if(T == NULL) return 1; //空树为二叉排序树
    if(T->data < min || T->data > max) return 0; //不符合条件直接返回
    //递归左右子树
    return JudgeBST(T->lchild, min, T->data-1) && JudgeBST(T->rchild, T->data+1, max);
}

status JudgeBiTree(BiTree T){
    return JudgeBST(T, INT_MIN, INT_MAX) ? YES : NO;
}

这里用到了一个递归的方法，对于每个节点，判断它的值是否在指定的范围内（即左子树的值都小于该节点，右子树的值都大于该节点），然后递归判断左右子树是否满足条件即可。

相关问题

请用C语言编写一个算法，删除二叉树中所有以值x为根的子树，并释放相应的空间。二叉树采用二叉链表方式存储。二叉树的存储采用biTree.c中的结构完成，运行结果可随机

以下是用C语言编写的算法，删除二叉树中所有以值x为根的子树，并释放相应的空间：

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

typedef struct BiNode {
    int data;
    struct BiNode *left;
    struct BiNode *right;
} BiNode, *BiTree;

void createBiTree(BiTree *T) {
    int data;
    scanf("%d", &data);
    if (data == -1) {
        *T = NULL;
    } else {
        *T = (BiNode*)malloc(sizeof(BiNode));
        (*T)->data = data;
        createBiTree(&((*T)->left));
        createBiTree(&((*T)->right));
    }
}

void deleteSubTree(BiTree *T, int x) {
    if (*T == NULL) {
        return;
    }
    if ((*T)->data == x) {
        free(*T);
        *T = NULL;
        return;
    }
    deleteSubTree(&((*T)->left), x);
    deleteSubTree(&((*T)->right), x);
    if ((*T)->left == NULL && (*T)->right == NULL) {
        free(*T);
        *T = NULL;
    }
}

void inorderTraversal(BiTree T) {
    if (T == NULL) {
        return;
    }
    inorderTraversal(T->left);
    printf("%d ", T->data);
    inorderTraversal(T->right);
}

int main() {
    BiTree T;
    int x;
    printf("请输入二叉树的先序遍历序列：\n");
    createBiTree(&T);
    printf("请输入要删除的子树的根节点值：\n");
    scanf("%d", &x);
    deleteSubTree(&T, x);
    printf("删除后的二叉树中序遍历序列为：\n");
    inorderTraversal(T);
    return 0;
}

其中，`createBiTree`函数用于创建二叉树，`deleteSubTree`函数用于删除以值x为根的子树，`inorderTraversal`函数用于中序遍历二叉树。运行程序后，先输入二叉树的先序遍历序列，然后输入要删除的子树的根节点值，最后输出删除后的二叉树中序遍历序列。

用c语言1.编写函数,输入字符序列,建立二叉树的二叉链表 2.编写函数,实现二叉树的中序递归遍历算法。 3.编写函数,实现二叉树的中序非递归遍历算法 4.编写函数,借助队列实现二叉树的层次遍历算法 5.编写函数,求二叉树的高度 6.编写函数,求二叉树的结点个数 7.编写函数,求二叉树的叶子个数 8.编写函数,交换二叉树每个结点的左子树和右子树

这些问题属于编程类问题，我可以回答。

1. 下面是用C语言编写输入字符序列，建立二叉树的二叉链表的函数：

typedef struct BiNode {
    char data;
    struct BiNode *left;
    struct BiNode *right;
} BiNode, *BiTree;

void createBiTree(BiTree *root) {
    char ch;
    scanf("%c", &ch);
    if (ch == '#') {
        *root = NULL;
    } else {
        *root = (BiNode *) malloc(sizeof(BiNode));
        (*root)->data = ch;
        createBiTree(&((*root)->left));
        createBiTree(&((*root)->right));
    }
}

2. 下面是用C语言编写实现二叉树的中序递归遍历算法的函数：

void inOrder(BiTree tree) {
    if (tree != NULL) {
        inOrder(tree->left);
        printf("%c ", tree->data);
        inOrder(tree->right);
    }
}

3. 下面是用C语言编写实现二叉树的中序非递归遍历算法的函数：

void inOrderNonRecursion(BiTree tree) {
    BiNode *stack[10000];
    int top = -1;
    BiNode *p = tree;
    while (p != NULL || top != -1) {
        while (p != NULL) {
            stack[++top] = p;
            p = p->left;
        }
        if (top != -1) {
            p = stack[top--];
            printf("%c ", p->data);
            p = p->right;
        }
    }
}

4. 下面是用C语言编写借助队列实现二叉树的层次遍历算法的函数：

void levelOrder(BiTree tree) {
    BiNode *queue[10000];
    int front = 0, rear = 0;
    if (tree != NULL) {
        queue[++rear] = tree;
        while (front != rear) {
            front++;
            BiNode *p = queue[front];
            printf("%c ", p->data);
            if (p->left != NULL) {
                queue[++rear] = p->left;
            }
            if (p->right != NULL) {
                queue[++rear] = p->right;
            }
        }
    }
}

5. 下面是用C语言编写求二叉树的高度的函数：

int getHeight(BiTree tree) {
    if (tree == NULL) {
        return 0;
    } else {
        int leftHeight = getHeight(tree->left);
        int rightHeight = getHeight(tree->right);
        return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
    }
}

6. 下面是用C语言编写求二叉树的结点个数的函数：

int getNodeCount(BiTree tree) {
    if (tree == NULL) {
        return 0;
    } else {
        return getNodeCount(tree->left) + getNodeCount(tree->right) + 1;
    }
}

7. 下面是用C语言编写求二叉树的叶子个数的函数：

int getLeafCount(BiTree tree) {
    if (tree == NULL) {
        return 0;
    }
    if (tree->left == NULL && tree->right == NULL) {
        return 1;
    } else {
        return getLeafCount(tree->left) + getLeafCount(tree->right);
    }
}

8. 下面是用C语言编写交换二叉树每个结点的左子树和右子树的函数：

void swapBiTree(BiTree tree) {
    if (tree != NULL) {
        BiNode *temp = tree->left;
        tree->left = tree->right;
        tree->right = temp;
        swapBiTree(tree->left);
        swapBiTree(tree->right);
    }
}