python排序算法
- 掌握python中主要的排序算法
一、排序算法概述
排序算法是计算机科学中最基本、也是最常用的问题之一。在实际应用中，需要对大量数据进行排序，以便更好地进行汇总、查询等操作。而排序算法则可以将数据按照某种规则进行排列，使得查询、计算等操作更加方便快捷。
排序算法是将一组无序的元素按照特定的顺序重新排列的算法。在排序过程中，需要根据一定的规则来比较元素大小，然后进行交换或移动，从而达到排列的目的。常见的排序算法有插入排序、冒泡排序、选择排序、希尔排序、归并排序、快速排序等。不同的排序算法具有不同的优缺点，我们需要根据具体的需求选择不同的算法。
二、插入排序
插入排序是一种简单直观的排序算法，其基本思想是将一个记录插入到已有的有序表中，从而得到新的有序表。具体实现时，我们可以将未排序的元素逐个插入到已排好序的部分中，从而使元素逐步有序。插入排序算法的时间复杂度为O(n^2)，空间复杂度为O(1)。
代码实现：
def insertion_sort(arr):
for i in range(len(arr)):
j = i
while j > 0 and arr[j] < arr[j-1]:
arr[j], arr[j-1] = arr[j-1], arr[j]
j -= 1
return arr
arr=[100,4,0,10,90,30,10,5,34,4,5,2,14,14,115,53,15]
insertion_sort(arr)
print(arr)
#运行结果
# [0, 2, 4, 4, 5, 5, 10, 10, 14, 14, 15, 30, 34, 53, 90, 100, 115]
三、冒泡排序
冒泡排序也是一种简单的排序算法，其基本思想是通过相邻两个元素的比较和交换来实现排序。具体实现时，我们重复地遍历待排序序列，每次比较相邻两个元素的大小，若它们的顺序不对则进行交换，直到序列中所有元素都排好序。冒泡排序算法的时间复杂度为O(n^2)，空间复杂度为O(1)。
代码实现：
def bubble_sort(arr):
n = len(arr)
for i in range(n - 1):
for j in range(n - i - 1):
if arr[j] > arr[j + 1]:
arr[j], arr[j + 1] = arr[j + 1], arr[j]
return arr
arr=[100,4,0,10,90,30,10,5,34,4,5,2,14,14,115,53,15]
bubble_sort(arr)
print(arr)
#运行结果
# [0, 2, 4, 4, 5, 5, 10, 10, 14, 14, 15, 30, 34, 53, 90, 100, 115]
四、选择排序
选择排序是一种简单直观的排序算法，其基本思想是每次从待排序序列中选择最小（或最大）的元素，并将其放到已排序序列的末尾。具体实现时，我们重复地从未排序的部分中选择最小的元素，然后与已排序的末尾元素进行交换，直到整个序列都排好序。选择排序算法的时间复杂度为O(n^2)，空间复杂度为O(1)。
代码实现：
def selection_sort(arr):
n = len(arr)
for i in range(n - 1):
min_index = i
for j in range(i + 1, n):
if arr[j] < arr[min_index]:
min_index = j
arr[i], arr[min_index] = arr[min_index], arr[i]
return arr
arr=[100,4,0,10,90,30,10,5,34,4,5,2,14,14,115,53,15]
selection_sort(arr)
print(arr)
#运行结果
# [0, 2, 4, 4, 5, 5, 10, 10, 14, 14, 15, 30, 34, 53, 90, 100, 115]
五、希尔排序
希尔排序也是一种简单有效的排序算法，其基本思想是通过将序列分成若干个子序列来实现排序。具体实现时，我们先将序列分成若干个子序列，对每个子序列进行插入排序，使得子序列内部基本有序，然后逐步缩小子序列的范围，直到整个序列有序。希尔排序算法的时间复杂度为O(nlogn)，空间复杂度为O(1)。
代码实现：
def shell_sort(arr):
n = len(arr)
gap = n // 2
while gap > 0:
for i in range(gap, n):
j = i
while j >= gap and arr[j] < arr[j - gap]:
arr[j], arr[j - gap] = arr[j - gap], arr[j]
j -= gap
gap //= 2
return arr
arr=[100,4,0,10,90,30,10,5,34,4,5,2,14,14,115,53,15]
shell_sort(arr)
print(arr)
#运行结果
# [0, 2, 4, 4, 5, 5, 10, 10, 14, 14, 15, 30, 34, 53, 90, 100, 115]
六、归并排序
归并排序是一种高效的排序算法，其基本思想是将两个有序的子序列合并成一个更大的有序序列。具体实现时，我们先递归地将待排序序列划分成若干个子序列，然后再合并这些子序列，直到整个序列都排好序。归并排序算法的时间复杂度为O(nlogn)，空间复杂度为O(n)。
代码实现：
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr) // 2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
result = []
i, j = 0, 0
while i < len(left) and j < len(right):
if left[i] <= right[j]:
result.append(left[i])
i += 1
else:
result.append(right[j])
j += 1
result += left[i:]
result += right[j:]
return result
arr=[100,4,0,10,90,30,10,5,34,4,5,2,14,14,115,53,15]
merge_sort(arr)
print(arr)
#运行结果
# [0, 2, 4, 4, 5, 5, 10, 10, 14, 14, 15, 30, 34, 53, 90, 100, 115]
七、快速排序
快速排序是一种高效的排序算法，其基本思想是通过分治法来实现排序。具体实现时，我们首先选择一个元素作为“轴心”，然后将待排序序列分成两个部分，使得左边部分的元素都小于轴心，右边部分的元素都大于轴心，接着递归地对左右两部分进行排序即可。快速排序算法的时间复杂度为O(nlogn)，空间复杂度为O(n)。
代码实现：
python
def quick_sort(arr, left, right):
if left >= right:
return arr
pivot = arr[left]
i, j = left, right
while i < j:
while i < j and arr[j] >= pivot:
j -= 1
arr[i] = arr[j]
while i < j and arr[i] < pivot:
i += 1
arr[j] = arr[i]
arr[i] = pivot
quick_sort(arr, left, i - 1)
quick_sort(arr, i + 1, right)
return arr
arr=[100,4,0,10,90,30,10,5,34,4,5,2,14,14,115,53,15]
quick_sort(arr)
print(arr)
#运行结果
# [0, 2, 4, 4, 5, 5, 10, 10, 14, 14, 15, 30, 34, 53, 90, 100, 115]
九、算法比较
在实际应用中，不同的排序算法具有不同的优缺点，我们需要根据具体的需求选择合适的算法。下面，我们比较一下以上几种排序算法的时间复杂度和空间复杂度。
排序算法 平均时间复杂度 最坏时间复杂度 空间复杂度
插入排序 O(n^2) O(n^2) O(1)
冒泡排序 O(n^2) O(n^2) O(1)
选择排序 O(n^2) O(n^2) O(1)
希尔排序 O(nlogn) O(n^2) O(1)
归并排序 O(nlogn) O(nlogn) O(n)
快速排序 O(nlogn) O(n^2) O(n)
由上表可知，不同的排序算法具有不同的时间复杂度和空间复杂度。在实际应用中，我们需要选择合适的算法来进行排序操作，以达到更好的效果。