练习5_python3排序算法-Copy1
python排序方法
python排序方法一、冒泡排序冒泡排序是一种简单的排序算法，它重复地遍历待排序序列，每次比较相邻的两个元素，如果顺序错误就交换它们。
经过一轮的遍历，最大的元素会排到序列的最后面，然后继续遍历剩余的元素。
代码实现:```def bubble_sort(lst):n = len(lst)for i in range(n - 1):for j in range(n - i - 1):if lst[j] > lst[j + 1]:lst[j], lst[j + 1] = lst[j + 1], lst[j]return lst```二、选择排序选择排序是一种简单直观的排序算法，它的主要思想是在未排序的序列中选择最小（或最大）的元素，将它与序列的第一个元素交换位置，然后在剩余的序列中继续做同样的操作，直到整个序列排序完成。
三、插入排序插入排序是一种简单但效率较低的排序算法，它的思路是遍历待排序序列，将每个元素插入到已排序的序列中的正确位置上。
插入排序分为直接插入排序和希尔排序两种。
1. 直接插入排序2. 希尔排序希尔排序是直接插入排序的升级版，它利用了“增量序列”的概念，可以将待排序序列拆分为若干个子序列进行排序，逐步缩小增量序列的范围，最终完成整个序列的排序。
四、快速排序快速排序是一种高效的排序算法，它的主要思想是通过分治技术将待排序序列拆分为两个子序列，然后对子序列分别进行排序，最终合并成一个有序序列。
快速排序的优点是实现简单且在大多数情况下都能在O(nlogn)的时间复杂度内完成排序。
五、堆排序堆排序是一种基于堆数据结构的排序算法，它的主要思想是将待排序序列构建成一个二叉堆，然后利用堆的性质将堆顶元素与末尾元素交换位置，然后将未排序部分重新构建成一个堆，重复以上操作，直到整个序列排序完成。
```def heap_sort(lst):def sift_down(start, end, nums):root = startwhile True:child = 2 * root + 1if child > end:breakif child + 1 <= end and nums[child] < nums[child + 1]:child += 1if nums[root] < nums[child]:nums[root], nums[child] = nums[child], nums[root]root = childelse:breakn = len(lst)for i in range(n // 2 - 1, -1, -1):sift_down(i, n - 1, lst)for i in range(n - 1, 0, -1):lst[0], lst[i] = lst[i], lst[0]sift_down(0, i - 1, lst)return lst```六、归并排序七、计数排序计数排序是一种非比较排序算法，它的主要思想是统计待排序序列中每个元素出现的次数，然后根据元素的大小和出现次数进行排序。
Python练习题005：三个数字由大到小排序输出
Python练习题005：三个数字由⼤到⼩排序输出【Python练习题 005】输⼊三个整数x,y,z，请把这三个数由⼩到⼤输出。
-----------------------------------------------------------------------这题想想应该⽐较容易：⽆⾮是先获取3个数字，然后⽐⼤⼩，按顺序输出即可。
不过在写代码的过程中遇到了个难题：因为担⼼输⼊时输⼊⾮指定的分隔符，需要指定多个分隔符（英⽂逗号、中⽂逗号、空格），但。
上⽹搜索了下，发现可以，于是就有了这⼀⾏了。
代码如下：import rex, y, z = re.split(',| |，| ', input('请输⼊3个数字，⽤逗号或空格隔开：'))x, y, z = int(x), int(y), int(z)maxNo = max(x, y, z)minNo = min(x, y, z)print(maxNo, x+y+z-maxNo-minNo, minNo)早就知道正则表达式很强⼤，但因为太难了，⼀直没敢碰啊…… ⽇后⼀定得好好研究下这部分内容！【2016-10-14 更新】------------------------------------------------------------坐地铁，⼿机⾥读了篇⽂章，看到了 str.sort() 这个⽅法，觉得可以⽤来解这题。
思路是：⽤ re.split() 得到 3 个字符型数字的列表，把字符转换为数字，排下序，然后 print() 不就都解决了吗？代码如下：import relst = re.split(',| |，| ', input('请输⼊3个数字，⽤逗号或空格隔开：'))for i in range(len(lst)):lst[i] = int(lst[i])lst.sort()print(lst)果然简单很多啊~~~++++++++++++++++++++++++++++++++++++++题⽬出处：。
python 排列组合的算法
主题：Python中常用的排列组合算法内容：1. 简介：Python是一种功能强大且易于学习的编程语言，其内置的库和模块使得许多复杂的算法变得易于实现。
在本文中，我们将讨论Python 中常用的排列组合算法，这些算法对于解决许多实际的问题都非常有用。
2. 排列算法：2.1 字符串的全排列：Python中可以使用`itertools`库中的`permutations`函数来获取一个字符串的所有排列。
2.2 数组的全排列：利用递归和交换元素的方式可以实现数组的全排列算法，该算法可以用来解决诸如旅行商问题等实际问题。
3. 组合算法：3.1 组合的生成：使用`itertools`库中的binations`函数可以获取一个序列的所有组合。
3.2 组合的求解：通过递归和回溯的方式可以实现组合的求解，这种方法在解决组合优化问题时非常有用。
4. 应用实例：4.1 排列和组合在密码学中的应用：排列和组合算法可以用来生成各种密码的可能组合，这对于破解密码以及设计安全的密码系统都非常重要。
4.2 排列和组合在商品排列组合的应用：在电商领域，排列和组合算法可以用来对商品进行排序和组合，以实现更好的推荐系统。
5. 总结：Python中的排列组合算法在解决实际问题中具有重要的作用，通过充分利用Python的内置库和函数，我们可以快速高效地实现各种排列组合算法。
这些算法不仅可以用来解决计算问题，还可以应用于密码学、商业推荐等实际场景中。
通过以上内容，我们可以了解Python中常用的排列组合算法以及它们在实际应用中的重要性，相信这些知识对于读者来说将是非常有价值的。
6. 代码示例：6.1 字符串的全排列示例：```pythonimport itertoolss = "abc"perm = itertools.permutations(s)for p in perm:print(''.join(p))```6.2 数组的全排列示例：```pythondef permute(nums):def backtrack(start):if start == len(nums):result.append(nums[:])returnfor i in range(start, len(nums)):nums[i], nums[start] = nums[start], nums[i] backtrack(start + 1)nums[i], nums[start] = nums[start], nums[i]result = []backtrack(0)return resultnums = [1, 2, 3]print(permute(nums))```6.3 组合的生成示例：```pythonimport itertoolss = "abcd"b = itertoolsbinations(s, 2)for c inb:print(''.join(c))```6.4 组合的求解示例：```pythondefbine(n, k):def backtrack(start, path): if len(path) == k:result.append(path[:]) returnfor i in range(start, n + 1): path.append(i)backtrack(i + 1, path) path.pop()result = []backtrack(1, [])return resultn = 4k = 2printbine(n, k))```7. 进阶应用：7.1 排列组合在数据挖掘中的应用：在数据挖掘领域，排列组合算法常常用于特征选择和模式发现，通过对特征的各种排列组合进行分析可以发现隐藏在数据中的规律和趋势。
python字符串数字排序规则
python字符串数字排序规则Python是一种功能强大的编程语言，它提供了许多方便的方法来处理字符串和数字。
在Python中，字符串和数字的排序规则是不同的。
本文将介绍Python中字符串和数字的排序规则，并提供一些示例代码来说明这些规则。
首先，让我们来看看Python中字符串的排序规则。
在Python中，字符串的排序是基于字符的ASCII码值进行的。
ASCII码是一种用于表示字符的标准编码系统，它为每个字符分配了一个唯一的整数值。
在ASCII码中，数字字符的值小于字母字符的值，而大写字母的值小于小写字母的值。
因此，在对字符串进行排序时，Python会按照字符的ASCII码值从小到大的顺序进行排序。
下面是一个示例代码，演示了如何使用Python对字符串进行排序：```pythonstrings = ['apple', 'banana', 'cherry', 'date']strings.sort()print(strings)```运行上述代码，输出结果为：['apple', 'banana', 'cherry', 'date']。
可以看到，字符串按照字母的ASCII码值从小到大的顺序进行了排序。
接下来，让我们来看看Python中数字的排序规则。
在Python中，数字的排序是基于数字的大小进行的。
Python会将数字从小到大进行排序，无论是整数还是浮点数。
下面是一个示例代码，演示了如何使用Python对数字进行排序：```pythonnumbers = [3, 1, 4, 1, 5, 9, 2, 6, 5]numbers.sort()print(numbers)```运行上述代码，输出结果为：[1, 1, 2, 3, 4, 5, 5, 6, 9]。
可以看到，数字按照从小到大的顺序进行了排序。
python sort排序规则
python sort排序规则Python是一种高级编程语言，提供了各种排序算法来满足不同的需求。
常见的排序算法包括冒泡排序、插入排序、选择排序、快速排序、归并排序等等。
在Python中，排序算法可以通过内置的sort()函数来实现。
sort()函数可以按升序或降序排序，而且还可以自定义排序规则。
默认情况下，sort()函数会将元素按数字或字母的顺序进行排序，但是它也允许使用关键字参数来指定自定义的排序函数。
下面是关于Python sort排序规则的详细解释：第一步：排序函数在Python中，sort()函数是一个用于列表和元组排序的内置函数。
我们可以使用该函数按照我们的需要对列表和元组进行排序。
该函数不会返回一个新的排序后的列表/元组，而是会直接修改原有的列表/元组。
排序函数有两个关键字参数：reverse和key。
reverse参数是一个布尔值，用于指定排序顺序是升序还是降序。
默认情况下，它是False，表示升序排序。
key参数接受一个函数，用于指定排序规则。
第二步：升序/降序排序在Python中，我们可以使用reverse参数来指定排序顺序。
如果将reverse参数设置为True，则会按降序进行排序，否则会按升序进行排序。
例如：# 将列表按升序排序list = [3, 2, 5, 1, 4]list.sort()print(list)# 将列表按降序排序list = [3, 2, 5, 1, 4]list.sort(reverse=True)print(list)上面的代码示例中，第一个sort()函数使用默认参数进行升序排序，而第二个sort()函数使用reverse=True参数进行降序排序。
第三步：自定义排序规则在Python中，我们可以使用key参数来指定自定义排序规则。
该参数允许我们传递一个函数作为其值，该函数将对列表中的每个元素进行操作，并返回用于排序的关键值。
例如：# 使用自定义函数按单词长度对列表进行排序list = ["apple", "banana", "cherry", "orange", "kiwi", "melon"]def myFunc(e):return len(e)list.sort(key=myFunc)print(list)在上面的代码示例中，我们定义了一个函数myFunc，该函数接受一个字符串参数，并返回该字符串的长度。
python中copy的用法
python中copy的用法在Python中，`copy(`是一种用于复制对象的方法。
它可以用于各种数据结构，如列表、字典、集合等。
使用`copy(`方法能够创建一个原始对象的副本，并且可以进行独立的操作，而不会影响原始对象。
下面是有关`copy(`方法的详细介绍。
1.复制列表：```python# 使用copy(方法复制列表original_list = [1, 2, 3, 4, 5]copied_list = original_list.copyprint(copied_list) # [1, 2, 3, 4, 5]#修改副本不会影响原始列表copied_list.append(6)print(copied_list) # [1, 2, 3, 4, 5, 6]print(original_list) # [1, 2, 3, 4, 5]```2.复制字典：```python# 使用copy(方法复制字典original_dict = {"name": "John", "age": 30, "city": "New York"}copied_dict = original_dict.copyprint(copied_dict) # {"name": "John", "age": 30, "city": "New York"}#修改副本不会影响原始字典copied_dict["age"] = 31print(copied_dict) # {"name": "John", "age": 31, "city": "New York"}print(original_dict) # {"name": "John", "age": 30, "city": "New York"}```3.复制集合：```python# 使用copy(方法复制集合original_set = {1, 2, 3, 4, 5}copied_set = original_set.copyprint(copied_set) # {1, 2, 3, 4, 5}#修改副本不会影响原始集合copied_set.add(6)print(copied_set) # {1, 2, 3, 4, 5, 6}print(original_set) # {1, 2, 3, 4, 5}```4.复制嵌套对象：```python# 使用copy(方法复制嵌套对象original_nested_list = [[1, 2], [3, 4], [5, 6]]copied_nested_list = original_nested_list.copyprint(copied_nested_list) # [[1, 2], [3, 4], [5, 6]]#修改副本不会影响原始对象copied_nested_list[0][0] = "a"print(copied_nested_list) # [["a", 2], [3, 4], [5, 6]]print(original_nested_list) # [["a", 2], [3, 4], [5, 6]]```需要注意的是，使用`copy(`方法进行的复制是浅复制（shallow copy），即只复制对象本身而不包括其嵌套对象。
python经典大小排序方法
python经典大小排序方法好的，以下是一篇符合您要求的文档：一、概述在Python中，排序是一种常见的操作，可以对列表、元组、字典等数据结构进行排序。
大小排序方法是指根据数据的自然顺序或自定义规则对数据进行排序的方法。
Python提供了多种大小排序方法，下面将介绍一些常见的排序方法。
二、常见大小排序方法1. sorted() 函数sorted() 函数可以对列表进行排序，返回一个新的排序后的列表。
它支持升序和降序两种排序方式，可以通过参数 reverse 参数指定。
示例：```pythonnumbers = [5, 2, 9, 1, 5, 6]sorted_numbers = sorted(numbers) # 升序排序sorted_numbers = sorted(numbers, reverse=True) # 降序排序```2. sorted() 方法在列表对象上使用 sorted() 方法可以直接对原列表进行排序，不需要返回新的列表。
同样支持升序和降序两种排序方式。
示例：```pythonnumbers = [5, 2, 9, 1, 5, 6]numbers_sorted = sorted(numbers) # 对原列表进行排序```3. 使用 cmp 参数进行比较在Python 2中，可以使用 cmp 参数对数据进行大小比较。
cmp 参数应该是一个函数，该函数接受两个参数并返回一个值。
如果第一个参数小于第二个参数，则返回 -1；如果两个参数相等，则返回 0；如果第一个参数大于第二个参数，则返回 1。
使用 cmp 参数可以对自定义类型的数据进行排序。
示例：```pythondata = [3, 1, 4, 1, 5, 9, 2]data.sort(cmp=lambda x, y: x - y) # 对整数列表进行升序排序```4. 使用 key 参数进行排序key 参数可以接受一个函数作为参数，该函数返回一个值来对数据进行排序。
python的copy方法
python的copy方法Python的copy方法是Python中常用的一种数据复制方法。
它可以复制一个对象，生成一个与原对象具有相同值的新对象。
copy方法可以应用于多种数据类型，如列表、字典和集合等。
本文将介绍copy方法的用法和注意事项，并通过示例代码来演示其具体操作。
一、copy方法的基本用法copy方法是Python内置的方法，可以直接应用于可复制的数据类型。
其基本用法为：new_object = old_object.copy()其中，old_object为原对象，new_object为复制生成的新对象。
通过这个方法，可以在不改变原对象的情况下，生成一个与原对象具有相同值的新对象。
二、copy方法的适用对象copy方法适用于多种数据类型，如列表、字典和集合等。
下面分别介绍它们的具体应用。
1. 列表的复制列表是Python中常用的数据结构，copy方法可以用来复制一个列表。
示例代码如下：```pythonold_list = [1, 2, 3]new_list = old_list.copy()print(new_list) # 输出：[1, 2, 3]```2. 字典的复制字典是一种可变的数据类型，copy方法可以用来复制一个字典。
示例代码如下：```pythonold_dict = {'name': 'Tom', 'age': 18}new_dict = old_dict.copy()print(new_dict) # 输出：{'name': 'Tom', 'age': 18}```3. 集合的复制集合是一种无序、不重复的数据结构，copy方法可以用来复制一个集合。
示例代码如下：```pythonold_set = {1, 2, 3}new_set = old_set.copy()print(new_set) # 输出：{1, 2, 3}```三、copy方法的注意事项在使用copy方法时，需要注意以下几点：1. 对于不可变的数据类型（如数字、字符串和元组），copy方法会返回原对象本身，而不是复制生成的新对象。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
本节重点是介绍几种常见的排序算法，重点掌握代码的实现。
排序思想可以查看百度文库资料5. 排序算法排序算法最能体现一个程序员的算法功底，也是面试时经常被拿来考察候选者的题目，本节一共讲解8种排序算法。
5.1 冒泡排序核心思想：类似车轮战，噗噗。
即相邻的两个数据进行比较，假设数列A有n个数据。
先比较第1个和第2个数据，如果A1 > A2,则交换他们的位置，确保较大的那个数在右侧。
接下来比较A2和A3，采用相同的规则，较大的数向右移动，最后会比较An1和An的大小，如果An1 > An，那么交换他们的位置，这时，An是数列中的最大值。
接下来要做的事情，就是简单的重复之前的过程，整个数列，先暂时把An排除在外，这n1个无序的数，仍然可以采用之前的方法，找出n1个数当中的最大值，这样An1就是第2大的数，继续对n2个数做相同的事情。
为了更容易理解冒泡排序，我们一起来实现一个这个函数吧In [20]:def bubble_sort(lst, start = 0, end = 1):if not lst:return Noneend = end if end > 0 else len(lst)1while end > 0:for i in range(start, end):if lst[i] > lst[i+1]:lst[i], lst[i+1] = lst[i+1], lst[i]end = 1#print(lst)return lstif __name__ == "__main__":lst = [3,2,1,9,7,8,9,8,4]print(bubble_sort(lst, 2))print(bubble_sort(lst))[3, 2, 1, 4, 7, 8, 8, 9, 9][1, 2, 3, 4, 7, 8, 8, 9, 9]5.2 快速排序三个核心步骤从待排序数组中随意选中一个数值，作为基准值移动待排序数组中的元素，是的基准值左侧的数值都小于等于它，右侧的数值大于等于它基准值将原来的数组分为两部分，针对这两部分，重复上述步骤(递归思想)基于上述的分析可知：首先需要分A B区，然后分别针对该A B部分进行重复的操作，过程中就是一个递归的过程。
In [50]:def my_partition(lst, start, end):if not lst:return None# end = end if end >=0 else len(lst)1tmp = lst[start]while start < end:while start < end and lst[end] >= tmp:end = 1lst[start] = lst[end]while start < end and lst[start] <= tmp:start += 1lst[end] = lst[start]if start == end:lst[start] = tmpprint(lst, start)return startdef my_sort_quick(lst, start, end):if not lst:return None# end = end if end >=0 else len(lst)1if start >= end:return Noneindex = my_partition(lst, start, end)my_sort_quick(lst, start, index1)my_sort_quick(lst, index+1, end)if __name__ == "__main__":lst = [3,2,1,9,7,8,9,8,4]#print(my_partition(lst, 2))my_sort_quick(lst, 0, len(lst)1)print("分割线".center(50, ""))print(lst)[1, 2, 3, 9, 7, 8, 9, 8, 4] 2[1, 2, 3, 9, 7, 8, 9, 8, 4] 0[1, 2, 3, 4, 7, 8, 9, 8, 9] 8[1, 2, 3, 4, 7, 8, 9, 8, 9] 3[1, 2, 3, 4, 7, 8, 9, 8, 9] 4[1, 2, 3, 4, 7, 8, 9, 8, 9] 5[1, 2, 3, 4, 7, 8, 8, 9, 9] 7分割线[1, 2, 3, 4, 7, 8, 8, 9, 9]5.3 选择排序从第一个位置开始， 这个位置与它后面所有的位置的值进行比较，如果不满足要求，就调换位置实现这个函数，达到选择排序的目的In [55]:def my_selection_sort(lst, start, end):for i in range(end+1):for j in range(i+1, end+1):if lst[i] >= lst[j]:lst[i],lst[j] = lst[j], lst[i]if __name__ == "__main__":lst = [3,2,1,9,7,8,9,8,4]my_selection_sort(lst, 0, len(lst)1)print("分割线".center(50, ""))print(lst)分割线[1, 2, 3, 4, 7, 8, 8, 9, 9]5.4 希尔排序希尔排序(Shell's Sort)是插入排序的一种又称“缩小增量排序”（DiminishingIncrement Sort），是直接插入排序算法的一种更高效的改进版本。
希尔排序是非稳定排序算法。
希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。
实现这个函数，达到选择排序的目的In [57]:lst = [49,38,65,97,76,13,27,49,55,4]count = len(lst)step = count // 2while step > 0:for i in range(step):for j in range(step+i, count, step):if lst[jstep] > lst[j]:tmp = lst[j]k = j stepwhile k >= 0 and lst[k] > tmp:lst[k+step] = lst[k]k = steplst[k+step] = tmpstep //= 2lstOut[57]:[4, 13, 27, 38, 49, 49, 55, 65, 76, 97]5.5 直接插入排序每步将一个待排序的记录，按其关键码值的大小插入前面已经排序的文件中适当位置上，直到全部插入完为止。
实现这个函数，达到选择排序的目的In [62]:lst = [49,38,65,97,76,13,27,49,55,4]for i in range(len(lst)1):if lst[i] > lst[i+1]:tmp = lst[i+1]while i >= 0 and lst[i] > tmp:lst[i+1] = lst[i]i = 1lst[i+1] = tmpprint(lst)[4, 13, 27, 38, 49, 49, 55, 65, 76, 97]In [58]:lst = [49,38,65,97,76,13,27,49,55,4]for i in range(len(lst)1):if lst[i] > lst[i+1]:tmp = lst[i+1]k = iwhile k>=0 and lst[k] > tmp:lst[k+1] = lst[k]k = 1lst[k+1] = tmpprint(lst)[4, 13, 27, 38, 49, 49, 55, 65, 76, 97]5.6 归并排序（合并两个有序集合）合并的方法就是分别从两个序列中拿出一个数来进行比较，小的那一个放到新序列中，然后，从这个小的数所属的序列中拿出一个数来继续比较简单思想例如：有两个有序的序列，分别为 [1,4,7] ,[2,3,5],现在请考虑将这两个序列合并成一个有序的序列。
首先创建一个新的序列，分别从两个序列中取出第一个数，1和2，1比2小，把1放到新的序列中第一个序列中的1已经放到新序列中，那么拿出4来进行比较，2比4小，把2放到新的序列中第二个序列中的2已经放到新序列中，那么拿出3来进行比较，3比4小，把3放到新的序列中第二个序列中的3已经放到新序列中，那么拿出5来进行比较，4比5小，把4放到新的序列中第一个序列中的4已经放到新序列中，那么拿出7来进行比较，5比7小，把5放到新的序列中最后把7放入到新的序列中In [78]:def merge_lst(lst1, lst2):if not lst1 or not lst2:return Nonelst = []lst1_index = 0lst2_index = 0while lst1_index <= len(lst1)1 and lst2_index <= len(lst2)1:if lst1[lst1_index] > lst2[lst2_index]:lst.append(lst2[lst2_index])lst2_index += 1else:lst.append(lst1[lst1_index])lst1_index += 1if lst1_index == len(lst1):lst.extend(lst2[lst2_index:])else:lst.extend(lst1[lst1_index:])return lstif __name__ == "__main__":lst1 = [1,4,8,11]lst2 = [2,3,5,8,12]print(merge_lst(lst1, lst2))[1, 2, 3, 4, 5, 8, 8, 11, 12]5.7 归并排序（合并无序集合）利用了合并有序序列的思想，把一个序列分成A,B两个序列，如果A, B有序，则简单； 如果无序，则继续分组，直到分出来的序列里只有一个元素的时候，一个元素，就是一个有序的序列啊，这个时候就可以合并了实现这个函数，达到归并排序的目的In [81]:def merge_lst(lst1, lst2):if not lst1 or not lst2:return Nonelst = []lst1_index = 0lst2_index = 0while lst1_index <= len(lst1)1 and lst2_index <= len(lst2)1:if lst1[lst1_index] > lst2[lst2_index]:lst.append(lst2[lst2_index])lst2_index += 1else:lst.append(lst1[lst1_index])lst1_index += 1if lst1_index == len(lst1):lst.extend(lst2[lst2_index:])else:lst.extend(lst1[lst1_index:])#print(lst)return lstdef merge_sort(lst1):if len(lst1) <= 1:return lst1middle = len(lst1)//2lst2 = merge_sort(lst1[:middle])lst3 = merge_sort(lst1[middle:])return merge_lst(lst2, lst3)if __name__ == "__main__":lst = [49,38,65,97,76,13,27,49,55,4]print(merge_sort(lst))[4, 13, 27, 38, 49, 49, 55, 65, 76, 97]5.8 选择排序每一次，都从序列中找出一个最小值，然后把它与序列的第一个元素交换位置，这样下去，待排序的元素就会越来越少，直到最后一个假设有一个序列，a[0],a[1],a[2]...a[n]现在，对它进行排序。