数字 k 在排序数组 arr 中出现的次数

题目：给定一个排好序的数组 arr 和 一个 数字 k ,求 k 在数组中出现的次数。例如给定一个数组 {1 ， 2 ， 3 ， 3 ， 3 ， 3 ， 4 ， 5 } 和数字 3 ，则 3 出现的次数 为 4 

思路：最简单的还是用暴力方法，从头到尾遍历数组，时间复杂度为 n ,但是这样做，好像一点技术含量都没有。

我们可以稍微提高一下用二分法，找出 k 在数组中的位置，然后再分别设置两个变量往前和往后扫描，统计 k 出现的次数，这样子比上面的暴力方法好一点，但是最坏的情况也就是整个数组所以数字都是 k 时，时间复杂度还是 n。

我们还可以再提高一下！还是继续用二分法，我们找到第一个 k 出现的位置firstIndex 和 最后一个 k 出现的位置 lastIndex ，则 k 出现的次数为 lastIndex - firstIndex + 1。时间复杂度为 logn

具体代码：

import java.util.Scanner;

/**
 * 给定一个排序数组arr 和 一个数 k 求 k 在数组中出现的次数
 * @author luzi
 *
 */
public class theCountofK {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Scanner scan = new Scanner(System.in);
		while(scan.hasNext()){
			int n = scan.nextInt();
			int[] arr = new int[n];
			for(int i = 0; i < n; i++)
				arr[i] = scan.nextInt();
			
			int k = scan.nextInt();
			
			System.out.println(countOfK1(arr,k));
			System.out.println(countOfK2(arr,k));
			System.out.println(countOfK3(arr,k));
		}
	}
	
	//使用暴力的方法，从头开始遍历数组,时间复杂度为 n
	public static int countOfK1(int[] arr,int k){
		int count = 0;
		for(int i = 0; i < arr.length; i++){
			if(arr[i] == k)
				count++;
		}
		return count;
	}
	
	//利用二分查找，先找到数字 k 然后再分别从前后开始统计，最坏的情况时间复杂度是 n ,但是总体比暴力方法好
	private static int countOfK2(int[] arr, int k) {
		// TODO Auto-generated method stub
		int count = 0;
		int left = 0;
		int right = arr.length - 1;
		while(left < right){
			int mid = (right - left)/2 + left;
			if(arr[mid] == k){
				left = k;
				right = k + 1;
				break;
			}
			else
				if(arr[mid] > k){
					right = mid;
				}
				else
					left = mid + 1;
		}
		for(;left >= 0; left--){
			if(arr[left] == k)
				count++;
			else
				break;
		}
		for(;right < arr.length; right++){
			if(arr[right] == k)
				count++;
			else
				break;
		}
		
		return count;
	}

	//利用二分法，找到第一个 k 出现的位置 和最后一个 k 出现的位置，即可算出有多少个 k ，时间复杂度为 logn
	public static int countOfK3(int[] arr,int k){
		int count = 0;
		int left = 0;
		int right = arr.length - 1;
		
		int firstIndex = -1;
		int lastIndex = -1;
		
		//我们先找出第一个 k 的位置
		while(left <= right){
			int mid = (right - left)/2 + left;
			
			if(arr[mid] == k){
				if(mid == 0 || (mid > 0 && arr[mid - 1] != k)){
					firstIndex = mid;
					break;
				}
				else
					right = mid - 1;
			}
			else
				if(arr[mid] > k)
					right = mid - 1;
				else
					left = mid + 1;
		}
		
		//找出最后一个 k 出现的位置
		right = arr.length - 1;
		left = firstIndex;
		
		while(left <= right){
			
			int mid = (right - left)/2 + left;
			
			if(arr[mid] == k){
				if(mid == arr.length - 1 || (mid < arr.length - 1 && arr[mid + 1] != k)){
					lastIndex = mid;
					break;
				}
				else
					left = mid + 1;
			}
			else
				if(arr[mid] > k)
					right = mid - 1;
				else
					left = mid + 1;
		}
		if(firstIndex < 0 && lastIndex < 0)
			return 0;
		if(firstIndex >= 0 && firstIndex == lastIndex)
			return 1;
		
		count = lastIndex - firstIndex + 1;
		return count;
	}

}