数组查找（算法基础）

二维数组查找

• 问题：在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

• 解决：

  class Solution:
      # array 二维列表
      def Find(self, target, array):
          # write code here
          i = 0
          j = len(array[0]) - 1
          while(i < len(array) and j >= 0):
              if(target < array[i][j]):
                  #排除当前列
                  j -= 1
              elif(target > array[i][j]):
                  #排除当前行
                  i += 1
              else:
                  return True
          return False
  

二分查找

• 问题：一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。

  例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。

  NOTE：给出的所有元素都大于0，若数组大小为0，请返回0

• 解决：

  #方法一：直接遍历查找
  class Solution:
      def minNumberInRotateArray(self, rotateArray):
          if len(rotateArray) == 0 or  rotateArray == None:
              return 0
          for i in range(len(rotateArray)):
              if rotateArray[i] > rotateArray[i+1]:
                  #递减的元素=最小的元素
                  return rotateArray[i+1]
          return rotateArray[0]
  
  #方法二：二分查找
  class Solution:
      def minNumberInRotateArray(self, rotateArray):
          if len(rotateArray) == 0 or rotateArray == None:
              return 0
          left = 0
          right = len(rotateArray) - 1
          mid = 0
          while(rotateArray[left] >= rotateArray[right]):
              if right - left == 1:
                  #两个下标相邻
                  mid = right
                  break
              mid = (left+right) // 2
              #无法判定最小元素在mid左侧，还是右侧，采用遍历
              if rotateArray[left] == rotateArray[right] and rotateArray[mid] == rotateArray[left]:
                  result = rotateArray[left]
                  for i in range(left+1, right):
                      if rotateArray[i] < result:
                          result = rotateArray[i]
                  return result
              #由于原数组非递减特性，rotateArray[mid]大于等于rotateArray[left],则最小元素在逆转数组mid后
              if rotateArray[mid] >= rotateArray[left]:
                  left = mid
              #rotateArray[mid]小于rotateArray[left],则最小元素在逆转数组mid前
              else:
                  right = mid
          return rotateArray[mid]
  

数组操作（排序思想的扩展应用）

• 问题：输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分， 所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。

• 解决：

  class Solution:
      def reOrderArray(self, array):
          # write code here
          k = 0
          for i in range(len(array)):
              if array[i]%2 == 1:
                  j = i
                  temp = array[i]#将奇数保存
                  while j>k:#将奇数前的偶数序列整体后移一位
                      array[j]=array[j-1]
                      j -= 1
                  array[k] = temp
                  k += 1
        return array
  

数组的使用（简单算法的设计）

• 问题：数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组 {1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则 输出0。

• 解决：

  #方法一：使用字典
  class Solution:
      def MoreThanHalfNum_Solution(self, numbers):
          # write code here
          dic = {}
          for i in range(len(numbers)):
              if numbers[i] in dic:
                  dic[numbers[i]] += 1
              else:
                  dic[numbers[i]] = 1
          for k in dic:
              if dic[k] > (len(numbers)//2):
                  return k
          return 0
      
  #方法二：使用排序
  class Solution:
      def MoreThanHalfNum_Solution(self, numbers):
          #numbers.sort()
          for i in range(len(numbers)-1):
              for j in range(0,len(numbers)-i-1):
                  if numbers[j]>numbers[j+1]:
                      numbers[j],numbers[j+1] = numbers[j+1],numbers[j]
          count = 0
          mid = len(numbers)//2
          for i in range(len(numbers)):
              if numbers[i] == numbers[mid]:
                  count += 1
          if count > mid:
              return numbers[mid]
          else:
              return 0
  #方法三
  class Solution:
      def MoreThanHalfNum_Solution(self, numbers):
          # write code here
          if(len(numbers)==0):
              return 0
          target = numbers[0]
          times = 1
          for i in range(len(numbers)):
              if times==0:
                  target = numbers[i]
                  times = 1
              elif target==numbers[i]:
                  times += 1
              else:
                  times -= 1
          #最终遍历
          times = 0
          for i in range(len(numbers)):
              if target == numbers[i]:
                  times += 1
          return target if times > len(numbers)/2 else 0