2023.11.23二分查找、快速幂，二叉树，排序树

排序

二分查找

int b(int key){
    int low=0,high=size-1,mid;
    while(low<=high){
        mid=low+(high-low)>>1;
        if(arr[mid]==key){
            return mid;
        }else if(arr[mid]>key){
            high=mid-1;
        }else{
            low=mid+1;
        }
    }
    return -1;
}

最后一定是左右指针重合，即最后一个查找的元素 ，如果没找到，就一定是左指针大于右指针。

当最后查找的元素比目标值小时，左指针右移，导致左指针大。

当最后查找的元素比目标值大，则右指针左移，导致左指针大

快速幂

int power(a, n) {
    if (n == 1) {
        return a;
    }
    pow = power(a, n / 2);
    pow = pow * pow;
    if (n % 2 == 1) {
        pow *= a;
    }
    return pow;
}

二叉树 排序树

struct node{
    int data;
    node*lchild,*rchild;
}

查找 

bool search(node*root,int key,node* f,node* p){
    if(!root){
        *p=f;
        return false;
    }else if(key==root->data){
        






bool BST(node root,int key, node f,node*p){
    if(!root){
        *p=f;
        return false;
    }else if(key ==root->data){
        *p=root;
        return true;
    }else if(key<root->data){
        return BST(root->lchild,key,root,p);
    }else{
        return BST(root->rchild,key,root,p);
    }
}

插入

bool insert(node root,int key){
    node p,s;
    if(!search(root,key,nullptr,&p)){
        s=new node;
        s->data=key;
        s->rchild=nullptr;
        s->lchild=nullptr;
        if(!p){
            root=s;
        }else if(key<p->data){
            p->lchild=s;
        }else{
            p->rchild=s;
        }
        return true;
        }else{
            return false;
        }
}

删除

struct binode{
    int data;
    binode *lchild,*rchild;
}*bitree;
bool delete(bitree* t,int key){
    if(!t){
        return false;
    }else{
        if(key==t->data){
            return delete(t);
        }else if(key<t->data){
            return delete(t->lchild,key);
        }else{
            return delete(t->rchild,key);
        }
    }
}