折半查找平均查找长度计算_二分查找（折半查找）

概念：

二分查找是一种高效的查找方式，不过要求线性表（注意与非线性表之间的区别，具有四个特征）必须采用顺序存储结构（注意不是链式存储结构），并且元素是有序排列的。

时间复杂度：log（n）

假设有n个元素，则二分查找的元素个数如下：n n/2 n/4 n/8 n/16 ....

代码：

int binarySerch(vector<int> & nums,int low,int hi,int target)
{
	int len  = nums.size();
	if(low<0 || low > len-1 || hi < 0 || hi > len-1 || 0 == len)
	{
		return -1;
	}

	while(low <= hi) //注意这里一定要加上=
	{
		int mid = low + (hi -low)/2;
		if(target == nums[mid])
			return mid;
		else if(target > nums[mid])
			low = mid+1;
		else
			hi = mid-1;
	}

	return -1;

}

应用

问题1: 剑指 offer旋转数组中的最小数字

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

思路：题目中给的数组的特征，虽然不是全局有序，但是部分有序

代码：

class Solution {
public:
    int minNumberInRotateArray(vector<int> rotateArray)
	{
		int len = rotateArray.size();
		if(0 == len)
			return 0;
		int low=0;
		int hi = len-1;
		while(low < hi)
		{
			int mid = low+(hi-low)/2;
			if(rotateArray[mid] < rotateArray[hi])//说明mid属于左边递增的部分，mid-hi是有序递增的，则最小值在mid及其左边
			{
				hi  = mid;
			}else//说明最小值在mid的右边，因为mid属于左边递增的部分，且右边递增的元素都大
			{
				low = mid+1;
			}

		}

		return rotateArray[low];

    }
};

问题2: leetcoe 33. 搜索旋转排序数组.

假设按照升序排序的数组在预先未知的某个点上进行了旋转。

( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。

搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。

你可以假设数组中不存在重复的元素。

你的算法时间复杂度必须是 O(log n) 级别。

示例 1:

输入: nums = [4,5,6,7,0,1,2], target = 0

输出: 4

示例 2:

输入: nums = [4,5,6,7,0,1,2], target = 3

输出: -1

来源：力扣（LeetCode）

链接：力扣

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

总体思想也是利用数组的局部递增特性，且左边序列的所有数据都大于右边序列的所有递增数据。如果mid上的数据和target同时落在一个递增序列上，那么就可以使用二分查找的思想。

感觉解法一中有很多重复判断，但是又找不出来哪里有问题了，如果路过的朋友看到了麻烦告知下：

解法一：

class Solution {
	public:
		int binarySerch(vector<int> & nums,int low,int hi,int target)//二分查找的算法
		{
			int len  = nums.size();
			if(low<0 || low > len-1 || hi < 0 || hi > len-1 || 0 == len)
			{
				return -1;
			}

			while(low <= hi) //注意这里一定要加上=
			{
				int mid = low + (hi -low)/2;
				if(target == nums[mid])
					return mid;
				else if(target > nums[mid])
					low = mid+1;
				else
					hi = mid-1;
			}

			return -1;

		}
		int search(vector<int>& nums, int target)
		{
			int len = nums.size();
			if(0 == len)
				return -1;
			int low = 0;
			int hi = len-1;
			while(low <= hi)
			{
				if(nums[low] <= nums[hi])
				{
					return binarySerch(nums,low,hi,target);
				}
				int mid = low + (hi -low)/2;
				if(target ==nums[mid])
					return  mid;
				else if (nums[mid] <= nums[hi] )
				{
					if(target >= nums[mid] && target <= nums[hi])
					{
						return binarySerch(nums,low,hi,target);

					}else
					{
						hi = mid-1;
					}

				}else
				{
					if(target >= nums[low] && target <= nums[mid])
					{

						return binarySerch(nums,low,hi,target);

					}else
					{
						low = mid+1;

					}
				}
			}


			return -1;
		}
};

解法二：

class Solution {
	public:
		int search(vector<int>& nums, int target)
		{
			int len = nums.size();
			if(0 == len)
				return -1;
			int low = 0;
			int hi = len-1;
			while(low <= hi)
			{
				int mid = low+(hi-low)/2;
				if(nums[mid] == target)
					return mid;
				else if(nums[mid] < nums[hi])
				{
					if(target >= nums[mid] && target <= nums[hi] )
					{
						low = mid + 1;
					}else
					{
						hi = mid-1;
					}
				}else
				{
					if(target <= nums[mid] && target >= nums[low] )
					{
						hi = mid - 1;
					}else
					{
						low = mid + 1;
					}

				}

			}


			return -1;
		}
};

问题3: leetcode34. 在排序数组中查找元素的第一个和最后一个位置

给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。

你的算法时间复杂度必须是 O(log n) 级别。

如果数组中不存在目标值，返回 [-1, -1]。

示例 1:

输入: nums = [5,7,7,8,8,10], target = 8

输出: [3,4]

示例 2:

输入: nums = [5,7,7,8,8,10], target = 6

输出: [-1,-1]

来源：力扣（LeetCode）

链接：力扣

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target)
    {
        vector<int> res;
        int  len = nums.size();
        if(len == 0)
		{

			res.push_back(-1);
			res.push_back(-1);
            return res;
		}

        int low = 0;
        int hi = len-1;
        while(low <= hi)
        {
            int mid = low + (hi-low)/2;
            int m = mid;
            if(nums[mid] == target)
            {
                while(mid <= len-1 && nums[mid] == target) mid++;//注意这里&&左右两
               //边的顺序，不让nums会出现越界现象，从而出现段错误
                mid--;
                while( m >= 0 && nums[m] == target) m--;
                m++;

                res.push_back(m);
                res.push_back(mid);
                return res;

            }else if(nums[mid] > target)
            {
                hi = mid-1;
            }else{
                low = mid+1;
            }
        }
        res.push_back(-1);
        res.push_back(-1);
        return res;
    }
};