leetcode_033 Search in Rotated Sorted Array

题目分析：

• 在旋转后的有序数组中查找某个元素。（数组中不存在重复元素）

解题思路：

• 两种方法实现

  方法1：遍历实现

  1）先判断要查找的数与数组头元素和数组尾元素大小，确定遍历方向；

  2）以一定的方向遍历查找，判断是否存在次元素。

  注意：遍历过程中若出现逆序情况，则说明不存在此元素。

  方法2：利用二分查找实现

  1）若target == A[mid]，直接返回mid即可；

  2）若A[first] <= A[mid]时，判断target是否在A[first，mid)之间，在它们之间，则last = mid，否则first = mid + 1；

  3）若A[first] > A[mid]时，判断target是否在A(mid, last - 1]之间，在它们之间，则first = mid + 1，否则last = mid。

• 实现程序

  class Solution
  {
      public: 
          // 一遍遍历（通过） 
          int search(vector<int> nums, int target)
          {
              if (nums[0] == target)
                  return 0;
              if (nums[nums.size() - 1] == target)
                  return nums.size() - 1;
              // 从前向后遍历查找 
              if (nums[0] < target)
              {
                  for (int i = 1; i < nums.size(); i++)
                  {
                      if (nums[i] == target)
                          return i;
                      if (nums[i] < nums[i - 1])
                          return -1;
                  }
              }
              // 从后向前遍历查找 
              else if (nums[nums.size() - 1] > target)
              {
                  for (int i = nums.size() - 2; i >= 0; i--)
                  {
                      if (nums[i] == target)
                          return i;
                      if (nums[i] > nums[i + 1])
                          return -1;
                  }
              }
              return -1;
          }
  
          // 二分查找实现 
          int search(vector<int>& nums, int target)
          {
              int first = 0;
              int last = nums.size();
              int mid;
              while(first != last)
              {
                  mid = (first + last) / 2;
                  if(nums[mid] == target)
                      return mid;
                  // nums[first] <= nums[mid]情况 
                  if(nums[first] <= nums[mid])
                  {
                      // target处于[first, mid)之间，则令last = mid 
                      if(nums[first] <= target && target < nums[mid])
                          last = mid;
                      else
                          first = mid + 1;
                  }
                  // nums[first] > nums[mid] 
                  else
                  {
                      // target处于(mid, last-1]之间，则令first = mid + 1 
                      if(nums[mid] < target && target <= nums[last - 1])
                          first = mid + 1;
                      else
                          last = mid;
                  }       
              }
              return -1;
          }
  };