二叉搜索树(BST)

数据域大小关系：

　　根>左，根<右

假设所有二叉树的所有结点数据都是正数，且两两不同

arr   6,3,8,2,5,1,7

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

typedef struct node{
    int data;
    struct node* left;
    struct node* right;
} Node;

typedef struct{
    Node* root;
} Tree;

void insert(Tree* tree, int value)
{
    Node* node= malloc(sizeof(Node));
    node -> data  = value;
    node -> left  = NULL;
    node -> right = NULL;
    
    if(tree -> root == NULL){
        tree -> root = node;
        return ;
    }
    else
    {
        Node* temp = tree -> root;
        while(temp != NULL){
            if(temp -> data > value){
                //走左边有两种情况 
                if(temp -> left == NULL){
                    temp -> left = node;
                    return;
                }
                else
                    temp = temp -> left;
            }
            if(temp -> data < value){
                if(temp -> right == NULL){
                    temp -> right = node;
                    return;
                }
                else
                    temp = temp -> right;
            }
        }
    }
}
int get_height(Node* node)//为了便于递归的进行 
{
    if(node == NULL)
        return 0;
    else
    {
        int h_left  = get_height(node -> left);
        int h_right = get_height(node -> right);
        int max = h_left;
        if(max < h_right){
            max = h_right;
        }
        return max + 1;
    }
}
int get_maximum(Node* node)
{
    if(node == NULL)
        return -1;//所有节点全为正数时 
    else{
        int m1 = get_maximum(node -> left);
        int m2 = get_maximum(node -> right);
        int m3 = node -> data;
        int max = m1;
        if(m2>max) {
            max = m2;
        }
        if(m3>max){
            max = m3;
        }
        return max;
    } 
}

void preorder(Node* node){
    if(node != NULL){
        printf("%d
",node -> data);
        preorder(node -> left);
        preorder(node -> right);
    }
}
void inorder(Node* node){
    if(node != NULL){
        inorder(node -> left);
        printf("%d
",node -> data);
        inorder(node -> right);
    }
}
void postorder(Node* node){
    if(node != NULL){
        postorder(node -> left);
        postorder(node -> right);
        printf("%d
",node -> data);
    }
}

int main(){
    Tree tree;
    tree.root=NULL;
    
    int arr[7]={6,3,8,2,5,1,7};
    
    int i;
    for(i=0; i<7; i++)
        insert(&tree, arr[i]);
        
    printf("h = %d
", get_height(tree.root));
    
    printf("max = %d
", get_maximum(tree.root)); 
    
}

//----------------------------------

新增问题：

 1）复制二叉树

刚拿到手时候，直接传指针，输不出来值。检查一番，发现犯了低级错误：直接传递指针变量，因为此时传递的是指针变量的指向，相当于实体变量。

Node* Copy(Node* ExtN,Node* newN){
    //复制二叉树，中序方法 
    if(ExtN == NULL){
        return NULL;
    }
    else
    {
        newN = (Node*)malloc(sizeof(Node));
        newN -> data = ExtN -> data;
        newN -> left  = Copy(ExtN -> left, newN -> left);
        newN -> right = Copy(ExtN -> right,newN -> right);
        return newN;
    }
} 

...

int main(){
    //...

    Tree newT;
    newT.root=Copy(tree.root, newT.root);
    preorder(newT.root);
    //复制二叉树

    //...      
    

}   

2）计算结点个数

int Count(Node *node){
    //统计节点总数 
    if(node == NULL){
        return 0;
    }
    else{
        return Count(node -> left)+
               Count(node -> right)+1;
    }
}

3）统计叶子个数

int countLeaf(Node *node){
    //统计叶子结点的个数 
    if(node == NULL)
        return 0;
    if(node -> left == NULL && node -> right == NULL)
        return 1;
    else{
        return countLeaf(node -> left) + countLeaf(node -> right);
    } 
}