剑指offer-查找

问题1、二分查找

//注意：二分查找的前提是数组基本有序
int BinarySearch(int a[],int low,int high,int key){
    while(low<=high){
        int mid=low+(high-low)/2;
        if(a[mid]==key)
                    return mid;
        else if(a[mid]>key){
                high=mid-1;
        }
        else{
            low=mid+1;
        }
    }
    return -1;
}
//STL提供的函数 binary_search(a, a + 8, 44)可以判断查找的元素是否存在，不能返回位置。

问题2、第一个只出现一次的字符

//方法1使用map的key唯一性
char FirstAppearChar(string s){
    map<char,int>  cimap;
    for(int i=0;s[i]!='\0';i++){
        cimap[s[i]]++;
    }
    for(int j=0;s[j]!='\0';j++){
        if(cimap[s[j]]==1)
            return s[j];
    }
    return '\0';
}

//方法2使用哈希更方便，但是空间变大
char FirstAppearChar(char *s){
    unsigned int hashTable[256];
    memset(hashTable,0,sizeof(hashTable));
    for(int i=0;s[i]!='\0';i++){
        hashTable[s[i]-'0']++;
    }
    for(int j=0;j!=s[j];j++){
        if(hashTable[s[j]-'0']==1)
                return s[j];
    }
    return '\0';
}

问题3、数字在排序数组中第一次出现的次数

//方法一、直接二分查找到第一个num的位置，然后沿着num的位置前后搜索,复杂度为O(n)
int TimesOfNumber(int a[],int n,int num){
    int low=0;
    int high=n-1;
    int pos=-1;
    while(low<=high){
        int mid=low+(high-low)/2;
        if(a[mid]==num){
            pos=mid;
            break;
        }
        else if(a[mid]<num){
            low=mid+1;
        }else{
            high=mid-1;
        }
    }
    if(pos==-1)
            return 0;
    int times=1;
    int i=pos-1,j=pos+1;
    while(i>=0&&a[i]==num){
        times++;
        i--;
    }
    while(j<n&&a[j]==num){
        times++;
        j++;
    }

    return times;
}

//方法二、改造二分查找，找到第一个出现num的位置和最后一个num出现的位置即可，复杂度为O(logn)。
int GetFirstK(int a[], int n, int num,int low,int high){
    if (low>high)
            return -1;
    int mid = low + (high-low)/2;
    if (a[mid] == num){
        if (mid>0 && a[mid-1]!=num||mid==0)
                return mid;
        else
            high=mid-1;
    }
    else if (a[mid] < num){
        low=mid+1;
    }
    else
    {
        high=mid-1;
    }
    return GetFirstK(a,n,num,low,high);
}
int GetLastK(int a[], int n, int num, int low, int high){
    if (low>high)
        return -1;
    int mid = low + (high - low) / 2;
    if (a[mid] == num){
        if (mid<n-1 && a[mid +1] != num || mid == n-1)
            return mid;
        else
            high = mid - 1;
    }
    else if (a[mid] < num){
        low = mid + 1;
    }
    else
    {
        high = mid - 1;
    }
    return GetLastK(a, n, num, low, high);
}

问题4、二叉搜索树的后序遍历判断

bool isPostOrderOfBinarySearchTree(int a[],int n){
    if(a==NULL||n<=0)
                return false;
    int rootValue=a[n-1];//最后一个是根结点
    int i=0;
    //从第一个开始的位左子树并且左子树的元素均小于根节点
    for(;i<n-1;i++){
        if(a[i]>rootValue)
                    break;
    }
    int j=i;
    for(;j<n-1;j++){
        if(a[j]<rootValue)
            return false;
    }
    bool lest=true;
    if(i>0){
        left=isPostOrderOfBinarySearchTree(a,i);
    }
    bool right=true;
    if(i<n-1){
        right=isPostOrderOfBinarySearchTree(a+i,n-i-1);
    }
    return left&&false;
}

问题5、数组中出现次数超过一半的数字

int  MoreThanHalf(int a[], int n){
    int times=1;
    int target=a[0];
    for(int i=0;i<n;i++){
        if(times==0){
                target=a[i];
                times=1;
        }
        else if(a[i]==target){
                times++;
        }
        else{
            times--;
        }
    }
}

问题6、在数组长度为n的数组中查找第k大的数字
等效于求无序数组中最小的k个数

int Partition(int a[],int n,int low, int high){
    int pivot = a[low];
    while (low<high){
        for (; high >= 0 && a[high] >= pivot; high--);
        if (a[high]<pivot){
            a[low++] = a[high];
        }
        for(; low <= high&&a[low]<pivot; low++);
        if (a[low]>pivot){
            a[high--] = a[low];
        }
    }
    a[low] = pivot;
    return low;
}
//利用快速排序思想得到了以pivot为中心的数组：左边<pivot<右边
int LargestKNum(int a[], int n, int k){
    int start = 0;
    int end = n - 1;
    int index = Partition(a, n, start, end);
    while (index != k - 1){
        cout<<index<<endl;
        if (index>k - 1){
            end = index - 1;
            index = Partition(a, n, start, end);
        }
        else{
            start = index + 1;
            index = Partition(a, n, start, end);
        }
    }
    return a[index];
}