剑指offer-查找

原创 2016年08月30日 19:48:02

问题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];
}

相关文章推荐

剑指Offer(第二版)面试题53:在排序数组中查找数字出现的次数

关于剑指Offer中二分查找算法的实际应用举例

[剑指Offer]二维数组中的查找

题目描述 在一个二维数组中,每一行都按照从左到右递增的顺序排序,每一列都按照从上到下递增的顺序排序。请完成一个函数,输入这样的一个二维数组和一个整数,判断数组中是否含有该整数。 输入描述 a...

剑指offer面试题java实现之题3:二维数组中的查找

/** * @function 在一个二维数组中,每一行都按照从左向右递增顺序排序; * 每一列都按照从上到下递增顺序排序。 * 1, 2, 8, 9 ,10 * 2, 4,...

剑指offer-面试题3 查找二维数组中的数

面试题3 查找二维数组中的数 题目描述: 一个二维数组,每一行从左到右递增,每一列从上到下递增.输入一个二维数组和一个整数,判断数组中是否含有整数。...
  • pomony1
  • pomony1
  • 2017年03月22日 12:10
  • 454

【剑指Offer学习】【面试题3 :二维数组中的查找】

题目:在一个二维数组中,每一行都按照从左到右递增的顺序排序,每一列都按照从上到下递增的顺序排序。请完成一个函数,输入这样的一个二维数组和一个整数,判断数组中是否含有该整数。...

剑指offer----二维数组中的查找的解析与实现

题目: 在一个二维数组中,每一行都按照从左到右递增的顺序排序,每一列都按照从上到下递增的顺序排序。请完成一个函数,输入这样的一个二维数组和一个整数,判断数组中是否含有该整数。 解析:  (1)该数组是...
  • snow_7
  • snow_7
  • 2016年06月14日 15:49
  • 265

《剑指Offer》查找和排序——旋转数组中的最小数字

题目: 把一个数组最开始的若干个元素搬到数组的末尾,我们称之为数组的旋转。输入一个非递减排序的数组的一个旋转,输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}...

《剑指offer》面试题三 二维数组中的查找

近日看到某网站上收录了《剑指offer》上的题目,觉得可以好好做下去,锻炼自己。 不多说,原题网址  http://ac.jobdu.com/problem.php?pid=1384  原...

剑指offer之面试题3:二维数组中的查找

题  目: 在一个二维数组中,每一行都按照从左到右递增的顺序排序,每一列都按照从上到下递增的顺序排序。请完成一个函数,输入这样的一个二维数组和一个整数,判断数组中是否含有该整数。 解题思路...

剑指offer27--查找数组中最小的k个数

输入n个整数,找出其中最小的k个数
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:剑指offer-查找
举报原因:
原因补充:

(最多只允许输入30个字)