算法学习之数字在排序数组中出现的次数

题目描述

统计一个数字在排序数组中出现的次数。

思路：看到排序树组马上想到二分查找。更爽的是Java为我们提供了api

import java.util.*;
public class Solution {
    public int GetNumberOfK(int [] array , int k) { 
           int index = Arrays.binarySearch(array,k);
           if(index<0)return 0;
           int count=1;
           for(int i = index-1;i>=0&&array[i]==k;i--){
               count++;
           }
           for(int i = index+1;i<array.length&&array[i]==k;i++){
               count++;
           }
           return count;
    }
}

• 时间复杂度：O(logn)。
• 空间复杂度：O(logn)。

我们不妨顺便看下binarySearch源码

private static int binarySearch0(int[] a, int fromIndex, int toIndex,
                                     int key) {
        int low = fromIndex;
        int high = toIndex - 1;

        while (low <= high) {
            int mid = (low + high) >>> 1;
            int midVal = a[mid];

            if (midVal < key)
                low = mid + 1;
            else if (midVal > key)
                high = mid - 1;
            else
                return mid; // key found
        }
        return -(low + 1);  // key not found.
    }

也很好理解，通过二分查找不断取中间值获取目标值。

 

题目二：0~n-1中缺失的数字

一个长度为n-1的递增排序数组中的所有数字都是唯一的，并且每个数字都在范围0 ~ n-1之内。在范围0 ~ n-1内的n个数字中有且只有一个数字不在该数组中，请找出这个数字。

思路：因为有序所以有时二分查找，根据题目所知第一个下标不等于当前位置值的，如图。

所以我们设立中间值，

当中间值与索引相等时：我们取有半部分

中间值不等于索引值时：

1、先看索引值前一个值是否也与对应下标相等，不相等则取左半部分

2、相等则当前mid就是目标值

 public int getMissingNumber(int [] numbers){
        if(numbers==null||numbers.length<=0)return -1;
        int lo = 0,hi = numbers.length-1;
        while (lo<=hi){
            int mid = (lo+hi)>>1;
            if(numbers[mid]!=mid) {
                if(mid==0||numbers[mid-1]==mid-1) {
                    return mid;
                }
                hi = mid-1;
            }else {
                lo = mid+1;
            }
        }
        return -1;
    }

• 时间复杂度：O(logn)。
• 空间复杂度：O(1)。

题目三：数组中数值和下标相等的元素。

假设一个单调递增的数组里的每个元素都是整数并且是唯一的。请编程实现一个函数，找出数组中任意一个数值等于其下标的元素。例如，在数组{-3, -1, 1, 3, 5}中，数字3和它的下标相等。

思路：道理跟上面一致：二分查找中间值小于中间下标取右半部分，反之左半部分，相等则找到目标值。

 

  public int getSameAsIndex(int [] numbers){
        if (numbers==null||numbers.length<=0)return -1;
        int lo = 0,hi = numbers.length-1;
        while(lo<=hi) {
            int mid = (lo+hi)>>1;
            if(mid==numbers[mid]) {
                return mid;
            }else if(mid>numbers[mid]) {
                lo = mid+1;
            }else {
                hi = mid-1;
            }

        }
        return  -1;
    }

• 时间复杂度：O(logn)。
• 空间复杂度：O(1)。