算法

博客出处：https://www.cnblogs.com/weihengblog/p/9439865.html

冒泡排序（时间复杂度为 o（n2））

冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。

冒泡排序的原理：

1. 比较两个相邻的元素，如果第一个比第二个大，就交换他们
2. 对每一对相邻的元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

越大的元素会经由交换慢慢“浮”到数列的顶端。

def maopao(l):
    for i in range(len(l)):
        for j in range(len(l) - i - 1):
            if l[j] > l[j+1]:
                l[j],l[j+1] = l[j+1],l[j]
    return l


import random

l = list(range(100))
# 随机打乱列表
random.shuffle(l)
print(maopao(l))

选择排序（时间复杂度为o（n2））

选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

选择排序是不稳定的排序方法。

选择排序原理：

1. 我们假设第一个数最小，记录他的位置
2. 然后同之后的每一个数比较，如果有小于这个数的，就记录它的索引

3. 每次将无序区最小的放到有序区的起始位置

def select_sort(l):

    for i in range(len(l)):
        min_loc = i
        for j in range(i+1,len(l)):
            if l[min_loc] > l[j]:
                min_loc = j
        if min_loc != i:
            l[i],l[min_loc] = l[min_loc],l[i]

    return l

import random

l = list(range(10))
# 随机打乱列表
random.shuffle(l)
print(select_sort2(l))

插入排序（时间复杂度为o（n2））

插入排序：列表被分为有序区和无序区两个部分。假设最初有序区只有一个元素。每次从无序区选择一个元素，插入到有序区的位置，直到无序区变空。

思路:

1. 记录摸到的牌

2. 记录手里最后一张牌的位置

3. 开始 摸牌插牌

4. 摸到的牌小于 手里的牌

5. 手里最后一张牌往后移

6. 手里倒数第二张牌的位置

def insert_sort(l):

    for i in range(1,len(l)):
        tmp = l[i]
        j = i - 1 
        while True: 
            if j >= 0 and tmp < l[j]:
                l[j + 1] = l[j] 
                j = j - 1
            elif l[j] < tmp or j == -1:
                l[j + 1] = tmp
                break
    return l


import random

l = list(range(100))
# 随机打乱列表
random.shuffle(l)
print(insert_sort(l))
复制代码

　　

 二分查找（时间复杂度为o（logn））

def bin_search(data_set,value):
    low =0
    high =len(data_set)-1
    while low <=high:
        mid =high +low //2
        if data_set[mid] ==value :
            return mid

        elif data_set[mid]>value :
            high =mid -1

        else:
            low =mid +1

ls = [1,2,3,4,5,6,7,8,9,10]

print(bin_search(ls,8))

　　

快排 

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


def quick_sort(li,left,right):
    if left< right:
        mid =partition(li,left,right)
        quick_sort(li,left,mid -1)
        quick_sort(li,mid+1,right)

li =[0,2,3,4,5,7,6,5,4,22,2,2222,2300]
_quick_sort(li,0,12)
print(li)

　　

一行代码实现快排

主要利用了行数的递归调用和Python的切片特性，解释一下每行代码的含义：

第1行： #coding:utf-8 指定utf-8 编码
第2行：定义函数名和参数
第3行: 判断列表长度是否小于等于1， 如果小于等于1，直接返回列表
第4行：返回递归函数拼接的列表，[lt for lt in L[1:] if lt <= L[0]] 列表推导表达式，返回一个比 L[0] 小的列表，[ge for ge in L[1:] if ge >= L[0]], 返回一个比L[0] 大的列表， 再加上L[0] 就构成完整的列表
第四行是最关键的，返回三个部分：

比列表第一个元素小的所有元素列表递归调用
第一个元素
比列表第一个元素大的所有元素列表递归调用

def qsort(L):
    if len(L) <= 1: return L
    return qsort([lt for lt in L[1:] if lt < L[0]]) + 
　　　      L[0:1]+ 
           qsort([ge for ge in L[1:] if ge >= L[0]])

iList = [3,14,2,12,9,33,99,35]

print qsort(iList)

一行代码实现

quick_sort = lambda array: array if len(array) <= 1 else quick_sort([item for item in array[1:] if item <= array[0]]) + [array[0]] + 
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 quick_sort([item for item in array[1:] if item > array[0]])

堆排序

 

import  heapq
def heapsort(li):
    h =[]
    for value in li:
        heapq.heappush(h,value)

    return [heapq.heappop(h) for i in range (len(h))]

print(heapsort([1,2,3,4,5,666,77,85454,4]))

　　

def quick_sort(li, start, end):
    # 分治 一分为二
    # start=end ,证明要处理的数据只有一个
    # start>end ,证明右边没有数据
    if start >= end:
        return
    # 定义两个游标，分别指向0和末尾位置
    left = start
    right = end
    # 把0位置的数据，认为是中间值
    mid = li[left]
    while left < right:
        # 让右边游标往左移动，目的是找到小于mid的值，放到left游标位置
        while left < right and li[right] >= mid:
            right -= 1
        li[left] = li[right]
        # 让左边游标往右移动，目的是找到大于mid的值，放到right游标位置
        while left < right and li[left] < mid:
            left += 1
        li[right] = li[left]
    # while结束后，把mid放到中间位置，left=right
    li[left] = mid
    # 递归处理左边的数据
    quick_sort(li, start, left-1)
    # 递归处理右边的数据
    quick_sort(li, left+1, end)
 
if __name__ == '__main__':
    l = [6,5,4,3,2,1]
    # l = 3 [2,1,5,6,5,4]
    # [2, 1, 5, 6, 5, 4]
    quick_sort(l,0,len(l)-1)
    print(l)
    # 稳定性：不稳定
    # 最优时间复杂度：O(nlogn)
    # 最坏时间复杂度：O(n^2)
 

　　

 

import heapq
li =[1,2,3,3,2,6,33,2,33,44]
heapq.heapify(li)
print(li)  #构造践堆
输出结果：[1, 2, 3, 2, 2, 6, 33, 3, 33, 44]

heapq.heappush(li,0) #增加一个值
print(li)
输出结果：[0, 1, 3, 2, 2, 6, 33, 3, 33, 44, 2]

heapq.heappop(li)  #删除一个值.
print(li)

堆排序

#建堆,堆排序
def heap_sort(li):
    heapq.heapify(li)
    res =[]
    for i in range(len(li)):
        res.append(heapq.heappop(li))
    return res

import random
li = list(range(100))
random.shuffle(li)
print(heap_sort(li))