python 几个简单算法详解

一、冒泡排序

基本思想：它的思路很有特点循环，两两向后比较。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

#冒泡排序
# def bubble_sort(li):
#     for i in range(len(li)-1):   #走一趟,循环的次数
#         for j in range(len(li)-i-1):  #有序列为,len(li)-i,去掉有序不循环
#             if li[j]>li[j+1]:   #如果后一个数大,那就交换
#                 li[j],li[j+1]=li[j+1],li[j]

二、选择排序

基本思想：从所有序列中先找到最小的，然后放到第一个位置。之后再看剩余元素中最小的，放到第二个位置……以此类推，就可以完成整个的排序工作了。

选择排序
def select_sort(li):
    for i in range(len(li)-1):    #循环趟
        min_loc=i                 #设置i为最小下标
        for j in range(1+i,len(li)-1):    #循环无序区
            if li[min_loc]>li[j]:   #如过不是最小值,就换下标
                min_loc=j
        if min_loc!=i:                #如果下标不是原来的值,就互换
            li[i],li[min_loc]=li[min_loc],li[i]

三、插入排序

基本思想：将列表分为有序区和无序区两个部分,最初有序区只有一个元素,.每次从无序区选择一个元素,插入到无序区的位置,直到无序区变空.

# 插入排序
def insert_sort(li):
    for i in range(1, len(li)):   #走趟,从第一个数开始
        tmp = li[i]              #tmp为无序区手中拿的那张牌
        j = i - 1                #j 为有序区的右侧第一张牌
        while j >= 0 and tmp < li[j]:
            print(li)
            #当 有序区至少一张牌,且有序区右侧第一张牌大于需要插入的牌时
            li[j + 1] = li[j] #有序区右侧第一张牌继续向右移位,
            j = j - 1          #有序区向右移一位,继续让手牌去比较
        li[j + 1] = tmp    #当手牌不比左边的牌大了,将手牌插入

四、快速排序

基本思想：取一个元素p(第一个元素),使p归位,,,列表被分为两部分,左边都比p小,右边都比p大,.递归完成排序

# 取一个元素p（第一个元素），使元素p归位；
# 列表被p分成两部分，左边都比p小，右边都比p大；

第一种实现方式:
# 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     #这时候左右下标应该指向一个,就确定了tmp的位置
#     return left
# # 递归完成排序。
# 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)
# arr = [1, 4, 7, 1, 5, 5, 3, 85, 34, 75, 23, 75, 2, 0]
# quick_sort(arr,0,len(arr)-1)
# print(arr)

# 第二种方式

def quickSort(array):
    if len(array) < 2:    #如果数组就一个值,那就直接返回
        return array
    else:
        pivot = array[0]    #拿到第一个值,
        less = [i for i in array[1:] if i < pivot]   #比这个值小的都放左边,
        greater = [j for j in array[1:] if j > pivot]   #比这个值大的都扔右边
        return quickSort(less) + [pivot] + quickSort(greater) #返回这个数组

print(quickSort([1,5,2,6,9,3]))

五、归并排序

基本思想：假设我们有一个没有排好序的序列(14,12,15,13,11,16)，那么首先我们使用分割的办法将这个序列分割成一个个已经排好序的子序列。然后再利用归并的方法将一个个的子序列合并成排序好的序列。分割和归并的过程可以看下面的图例。这样通过先递归的分解数列，再合并数列就完成了归并排序。

def merge(left,right):
    result = []
    while left and right:  #当两边都有值的时候
        result.append(left.pop(0) if left[0] <= right[0] else right.pop(0))
    while left:  #只有Ｌｅｆｔ有值的时候
        result.append(left.pop(0))
    while right:   #只有right有值的时候
        result.append(right.pop(0))

    return result

def mergeSort(relist):
    if len(relist) <= 1:
        return relist
    mid_index = len(relist)//2   #先将列表查分为两部分
    left = mergeSort(relist[:mid_index])  # 递归拆解的过程
    right = mergeSort(relist[mid_index:])
    return merge(left,right)  # 合并的过程

print(mergeSort([1,5,2,9]))