判斷一棵二叉樹是否為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;  
    }