python第三十二天-----算法

算法（Algorithm）：一个计算过程，解决问题的方法
时间复杂度：用来评估算法运行效率的一个东西
ps：在日常使用中，请使用sort()，because no zuo no die！

1.冒泡排序：
指针如同气泡一样一个个由下向上浮，每次上浮如果上面的数比自己小则交换位置，这样就保证每次可以使最大的数字排列在最上面，重复此过程直到所有数有序；时间复杂度为O(n2)，wtf,平方怎么打，就酱吧。

 def bubble_sort_x(data):
     for i in range(len(data)-1):                        # 在循环到最后一个数的时候就不需要再比较了，因为此时列表已经排列好了
         for j in range(len(data)-i-1):                    # 指针一点点上浮的过程
             if data[j] > data[j+1]
             data[j+1], data[j] = data[j], data[j+1]

"调优后"，但是你会发现并不是真正的调优，时快时慢，因为此调优仅对当某次交换完成后发现下面的数并未进行交换(也就是已经排序好了)，那么就可以认为已经完成可以返回了，但是因为是这种特殊情况并不是每次都会出现，但是每次循环你必须要做一次判断，so，这个时间开销却是必须的，因此权衡利弊这下，北神还是觉得上面的好，简单易懂，萌萌哒。

 def bubble_sort(data):
     for i in range(len(data)-1):
         exchange = False
         for j in range(len(data) - i - 1):
             if data[j] > data[j+1]:
                 data[j], data[j+1] = data[j+1], data[j]
                 exchange = True
         if not exchange:
             return

2.选择排序：
默认以无序区第一个数为列表内的最小数，然后遍历列表开始跟默认比较大小，如果发现了比默认值小的则成为新的默认最小数，遍历完成后会发现列表中的最小数再与第一个数互换位置，重复此过程就可以保证列表从第一个数开始由小到大排序；时间复杂度为O(n2)，运行时间比冒泡快，因为它与冒泡一样都对数就行了比较，但是并没有直接互换位置，直到一次循环完成后找到了最小数才进行了一次位置互换，so，冒泡排序被吊打了。

 def insert_sort_x(data):
     for i in range(len(data)-1):
         min_loc = i
         for j in range(i+1, len(data)):                        # 从下一个开始跟i比较
             if data[j] < data[min_loc]:
                 min_loc = j
         data[i], data[min_loc] = data[min_loc], data[i]

3.希尔排序：
选择排序的升级版本，讲列表进行多次分段后各自进行排序，最后形成一个偏向有序的大列表，然后对整个大列表进行一次选择排序形成最终有序列表，看不懂就对了，没什么卵用。

 def shell_sort_x(data):
     gap = int(len(data) // 2)
     while gap >= 1:
         for i in range(gap, len(data)):
             tmp = data[i]
             j = i - gap
             while j >= 0 and tmp < data[j]:
                 data[j + gap] = data[j]
                 j -= gap
             data[i - gap] = tmp
         gap = gap // 2

4.快速排序：
取第一个元素x使其归位，列表分成两部分，左边都比x小，右边都比x大，然后对这两边递归进行排序。

 def quick_sort_x(data, left, right):
     mid = partition(data, left, right)                        # x归位
     quick_sort_x(data, left, mid-1)
     quick_sort_x(data, mid+1, right)

 def partition(data, left, right):
     tmp = data[left]
     while left < right:
         while left < right and data[range] >= tmp:
             right -= 1
         data[left] = data[right]
         while left < right and data[left] <= tmp:
             left += 1
         data[right] = data[left]
     data[left] = tmp

5.归并排序：
将数组递归切分成单个元素后对比排序合并。

 def merge_sort_x(data, low, high):
     if low < high:
         mid = (low + high) // 2
         merge_sort_x(data, low, mid)
         merge_sort_x(data, mid+1, high)
         merge(data, low, mid, high)

 def merge(data, low, mid, high):
     i = low
     j = mid + 1
     ltmp = []
     while i <= mid and j <= high:
     if data[i] < data[j]:            # 两边数依次取出比较大小
         ltmp.append(data[i])
         i += 1
     else:
         ltmp.append(data[j])
         j += 1
     while i <= mid:                    # 下面2个while只有一个会执行
         ltmp.append(data[i])
         i += 1
     while j <= high:
         ltmp.append(data[j])
         j += 1
     data[low:high+1] = ltmp

6.插入排序:
默认第一个元素是有序的，然后根据依次比较下一个元素与有序区内元素确定其位置。

 def insert_sort_x(data):
     for i in range(1, len(data)):
         tmp = data[i]
         j = i - 1
         while j >= 0 and tmp < data[j]:
             data[j + 1] = data[j]
             j -= 1
         data[j + 1] = tmp

7.堆排序：
建立一个堆，后去掉堆顶元素为最大元素放置于堆末尾(之后不参与计算)，通过一次调整再次得到堆顶，循环重复此过程。

 def sift(data, low, high):
     i = low
     j = 2 * i + 1
     tmp = data[i]
     while j <= high:
         if j < high and data[j] < data[j + 1]:
             j += 1
         if tmp < data[j]:
             data[i] = data[j]
             i = j
             j = 2 * i + 1
         else:
             break
     data[i] = tmp

 def heap_sort_x(data):
     n = len(data)
     for i in range(n // 2 - 1, -1, -1):
         sift(data, i, n - 1)
     for i in range(n - 1, -1, -1):
         data[0], data[i] = data[i], data[0]
         sift(data, 0, i - 1)