算法

查找

1. 线性查找
   1. 　　不要求数组为有序数组。其查找算法为对数组中的每个数字与你所需要查找的数字值(target)挨着进行比较。

      def line_search(data, target):
          for i in range(len(data)):
              if data[i] == target:
                  return i
          return None
      
      
      if __name__ == '__main__':
          ls = [2, 8, 7, 6, 3, 5, 9]
          res = line_search(ls, 3)
          print('所在列表的位置:', res)

2. 二分查找
   1. 　　要求数组为有序数组。其查找算法为先将数组从中间劈开，然后比较value与数组的劈开那的值比较，即与中值进行比较，若value＜中值，则去小于中值的那部分，继续递归该过程；若大于，则去大于那部分递归；若等于中值，则查找结束。

      def binary_search(data, target):
          low = 0
          high = len(data) - 1
          while low <= high:
              mid = (low + high) // 2
              if data[mid] == target:
                  return mid
              elif data[mid] > target:
                  high = mid - 1
              else:
                  low = low + 1
          return None
      
      
      if __name__ == '__main__':
          ls = range(2, 20)
          res = binary_search(ls, 4)
          print('所在列表的位置', res)

排序

1. 冒泡排序
   1. 　　每一次比较都伴随着交换，看起来像是一个泡泡在不停的向上冒出来，冒出一个最小（或最大）的数字。

      import random
      
      
      def bubble_sort(data):
          for i in range(len(data)-1):
              for j in range(len(data) - i - 1):
                  if data[j] > data[j + 1]:
                      data[j], data[j + 1] = data[j + 1], data[j]
      
      
      if __name__ == '__main__':
          ls = list(range(10))
          random.shuffle(ls)
          print('混乱的状态',ls)
          bubble_sort(ls)
          print('排序状态',ls)

2. 插入排序
   1. 　　如你打扑克抓牌，其乱序数组如牌桌上面的牌，而你手中的则为有序区，然后对你抓到的每张牌都进行排序，将其插入到相应的有序位置。

      import random
      
      
      def insertion_sort(data):
          for i in range(1, len(data)):
              tmp = data[i]
              j = i - 1
              while j >= 0 and data[j] > tmp:
                  data[j + 1] = data[j]
                  j -= 1
              data[j + 1] = tmp
      
      
      if __name__ == '__main__':
          ls = list(range(10))
          random.shuffle(ls)
          print('混乱状态', ls)
          insertion_sort(ls)
          print('有序状态', ls)

3. 选择排序
   1. 　　第一个数字为有序，记为最小min，然后与数组中其他数字进行比较，若找到比其还小的数字，则将找到的那个数字标记为loc_min，直到遍历完数组。然后交换第一个数字与找到的最小数字。依次对下一个数字进行排序

      import random
      
      
      def selection_sort(data):
          for i in range(len(data) - 1):  # 由于经过前面一系列的排序，最后的数字必然是最小（或最大）的，即有序
              loc_min = i
              for j in range(i + 1, len(data)):
                  if data[j] < data[loc_min]:
                      loc_min = j
              data[loc_min], data[i] = data[i], data[loc_min]
      
      
      if __name__ == '__main__':
          ls = list(range(10))
          random.shuffle(ls)
          print('混乱状态', ls)
          selection_sort(ls)
          print('排序状态', ls)

4. 快速排序
   1. 　　选取第一个数字，然后将小于它的数字放到左边，大于的数字放到右边。然后分别对左右两边继续进行该递归。

      import random
      
      
      def quick_sort(data, left, right):
          if left < right:
              mid = partition(data, left, right)
              quick_sort(data, left, mid - 1)
              quick_sort(data, mid + 1, right)
      
      
      def partition(data, left, right):
          tmp = data[left]
          while left < right:
              while left < right and data[right] > tmp:
                  right -= 1
              data[left] = data[right]
              while left < right and data[left] < tmp:
                  left += 1
              data[right] = data[left]
          data[left] = tmp
          return left
      
      if __name__ == '__main__':
          ls = list(range(20))
          random.shuffle(ls)
          print('混乱状态', ls)
          quick_sort(ls, 0, len(ls) - 1)
          print('排序状态', ls)

       

内容待完善...