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))