判断一棵二叉树是否为BST，一棵树是否为完全二叉树

对于一颗搜索二叉树，最简单的方法就是用中序遍历，看是不是一个递增数列，如果是则是一颗搜索二叉树，如果不是则不是搜索二叉树。在这里用一个lastVisit去记录上一次搜索到的节点。整个过程就是先找到最左下角的节点，更新这个lastVisit为这个节点的值，然后按照中序遍历依次更新即可。代码如下。

#include <stdio.h>
#include <climits>

//二叉树结点
typedef struct binary_tree_node_t{
    binary_tree_node_t * left;
    binary_tree_node_t * right;
    int  elem;

};

//如果是BST, 其中序遍历应该是从小到大的顺序
int lastVisit = INT_MIN;

int judge_BST(binary_tree_node_t * root){
    if(root == NULL){
        return 1;
    }

    int judgeLeft = judge_BST(root->left);//先判断左子树

    if( (root->elem >= lastVisit) && judgeLeft == 1){//当前结点比上次访问的数值要大
        lastVisit = root->elem;
    }else{
        return 0;
    }

    int judgeRight = judge_BST(root->right);//最后右子树

    return judgeRight;

}


//判断一颗二叉树是不是二叉排序树
int main(){
    binary_tree_node_t ns[10];

    for(int i = 1; i <= 6; i++){
        binary_tree_node_t tmp;    
        tmp.elem  = i;
        tmp.left = NULL;//必须显式初始化为NULL
        tmp.right = NULL;
        ns[i] = tmp;
    }
    
    binary_tree_node_t root;
    root.elem = 4;

    root.left = &ns[2];
    root.right = &ns[5];

    ns[2].left = &ns[1];
    ns[2].right = &ns[3];
     
    ns[5].right = &ns[6];


    printf("%d\n", judge_BST(&root));

    return 0;
}

对于一颗完全二叉树采用广度优先遍历，从根节点开始，入队列，如果队列不为空，循环。遇到第一个没有左儿子或者右儿子的节点，设置标志位，如果之后再遇到有左/右儿子的节点，那么这不是一颗完全二叉树。这个方法需要遍历整棵树，复杂度为O(N)，N为节点的总数。

    //二叉树结点定义  
    typedef struct Node  
    {  
        int data;  
        struct Node* left;  
        struct Node* right;  
    }Node;  
      
    //实现广度遍历需要队列  
    Queue<Node*> queue;  
      
    //第n层最右节点标志  
    bool leftMost = false;  
      
    bool ProcessChild(Node* child)  
    {  
        if (child)  
        {  
            if (!leftMost)  
            {  
                queue.push(child);  
            }  
            else  
            {  
                return false;  
            }  
        }  
        else  
        {  
            leftMost = true;  
        }  
      
        return true;  
    }  
      
    bool IsCompleteBinaryTree(Node* root)  
    {  
        //空树也是完全二叉树  
        if (!root)  
            return true;  
      
        //首先根节点入队列  
        queue.push(root);  
      
        while(!queue.empty())  
        {  
            Node* node = queue.pop();  
      
            //处理左节点  
            if (!ProcessChild(node->left))  
                return false;  
      
            //处理右节点  
            if (!ProcessChild(node->right))  
                return false;  
        }  
      
        //广度优先遍历完毕，此乃完全二叉树  
        return true;  
    }