常见排序及算法
1.交换排序(附算法详细解释链接)
(1)冒泡排序：
第1个和第2个数字比较，较大的数放在后面；第2个和第3个数字比较，较大的数放在后面，直到比较到最后一个
参考链接： https://www.cnblogs.com/chengxiao/p/6103002.html
(2)快速排序：
从需要排序的数里面随便找出一个，然后，把比这个数小的放在这个数左边，比这个数大的放在这个数右边，一样大的和这个数放在一起，最后，左右两边各自重复上述过程，直到左边或右边只剩下一个数（或零个数）无法继续为止
参考链接： https://www.jianshu.com/p/1bd09e10f6db?nomobile=yes
2.插入排序
(1)简单插入排序：
把第一个数当作已经排序的，然后把第二个数比较插入对应的位置；然后把第三个和前两个进行比较，插入对应的位置
参考链接： https://www.cnblogs.com/chengxiao/p/6103002.html
(2)希尔排序：
希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止
参考链接： https://www.cnblogs.com/chengxiao/p/6104371.html
3.选择排序
(1)简单选择排序：
每一趟从待排序的数据元素中选择最小（或最大）的一个元素作为首元素，直到所有元素排完为止
参考链接： https://www.cnblogs.com/chengxiao/p/6103002.html
(2)堆排序：
按大顶堆构建堆，其中大顶堆的一个特性是数据将被从大到小取出，将取出的数字按照相反的顺序进行排列，数字就完成了排序
参考链接： https://www.jianshu.com/p/0d383d294a80
框架中详细解释：
4.排序算法（python已测试通过）
# -*- coding:utf-8 -*-
__author__ = 'cq'
import time
import random
import sys
import copy
def time_cost(func):
def wrapper(*args, **kwargs):
sTime = time.time()
func(*args, **kwargs)
print("Time cost:%s" % (time.time() - sTime))
print(args[0])
return wrapper
# -------------------冒泡排序-----------------------#
@time_cost
def bubble_sort(list):
print("\nbubble_sort:")
for i in range(len(list) - 1):
tag = 0
for j in range(len(list) - i - 1):
if list[j] > list[j + 1]:
list[j], list[j + 1] = list[j + 1], list[j]
tag = 1
if not tag:
return
# -------------------插入排序-----------------------#
@time_cost
def insert_sort(list):
print("\ninsert_sort:")
for i in range(len(list)):
tag = 0
for j in range(i, 0, -1):
if list[j] < list[j - 1]:
list[j], list[j - 1] = list[j - 1], list[j]
tag = 1
if not tag:
break
# -------------------选择排序-----------------------#
@time_cost
def select_sort(list):
print("\nselect_sort:")
for i in range(len(list) - 1):
min = i
for j in range(i + 1, len(list)):
if list[min] > list[j]:
min = j
if min != i:
list[i], list[min] = list[min], list[i]
# -------------------快速排序-----------------------#
def part_sort(list, left, right):
temp = list[left]
while left < right:
while left < right and temp <= list[right]:
right -= 1
list[left] = list[right]
while left < right and temp >= list[left]:
left += 1
list[right] = list[left]
list[left] = temp
return left
def _quckly_sort(list, left, right):
if left < right:
mid = part_sort(list, left, right)
_quckly_sort(list, left, mid - 1)
_quckly_sort(list, mid + 1, right)
@time_cost
def quckly_sort(list):
print("\nquckly_sort:")
return _quckly_sort(list, 0, len(list) - 1)
# -------------------堆排序-----------------------#
def sift(list, low, high):
i = low
j = 2 * i + 1
temp = list[i]
while j <= high:
if j < high and list[j] < list[j + 1]:
j += 1
if temp < list[j]:
list[i] = list[j]
i = j
j = 2 * i + 1
else:
break
list[i] = temp
list[low], list[high] = list[low], list[high]
@time_cost
def heap_sort(list):
print("\nheap_sort:")
n = len(list)
for i in range(n // 2 - 1, -1, -1):
sift(list, i, n - 1)
for i in range(n - 1, -1, -1):
list[0], list[i] = list[i], list[0]
sift(list, 0, i - 1)
# -------------------归并排序-----------------------#
def ont_megre_sort(list, low, mid, high):
i = low
j = mid + 1
ltmp = []
while i <= mid and j <= high:
if list[i] < list[j]:
ltmp.append(list[i])
i += 1
else:
ltmp.append(list[j])
j += 1
while i <= mid:
ltmp.append(list[i])
i += 1
while j <= high:
ltmp.append(list[j])
j += 1
list[low:high + 1] = ltmp
def _megre_sort(list, low, high):
if low < high:
mid = (low + high) // 2
_megre_sort(list, low, mid)
_megre_sort(list, mid + 1, high)
ont_megre_sort(list, low, mid, high)
@time_cost
def megre_sort(list):
print("\nmegre_sort:")
return _megre_sort(list, 0, len(list) - 1)
# -------------------希尔排序-----------------------#
@time_cost
def shell_sort(list):
print("\nshell_sort:")
gap = len(list) // 2
while gap > 0:
for i in range(gap, len(list)):
temp = list[i]
j = i - gap
while j >= 0 and temp < list[j]:
list[j + gap] = list[j]
j -= gap
list[j + gap] = temp
gap //= 2
def main():
# 生成列表
list0 = list(range(100))
first_name = ["chen", "zhang", "li", "wang", "zhao"]
second_name = ["b", "a", "r", "t", "n"]
third_name = ["q", "g", "m", "f", "h"]
listname = [
{"id": "1000" + str(i),
"name": random.choice(first_name) +
random.choice(second_name) +
random.choice(third_name),
"age": random.randint(16, 60)
} for i in range(10)
]
random.shuffle(list0)
random.shuffle(listname)
# copy四份打乱后的列表
list1 = copy.deepcopy(list0)
list2 = copy.deepcopy(list0)
list3 = copy.deepcopy(list0)
list4 = copy.deepcopy(list0)
list5 = copy.deepcopy(list0)
list6 = copy.deepcopy(list0)
list7 = copy.deepcopy(list0)
# 设置递归深度
sys.setrecursionlimit(10000)
print("sort_list:")
print(list0)
# 排序算法
bubble_sort(list1)
select_sort(list2)
insert_sort(list3)
quckly_sort(list4)
heap_sort(list5)
megre_sort(list6)
shell_sort(list7)
print("\npractice to sort this list:")
for i in listname:
print(i)
if "__main__" == __name__:
main()
参考链接：https://www.cnblogs.com/cq146637/p/8060058.html
注：此文章为整合的网上优秀回答
参考链接如下：
https://www.cnblogs.com/chengxiao/p/6103002.html
https://www.jianshu.com/p/1bd09e10f6db?nomobile=yes
https://www.cnblogs.com/chengxiao/p/6103002.html
https://www.cnblogs.com/chengxiao/p/6104371.html
https://www.cnblogs.com/chengxiao/p/6103002.html
https://www.jianshu.com/p/0d383d294a80
https://www.cnblogs.com/cq146637/p/8060058.html