更大规模的其他排序有什么,能举个代码例子吗
时间: 2024-03-02 11:52:02 浏览: 15
常见的其他排序算法包括快速排序、归并排序和堆排序。这里分别给出它们的 Python 代码实现。
1. 快速排序
快速排序是一种基于分治思想的排序算法,它的时间复杂度为 O(nlogn)。它的核心思想是选取一个基准值,将数组中小于基准值的元素放在基准值的左边,大于基准值的元素放在基准值的右边,然后对左右两个子数组分别进行快速排序。
以下是 Python 快速排序的代码示例:
```python
def quick_sort(arr):
if len(arr) <= 1:
return arr
pivot = arr[len(arr)//2]
left = [x for x in arr if x < pivot]
middle = [x for x in arr if x == pivot]
right = [x for x in arr if x > pivot]
return quick_sort(left) + middle + quick_sort(right)
# 测试
import random
arr = [random.randint(1, 1000) for _ in range(10000)]
arr = quick_sort(arr)
print("排序后的数组为:")
for i in range(len(arr)):
print(arr[i])
```
2. 归并排序
归并排序也是一种基于分治思想的排序算法,它的时间复杂度为 O(nlogn)。它的核心思想是将数组分成两个子数组,分别进行归并排序,然后将两个有序的子数组归并成一个有序的数组。
以下是 Python 归并排序的代码示例:
```python
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr) // 2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
return merge(left, right)
def merge(left, right):
res = []
i = j = 0
while i < len(left) and j < len(right):
if left[i] <= right[j]:
res.append(left[i])
i += 1
else:
res.append(right[j])
j += 1
res += left[i:]
res += right[j:]
return res
# 测试
import random
arr = [random.randint(1, 1000) for _ in range(10000)]
arr = merge_sort(arr)
print("排序后的数组为:")
for i in range(len(arr)):
print(arr[i])
```
3. 堆排序
堆排序是一种利用堆的数据结构来实现的排序算法,它的时间复杂度为 O(nlogn)。它的核心思想是将数组看作一颗完全二叉树,通过构建一个大根堆或小根堆来实现排序。
以下是 Python 堆排序的代码示例:
```python
def heap_sort(arr):
n = len(arr)
for i in range(n//2-1, -1, -1):
heapify(arr, n, i)
for i in range(n-1, 0, -1):
arr[0], arr[i] = arr[i], arr[0]
heapify(arr, i, 0)
def heapify(arr, n, i):
largest = i
left = 2*i+1
right = 2*i+2
if left < n and arr[left] > arr[largest]:
largest = left
if right < n and arr[right] > arr[largest]:
largest = right
if largest != i:
arr[i], arr[largest] = arr[largest], arr[i]
heapify(arr, n, largest)
# 测试
import random
arr = [random.randint(1, 1000) for _ in range(10000)]
heap_sort(arr)
print("排序后的数组为:")
for i in range(len(arr)):
print(arr[i])
```
以上是三种常见的排序算法的 Python 代码实现,它们都比冒泡排序更适合大规模数据的排序。