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 lists
print(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 _list

print(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 lists

print(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 lists
print(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 c

def 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) + 1
buckets = []
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 list

list1 = 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)])“`