leetcode 33. 搜索旋转排序数组 (python)

题目：

题解：
题意分析：
对于旋转排序数组，可以看出是部分有序，要求时间复杂度是O(logn)，因此利用二分法进行查找
思路一：
对于本题，易于想到的思路，分为以下两步：

1. 找到旋转点
2. 比较target和旋转点的大小，利用二分法在数组中寻找target。
   下面是代码：

class Solution:
	def search(self, nums, target):
		#首先应用归并排序
		#首先找到间隔的结点
		if len(nums) == 0:
			return -1
		
		if len(nums) == 1:
			if target == nums[0]:
				return 0
			else:
				return -1

		low = 0
		high = len(nums) - 1
		mid = (low + high)//2

		temp = []

		#找到旋转点
		while low <= high:

			mid = (low + high) // 2
			print('mid %d' % mid)

			

			if nums[low] < nums[mid]:

				low = mid + 1
			else:
				

				high = mid - 1
			
			print(mid)


			if mid < (len(nums) - 1) and nums[mid + 1] < nums[mid]:
				print("$#$$")
				temp.append(mid)
				break
			if mid > 0 and nums[mid - 1] > nums[mid]:
				temp.append(mid)
				mid = mid - 1
				break


			
		# print('low %d' % low)
		# print('high %d' % high)

		#如果没有旋转点，即数组本身有序的情况下
		if len(temp) == 0:
			#没有旋转点
			print('wu')
			low2 = 0
			high2 = len(nums) - 1
			while low2 <= high2:

				mid2 = (low2 + high2)//2

				if target < nums[mid2]:
					high2 = mid2 - 1
				elif target >nums[mid2]:
					low2 = mid2 + 1
				else:
					return mid2

			return -1



		
		#下面是进行查找


		if target < nums[0]:
			if target < nums[mid + 1]:
				print("######")
				return -1
			elif target > nums[mid + 1]:
				low3 = mid + 1
				high3 = len(nums) - 1
				while low3 <= high3:
					mid = (low3 + high3)//2
					if target > nums[mid]:
						low3 = mid + 1
					elif target < nums[mid]:
						high3 = mid - 1
					else:
						return mid
			else:
				return mid + 1

		elif target > nums[0]:
			low1 = 0
			high1 = mid
			while low1 <= high1:

				mid1 = (low1 + high1)//2
				if target > nums[mid1]:
					low1 = mid1 + 1
				elif target < nums[mid1]:
					high1 = mid1 - 1
				else:
					return mid1
		else:
			return 0

		return -1

思路二：（划分出各种情况）在二分查找的背景下

1. 利用二分法找出中间节点，
2. 比较起始节点和中间节点的大小，如果小于等于中间节点，那么前半部分有序，旋转点在后半部分中；紧接着分析target和起始节点，中间节点的大小，判断low和high指针的移动方向；如果target大于起始节点小于中间节点，则high指针进行向前规约，否则low指针进行向后规约.
3. 如果大于中间节点，那么旋转点在前半部分中；此时如果target小于中间节点或者target大于起始节点；high指针都是向前规约，否则向后规约。

下面是代码：

class Solution:
	def search(self, nums, target):
		low = 0
		high = len(nums) - 1
		while(low <= high):
			mid = (low + high) // 2

			if target == nums[mid]:
				return mid

			if nums[low] <= nums[mid]:
				if target < nums[mid] and target >= nums[low]:
					high = mid - 1
				else:
					low = mid + 1

			else:

				if target < nums[mid] or target >= nums[low]:
					high = mid - 1
				else:
					low = mid + 1
		return -1

显然这种思路可以容易处理数据本身有序的情况，即在if nums[low] <= nums[mid]:这种情况中处理。
参考题解：
https://leetcode-cn.com/problems/search-in-rotated-sorted-array/solution/ji-jian-solution-by-lukelee/