python常用算法

1. 插入排序

• 算法描述:将列表中每一个元素与其他元素相比较后形成新的列表

lists = [69, 65, 90, 37, 92, 6, 28, 54]print(lists)def insert_sort(lists):    count = len(lists)    for i in range(1, count):        cur_number = lists[i]        for j in range(i - 1, -1, -1):            if lists[j] > cur_number:                lists[j], lists[j + 1] = lists[j + 1], lists[j]            else:                lists[j + 1] = cur_number                break    return listsprint(insert_sort(lists)) 

2. 希尔排序

• 算法描述:在插入排序思想基础上，将列表中元素按照一定规则分组，当分组间隔为1时，排序完成

lists = [69, 65, 90, 37, 92, 6, 28, 54]print(lists)def shell_sort_1(_list):    count = len(_list)    gap = count // 2    while gap > 0:        for i in range(gap, count):            current_item = _list[i]            j = i            while j >= gap and current_item < _list[j - gap]:                _list[j] = _list[j - gap]                j -= gap            _list[j] = current_item        gap //= 2    return _listprint(shell_sort_1(lists))

3. 冒泡排序

• 算法描述：它重复的走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来，一直重复直到排序完成，就像从杯底向上的一个个泡泡

lists = [69, 65, 90, 37, 92, 6, 28, 54]def bubble_sort(lists):    count = len(lists)    for i in range(0, count):        for j in range(i+1, count):            if lists[i] > lists[j]:                lists[i], lists[j] = lists[j], lists[i]    return listsprint(bubble_sort(lists))

4. 快速排序

• 算法描述：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据比另外一部分的所有数据都要小，然后再按照此方法对这两部分数据进行排序。

lists = [69, 65, 90, 37, 92, 6, 28, 54]def quick_sort(_list):    if len(_list) <= 1:        return _list    pivot = _list[len(_list) // 2]    left = [x for x in _list if x < pivot]    middle = [x for x in _list if x == pivot]    right = [x for x in _list if x > pivot]    return quick_sort(left) + middle + quick_sort(right)print(quick_sort(lists))

5. 直接选择排序

• 算法描述：
  
  • 第1趟：在待排序lists中比较lists[0]与lists[1:n]中的值，若lists[0]>lists[min],则交换，
  • 第二趟：在待排序lists中比较lists[1]与lists[2:n]中的值，若lists[1]>lists[min]，则交换，以此类推

lists = [69, 65, 90, 37, 92, 6, 28, 54]def select_sort(lists):    count = len(lists)    for i in range(0, count):        min = i        for j in range(i+1, count):            if lists[min] > lists[j]:                min = j        lists[min], lists[i] = lists[i], lists[min]    return listsprint(select_sort(lists))

6. 堆排序

• 算法思路：将待排序lists构建成一个完全二叉树，二叉树的每一个父节点均大于二个子节点，处于最上端的父节点是整个序列的最大值，第一趟将最上面的父节点提出放至lists末尾，然后将整个树最小子节点放至最大父节点，重新构建二叉树，依次类推

lists = [69, 65, 90, 37, 92, 6, 28, 54]def adjust_heap(lists, i, size):    lchild = 2*i+1    rchild = 2*i+2    max = i    if i < size/2:        if lchild < size and lists[lchild] > lists[max]:            max = lchild        if rchild < size and lists[rchild] > lists[max]:            max = rchild        if max != i:            lists[max], lists[i] = lists[i], lists[max]            adjust_heap(lists, max, size)def heap_sort(lists):    size = len(lists)    for i in range(0, size//2)[::-1]:        adjust_heap(lists, i, size)    for j in range(0, size)[::-1]:        lists[0], lists[j] = lists[j], lists[0]        adjust_heap(lists, 0, j)    return lists print(heap_sort(lists))```# 7. 归并排序- 第一趟将lists中的元素以长度为1分隔并排序，第二趟以长度为3分隔并排序，最终趟以len(lists)为长度进行排序```lists = [69, 65, 90, 37, 92, 6, 28, 54, 34, 95]def merge(a, b):    c = []    while len(a) != 0 and len(b) != 0:        if a[0] < b[0]:            c.append(a[0])            a.remove(a[0])        else:            c.append(b[0])            b.remove(b[0])    if len(a) == 0:        c += b    else:        c += a    return cdef merge_sort(lists):    if len(lists) == 0 or len(lists) == 1:        return lists    else:        middle = len(lists)//2        a = merge_sort(lists[:middle])        b = merge_sort(lists[middle:])        return merge(a, b)print(merge_sort(lists))```<div class="se-preview-section-delimiter"></div># 8. 桶排序- 算法描述：将要排序的元素分配至某些“桶”中，如0~10是一个桶，10~20是一个桶，在这个桶中范围的数进行排序，然后再排序所有桶<div class="se-preview-section-delimiter"></div>

lists = [69, 65, 90, 37, 92, 6, 28, 54]
print(lists)

def insertion_sort(lists):
for i in range(1, len(lists)):
current_number = lists[i]
for j in range(i-1, -1, -1):
if lists[j] > current_number:
lists[j], lists[j+1] = lists[j+1], lists[j]
else:
lists[j+1] = current_number
break
return lists

def bucket_sort(lists, bucket_size = 5):
string = False
if len(lists) == 0 or len(lists) == 1:
return lists
elif all(isinstance(element, str) for element in lists):
string = True
lists = [ord(element) for element in lists]
min_value = lists[0]
max_value = lists[0]

for i in range(0, len(lists)):    if lists[i] < min_value:        min_value = lists[i]    elif lists[i] > max_value:        max_value = lists[i]bucket_count = math.floor((max_value - min_value) / bucket_size) + 1buckets = []for i in range(0, int(bucket_count)):    buckets.append([])for i in range(0, len(lists)):    buckets[math.floor(float(lists[i] - min_value) / bucket_size)].append(lists[i])sorted_array = []for i in range(0,len(buckets)):    insertion_sort(buckets[i])    for j in range(0, buckets[i]):        sorted_array.append(buckets[i][j])if string:    return [chr(element) for element in sorted_array]else:    return sorted_array```

import math

”’ 下段程序输出结果将是list1 = [10]list2 = [1, 123]list3 = [10, ‘a’]
因为首先计算了list1至list3,然后再执行打印的操作，
因此list3引用函数的返回值覆盖了list1的返回值即[10],因此list1也返回[10,’a’]

def extendlist(val, list=[]):    list.append(val)    return listlist1 = extendlist(10)list2 = extendlist(123, [1,])list3 = extendlist('a')print('list1 = %s'% list1)print('list2 = %s'% list2)print('list3 = %s'% list3)```'''如果要更改上述内容，则需要对代码进行如下更改'''<div class="se-preview-section-delimiter"></div>

def extendlist(val,list=None):
if list is None:
list = []
list.append(val)
return list
list1 = extendlist(10)
list2 = extendlist(123, [1,])
list3 = extendlist(‘a’)

print(‘list1 = %s’% list1)
print(‘list2 = %s’% list2)
print(‘list3 = %s’% list3)“`

”’下段程序的输出结果将是：

[[], [], [], [], []][[10], [10], [10], [10], [10]][[10, 20], [10, 20], [10, 20], [10, 20], [10, 20]][[10, 20], [10, 20], [10, 20], [10, 20], [10, 20], 30]```此时list不能简简单单的认为是5个不相关的空列表'''<div class="se-preview-section-delimiter"></div>

list = [[]]*5
print(list)
list[0].append(10)
print(list)
list[1].append(20)
print(list)
list.append(30)
print(list)“`

”’给定一个含有N个数字的列表，使用单一的列表生成式来产生一个新的列表，该列表只包含满足以下条件的值：
（1）value为偶数
（2）key为偶数
将满足条件的值建立一个新的列表”’

numb1 = [0, 1, 2, 3, 4, 5, 6, 7, 8]list1 = [2, 2, 3, 4, 5, 6, 8, 10, 12]list2 = []for number in list1[::2]:    if number%2==0:        list2.append(number)print(list2)```'''斐波那契数列'''<div class="se-preview-section-delimiter"></div>#简单版<div class="se-preview-section-delimiter"></div>

def fib(n):
if n==1 or n==0:
return 1
else:
return fib(n-2)+fib(n-1)
print([fib(n) for n in range(10)])“`
由于存在大量的重复计算，如fib(10)计算fib(9)和fib(8),f(9)也需要计算fib(8),因此建立一个缓存及加快计算速度

def fib(n,cache=None):    if cache == None:        cache = {}    if n in cache:        return cache[n]    if n==1 or n==0:        return 1    else:        cache[n] = fib(n-2, cache)+fib(n-1, cache)    return cache[n]print([fib(n) for n in range(10)])```'''爬楼梯：比如有7级台阶，只能1步或2步，且不能倒退，问一共有多少种排列方法'''- 简单版<div class="se-preview-section-delimiter"></div>

def climb(n,steps):
count = 0
if n<=1:
count = 1
else:
for step in steps:
count += climb(n-step, steps)
return count“`

• 效率版

“`
def decorate(func):
cache = {}
def wrap(n):
if n not in cache:
cache[n] = func(n)
return cache[n]
return wrap

@decorate
def fib(n):
if n == 1 or n == 0 :
return 1
else:
return fib(n-2)+fib(n-1)

print([fib(n) for n in range(10)])“`