数据结构python学生成绩排序_数据结构与常见排序算法之算法篇（基于Python）

什么是算法？

我们举一个可能不太恰当的例子：

如果将最终写好运行的程序比作战场，我们码农便是指挥作战的将军，而我们所写的代码便是士兵和武器。

那么数据结构和算法是什么？答曰：兵法！

我们可以不看兵法在战场上肉搏，如此，可能会胜利，可能会失败。即使胜利，可能也会付出巨大的代价。我们写程序亦然：没有看过数据结构和算法，有时面对问题可能会没有任何思路，不知如何下手去解决；大部分时间可能解决了问题，可是对程序运行的效率和开销没有意识，性能低下；有时会借助别人开发的利器暂时解决了问题，可是遇到性能瓶颈的时候，又不知该如何进行针对性的优化。

如果我们常看兵法，便可做到胸有成竹，有时会事半功倍！同样，如果我们常看数据结构与算法，我们写程序时也能游刃有余、明察秋毫，遇到问题时亦能入木三分、迎刃而解。

故，数据结构和算法是一名程序开发人员的必备基本功，不是一朝一夕就能练成绝世高手的。冰冻三尺非一日之寒，需要我们平时不断的主动去学习积累。

在这里将通过以下几个排序算法来演示：

* 冒泡排序

* 选择排序

* 插入排序

* 希尔排序

* 快速排序

* 归并排序

分类演说

一、冒泡排序

1.冒泡排序算法的运作如下:

比较相邻的元素。如果第一个比第二个大(升序)，就交换他们两个。

对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

针对所有的元素重复以上的步骤，除了最后一个。

持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

2.交换过程图解:

冒泡排序

3.时间复杂度

最优时间复杂度：O(n) (表示遍历一次发现没有任何可以交换的元素，排序结束。)

最坏时间复杂度：O(n2)

稳定性：稳定

4.代码演示：

def bubble_sort1(numList):

"""冒泡排序(正向，从前到后排,时间复杂度O(n2))"""

length = len(numList)

for i in range(0, length - 1):

for j in range(0, length - 1 - i):

if numList[j] > numList[j + 1]:

numList[j], numList[j + 1] = numList[j + 1], numList[j]

def bubble_sort2(numList):

"""冒泡排序(反向，从后往前排，时间复杂度O(n2))"""

length = len(numList)

for i in range(length - 1, 0, -1):

for j in range(i):

if numList[j] > numList[j + 1]:

numList[j], numList[j + 1] = numList[j + 1], numList[j]

def bubble_sort3(numList):

"""冒泡排序(如果给出的列表就是有序的序列，那么可以这样优化,时间复杂度O(n2)，最优为O(n))"""

length = len(numList)

for i in range(length - 1, 0, -1):

is_change = False

for j in range(i):

if numList[j] > numList[j + 1]:

numList[j], numList[j + 1] = numList[j + 1], numList[j]

is_change = True

if not is_change:

return

if __name__ == '__main__':

li = [23, 23, 97, 1, 45, 775, 9, 12]

li2 = [2, 1, 97, 324, 45, 775, 0, 12]

li3 = [1, 2, 3, 4, 5, 6, 7, 8]

li4 = [2, 1, 97, 324, 45, 775, 0, 12]

print("排序前：" + str(li))

bubble_sort1(li)

print("正向排序" + str(li))

print("排序前：" + str(li2))

bubble_sort2(li2)

print("反向排序" + str(li2))

print("排序前：" + str(li3))

bubble_sort3(li3)

print("优化排序" + str(li3))

print("排序前：" + str(li4))

bubble_sort3(li4)

print("优化排序" + str(li4))

二、选择排序

1.选择排序的原理

首先在未排序序列中找到最小(大)元素，存放到排序序列的起始位置

再从剩余未排序元素中继续寻找最小(大)元素， 然后放到已排序序列的末尾。

以此类推，直到所有元素均排序完毕。

2.排序过程图解:

选择排序

3.时间复杂度

最优时间复杂度：O(n2)

最坏时间复杂度：O(n2)

稳定性：不稳定(考虑升序每次选择最大的情况)

4.代码演示：

def select_sort(numList):

length = len(numList)

for i in range(length - 1):

minIndex = i

for j in range(i + 1, length):

if numList[minIndex] > numList[j]:

minIndex = j

numList[i], numList[minIndex] = numList[minIndex], numList[i]

print("排序过程中：" + str(li))

if __name__ == '__main__':

li = [23, 23, 97, 1, 45, 775, 9, 12]

print("排序前：" + str(li))

select_sort(li)

print("排序后：" + str(li)

三、插入排序

1.插入排序算法的运作如下:

它是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

2.排序过程图解:

插入排序

3.时间复杂度

最优时间复杂度：O(n) (升序排列，序列已经处于升序状态)

最坏时间复杂度：O(n2)

稳定性：稳定

4.代码演示：

def insert_sort(numList):

length = len(numList)

for i in range(1, length):

# for j in range(0, i):

#

# if numList[i] < numList[j]:

# numList[i], numList[j] = numList[j], numList[i]

for j in range(i, 0, -1):

if numList[j] < numList[j - 1]:

numList[j], numList[j - 1] = numList[j - 1], numList[j]

else:

break

if __name__ == '__main__':

li = [23, 23, 97, 1, 45, 775, 9, 12]

print("插入排序：")

print("排序前：" + str(li))

insert_sort(li)

print("排序后：" + str(li))

四、归并排序

1.归并排序的原理

归并排序是采用分治法的一个非常典型的应用。归并排序的思想就是先递归分解数组，再合并数组。

将数组分解最小之后，然后合并两个有序数组，基本思路是比较两个数组的最前面的数，谁小就先取谁，取了后相应的指针就往后移一位。然后再比较，直至一个数组为空，最后把另一个数组的剩余部分复制过来即可。

2.排序过程图解

归并排序

3.时间复杂度

最优时间复杂度：O(nlogn)

最坏时间复杂度：O(nlogn)

稳定性：稳定

4.代码演示

def merge_sort(numlist):

# 1.获取到需要排序的队列

length = len(numlist)

# 2.判断列表的长度，如果为1则不需排序直接返回

if length <= 1:

return numlist

# 3.获取中间点，将队列的元素分成两个部分，递归继续拆分

center_point = length // 2

# 拆分的左边的部分

left_list = merge_sort(numlist[:center_point])

# 拆分的右边的部分，继续递归，直至队列的元素为1

right_list = merge_sort(numlist[center_point:])

# 4.初始化两个控制点,和存放排序后的队列

left_point, right_point = 0, 0

result = []

# 5.循环比较左右两侧对应角标的元素大小

while left_point < len(left_list) and right_point < len(right_list):

# 左边的元素和右边的元素相比较，将小的元素添加栋队列中

if left_list[left_point] <= right_list[right_point]:

result.append(left_list[left_point])

left_point += 1

else:

result.append(right_list[right_point])

right_point += 1

# 当退出上面的while循环就说明左侧或者右侧有一方的元素已经全部取完了，此时如果另一方如果还有元素那么就将剩余的元素添加到result中

result += left_list[left_point:]

result += right_list[right_point:]

# 6.返回排序后的队列给用户

return result

if __name__ == '__main__':

num_list = [12, 87, 9, 6, 2, 876, 12, 0, 4]

print("排序前：" + str(num_list))

sortList = merge_sort(num_list)

print("排序后：" + str(sortList))

持续更新....

喜欢的朋友动动小手点个赞咯，我会继续更新相关的内容，还望多多支持。