Python 实现七大排序算法,面试竟然被这 31 道 Python 基础题难倒了
该方法因 DL.Shell 于 1959 年提出而得名。 希尔排序是把记录按下标的一定增量分组,对每组使用直接插入排序算法排序;随着增量逐渐减少,每组包含的关键词越来越多,当增量减至 1 时,整个文件恰被分成一组,算法便终止。
代码实现
-- coding: UTF-8 --
def shell_sort(lists):
希尔排序 时间复杂度是 O(n log n)
count = len(lists)
step = 2
group = int(count / step)
while group > 0:
for i in range(0, group):
j = i + group
while j < count:
k = j - group
key = lists[j]
while k >= 0:
if lists[k] > key:
lists[k + group] = lists[k]
lists[k] = key
k -= group
j += group
group = int(group / step)
return lists
if name == "main":
test = [2, 5, 4, 6, 7, 3, 2]
print(shell_sort(test))
描述
时间复杂度是 O(n2), 是稳定排序算法。
它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。
代码实现
-- coding: UTF-8 --
def bubble_sort(lists):
冒泡排序 时间复杂度是 O(n2)
count = len(lists)
for i in range(0, count - 1):
for j in range(0, count - i - 1):
if lists[j] > lists[j + 1]:
lists[j], lists[j + 1] = lists[j + 1], lists[j]
return lists
if name == "main":
test = [2, 5, 4, 6, 7, 3, 2]
print(bubble_sort(test))
描述
快速排序的时间复杂度是 O(n log n), 是不稳定排序算法。
通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。
代码实现
-- coding: UTF-8 --
def quick_sort(lists, left, right):
快速排序 时间复杂度是 O(n log n)
if left >= right:
return lists
key = lists[left]
low = left
high = right
while left < right:
while left < right and lists[right] >= key:
right -= 1
lists[left] = lists[right]
while left < right and lists[left] <= key:
left += 1
lists[right] = lists[left]
lists[right] = key
quick_sort(lists, low, left - 1)
quick_sort(lists, left + 1, high)
return lists
if name == "main":
test = [2, 5, 4, 6, 7, 3, 2]
print(quick_sort(test, 0, len(test) - 1))
描述
选择排序的时间复杂度是 O(n2), 是不稳定排序算法。
基本思想:第 1 趟,在待排序记录 r1 ~ r[n] 中选出最小的记录,将它与 r1 交换;第 2 趟,在待排序记录 r2 ~ r[n] 中选出最小的记录,将它与 r2 交换;以此类推,第 i 趟在待排序记录 r[i] ~ r[n] 中选出最小的记录,将它与 r[i] 交换,使有序序列不断增长直到全部排序完毕。
代码实现
-- coding: UTF-8 --
def select_sort(lists):
选择排序 时间复杂度是 O(n2)
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
if name == "main":
test = [2, 5, 4, 6, 7, 3, 2]
print(select_sort(test))
描述
堆排序的时间复杂度是 O(n log n), 是不稳定排序算法。
堆排序(Heapsort)是指利用堆积树(堆)这种数据结构所设计的一种排序算法,它是选择排序的一种。可以利用数组的特点快速定位指定索引的元素。堆分为大根堆和小根堆,是完全二叉树。大根堆的要求是每个节点的值都不大于其父节点的值,即 A[PARENT[i]] >= A[i]
。在数组的非降序排序中,需要使用的就是大根堆,因为根据大根堆的要求可知,最大的值一定在堆顶。
代码实现
-- coding: UTF-8 --
from collections import deque
def swap_param(lists, i, j):
lists[i], lists[j] = lists[j], lists[i]
return lists
def heap_adjust(lists, start, end):
temp = lists[start]
i = start
j = 2 * i
while j <= end:
if (j < end) and (lists[j] < lists[j + 1]):
j += 1
if temp < lists[j]:
lists[i] = lists[j]
i = j
j = 2 * i
else:
break
lists[i] = temp
def heap_sort(lists):
length = len(lists) - 1
first_sort_count = length / 2
for i in range(first_sort_count):
heap_adjust(lists, first_sort_count - i, length)
for i in range(length - 1):
lists = swap_param(lists, 1, length - i)
heap_adjust(lists, 1, length - i - 1)
return [lists[i] for i in range(1, len(lists))]
def main():
lists = deque([50, 16, 30, 10, 60, 90, 2, 80, 70])
lists.appendleft(0)
print heap_sort(lists)
(1)Python 所有方向的学习路线(新版)
这是我花了几天的时间去把 Python 所有方向的技术点做的整理,形成各个领域的知识点汇总,它的用处就在于,你可以按照上面的知识点去找对应的学习资源,保证自己学得较为全面。
最近我才对这些路线做了一下新的更新,知识体系更全面了。
(2)Python 学习视频
包含了 Python 入门、爬虫、数据分析和 web 开发的学习视频,总共 100 多个,虽然没有那么全面,但是对于入门来说是没问题的,学完这些之后,你可以按照我上面的学习路线去网上找其他的知识资源进行进阶。
(3)100 多个练手项目
我们在看视频学习的时候,不能光动眼动脑不动手,比较科学的学习方法是在理解之后运用它们,这时候练手项目就很适合了,只是里面的项目比较多,水平也是参差不齐,大家可以挑自己能做的项目去练练。
评论