Python面试种常见的算法（排序问题）

python开发面试中总会问到一些算法类题目。总结后发现常见的算法题目多为以下几种：
1、冒泡排序
冒泡排序是一个基础的算法，他重复的走访要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们换过来。走访数列的工作是重复地进行直到没有在需要交换。

def bubble_sort(listInfo):
    length = len(listInfo)
    for j in range(length-1):
        count = 0
        for i in range(0, length-1-j):
            if listInfo[i] > listInfo[i+1]:
                listInfo[i], listInfo[i+1] = listInfo[i+1], listInfo[i]
                count += 1
        if count == 0:
            return


def main():
    print("冒泡函数排序：")
    li = [10, 22, 9, 666, 32, 21, 11]
    print(li)
    bubble_sort(li)
    print(li)


if __name__ == '__main__':
    main()

或者简单些可以写成：

li = [10, 22, 9, 666, 32, 21, 11]
for j in range(len(li)-1):
    for i in range(len(li)-1-j):
        if li[i] > li[i+1]:
            li[i], li[i+1] = li[i+1], li[i]

print(li)

结果为：

冒泡函数排序：
[10, 22, 9, 666, 32, 21, 11]
[9, 10, 11, 21, 22, 32, 666]

2、快速排序
快速排序就是冒泡排序的一种改进。快速排序的原理就是通过一次排序将要排序的数据分割成两部分，其中一部分的所有数据都比另外一部分的所有数据都要小。然后按此方法分别对两部分数据进行快速排序，整个排序过程可以递归进行，以此使整个数列变成有序数列。

def quick_sort(li, first, last):
    if first >= last:
        return
    mid_value = li[first]
    low = first
    high = last
    while low < high:
        while low < high and li[high] >= mid_value:
            high -= 1
        li[low] = li[high]
        while low < high and li[low] < mid_value:
            low += 1
        li[high] = li[low]
    li[low] = mid_value
    quick_sort(li, first, low-1)
    quick_sort(li, low+1, last)


def main():
    print("快速排序：")
    li = [5, 1, 44, 23, 67, 99, 87, 101]
    print(li)
    quick_sort(li, 0, len(li)-1)
    print(li)


if __name__ == '__main__':
    main()

3、选择排序
选择排序是一种简单直观的排序算法。他的原理是第一次从带排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最大小（大）的元素，放置在已排序的序列末尾。

def select_sort(li):
    length = len(li)
    for j in range(length-1):
        min_index = j
        for i in range(j+1, length):
            if li[min_index] > li[i]:
                min_index = i
        li[j], li[min_index] = li[min_index], li[j]


def main():
    print("选择排序：")
    li = [36, 99, 55, 78, 11, 65, 22, 18, 58]
    print(li)
    select_sort(li)
    print(li)


if __name__ == '__main__':
    main()

4、插入排序
插入排序对于少量的元素排序来说，它是一个有效的算法。插入排序的基本思想是将一个记录插入到已经排好序的表中，从而一个新的、纪录数增1的有序表。在代码实现过程使用双层循环，外层循环除了对第一个元素之外的所有元素，内层循环对当前元素前面有序表进行待插入位置查找，并进行移动。

def insert_sort(li):
    length = len(li)
    for j in range(1, length):
        i = j
        while i > 0:
            if li[i] < li[i-1]:
                li[i], li[i-1] = li[i-1], li[i]
                i -= 1
            else:
                break


def main():
    print("插入排序：")
    li = [5, 1, 44, 23, 67, 99, 87, 101]
    print(li)
    insert_sort(li)
    print(li)


if __name__ == '__main__':
    main()

5、希尔排序
希尔排序又叫“缩小增量排序”，是直接插入排序算法的高效改进版。希尔排序是非稳定排序算法。它是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量之间减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

def shell_sort(li):
     = len(li)
    gap = n // 2
    while gap >= 1:
        for j in range(gap, n):
            i = j
            while (i - gap) >= 0:
                if li[i] < li[i - gap]:
                    li[i], li[i - gap] = li[i - gap], li[i]
                    i -= gap
                else:
                    break
        gap //= 2


def main():
    print("希尔排序：")
    li = [54, 26, 93, 17, 77, 31, 44, 55, 20]
    print(li)
    shell_sort(li)
    print(li)


if __name__ == '__main__':
    main()

6、归并排序
归并排序是建立在归并才做上的一种有效、文星的排序算法，该算法是采用分治法的一个非常典型的应用。将已有的子序列合并，得到完全的有序序列；即先使每个子序列有序，再试子序列段间有序。若将两个有序列表合并成一个有序表，成为二路归并。

def merge_sort(listInfo):
    length = len(listInfo)
    if length <= 1:
        return listInfo
    mid = length // 2
    left_li = merge_sort(listInfo[:mid])
    right_li = merge_sort(listInfo[mid:])
    left_pointer, right_pointer = 0, 0
    result = []
    while left_pointer < len(left_li) and right_pointer < len(right_li):
        if left_li[left_pointer] < right_li[right_pointer]:
            result.append(left_li[left_pointer])
            left_pointer +=1
        else:
            result.append(right_li[right_pointer])
            right_pointer += 1
    result += left_li[left_pointer:]
    result += right_li[right_pointer:]
    return result
 
def main():
     print("归并排序测试：")
     li = [36,99,55,78,11,65,22,18,58]
     print(li)
     sortedResult = merge_sort(li)
     print(sortedResult)
 
if __name__ == '__main__':
	main()

7、堆排序
堆是一种近似完全二叉树的数据结构，堆排序是指利用堆这种数据结构所设计的一种排序算法。
堆排序满足堆积的性质：即子节点的键值或索引总是小于（或大于）他的父节点。

def big_endian(arr, start, end):
    root = start
    child = root*2+1
    while child <= end:
        if child + 1 <= end and arr[child] < arr[child+1]:
        # 为了始终让其跟子元素的较大必值，如果有变大就左换右，左边大即为默认。
            child += 1
        if arr[root] < arr[child]:
        # 父节点小于子节点直接交换位置，同时坐标也得交换，这样下次循环可以准确判断：是否为底层
        # 是不是调整完毕
            arr[root], arr[child] = arr[child], arr[root]
            root = child
            child = root*2+1
        else:
            break


def heap_sort(arr):
    first = len(arr)//2-1
    for start in range(first, -1, -1):
        # 从下到上，从左至右对每个节点进行调整，循环得到非叶子节点
        big_endian(arr, start, len(arr)-1)
    for end in range(len(arr)-1, 0, -1):
        arr[0], arr[end] = arr[end], arr[0]
        big_endian(arr, 0, end-1)
    return arr


def main():
    print("堆排序：")
    li = [58, 4, 123, 55, 66, 12, 8, 520]
    print(li)
    heap_sort(li)
    print(li)


if __name__ == '__main__':
    main()

8、基数排序
基数排序是一种非比较型整数排序法算法，其原理是将郑书记澳门位数切割成不同的数字，然后按每个位数比较。由于整数也可以表达字符串和特定的格式的浮点数。所以基数排序也不是只能是用于整数。

def radix_sort(array):
    max_num = max(array)
    place = 1
    while max_num > 10 ** place:
        place += 1
    for i in range(place):
        buckets = [[] for _ in range(10)]
        for num in array:
            radix = int(num / (10 ** i) % 10)
            buckets[radix].append(num)
        j = 0
        for k in range(10):
            for num in buckets[k]:
                array[j] = num
                j += 1
    return array


if __name__ == '__main__':
    array = [25, 17, 33, 17, 22, 13, 32, 15, 9, 25, 27, 18]
    print(radix_sort(array))