不同的排序方法 （Sorting algorithms)

不同的排序方法 （Sorting algorithms)

Python 入门基础-- Sorting方法

---

---

1 Bubble sort

1. 遍历所有数组元素;
2. 比较每个相邻元素;
3. 把大的放在右边。

---

# bubble sort
def bubbleSort(arr): 
    n = len(arr) 
  
    # 遍历所有数组元素
    for i in range(n-1): 
    # range(n)也可以工作，但外部循环将比需要的多重复一次。
        # Last i elements are already in place 
        # 最后i个元素已经在正确的位置了
        for j in range(0, n-i-1): 
  
            # 从0遍历数组到n-i-1
            # 如果前一个元素大于后一个元素
            # 则交换两个元素的位置
            if arr[j] > arr[j+1] : 
                arr[j], arr[j+1] = arr[j+1], arr[j] 
    return arr
# 测试用例
arr = [64, 34, 25, 12, 22, 90, 11 ]  
  
print(bubbleSort(arr))
# 结果 [11, 12, 22, 25, 34, 64, 90]

2 Selection sort

1. 遍历所有数组元素;
2. 将最小元素与每个未排序元素进行比较;
3. 记录最小值;
4. 把最小的元素放在正确的位置。

def selectSort(arr):
    n = len(arr)
    
    # 遍历所有数组元素 
    for i in range(n-1): 

        # 找到剩余未排序数组中的最小元素
        min_idx = i 
        for j in range(i+1, n): 
            if arr[min_idx] > arr[j]: 
                min_idx = j 

        # 交换 找到的最小元素 和 当前元素 的位置       
        arr[i], arr[min_idx] = arr[min_idx], arr[i] 
    return arr

arr = [64, 34, 25, 12, 22, 90, 11 ] 
  
print(selectSort(arr))
# 结果 [11, 12, 22, 25, 34, 64, 90]

3 Insert sort

1. 数组被划分为一个“已排序”子数组和一个“未排序”子数组。在开始时，已排序的子数组只包含原始数组的第一个元素。

2. 将未排序数组中的第一个元素求值，以便我们可以将其插入到已排序子数组中的正确位置。

3. 插入操作是将所有大于新元素的元素向右移动一个位置。

4. 继续这样做，直到整个数组都排好序。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wlxfkb(attachment:image.png)]

def insertSort(arr):
    n = len(arr)
    
    # 遍历所有数组元素
    for i in range(n):
        key = arr[i]
        # 比较当前元素与已排序的部分
        # 将当前元素插到正确的位置上
        j = i-1
        while j >= 0 and key < arr[j] : 
                arr[j + 1] = arr[j] 
                j -= 1
        arr[j + 1] = key 
    return arr

arr = [64, 34, 25, 12, 22, 90, 11 ] 
  
print(insertSort(arr))
# 结果 [11, 12, 22, 25, 34, 64, 90]

4 Merge sort

1. 一个初始数组被分成两个大致相等的部分。如果数组有奇数个元素，其中一个“一半”比另一个大一个元素。

2. 子数组被一遍又一遍地分成两半，直到最后得到每个数组只有一个元素。

3. 然后将单个元素数组组合成两个元素数组，并在过程中对它们进行排序。然后，这些排序对合并到四个元素的数组中，依此类推，直到初始数组排序完毕。

def insertSort(arr):
    n = len(arr)
    
    # 遍历所有数组元素
    for i in range(n):
        key = arr[i]
        # 比较当前元素与已排序的部分
        # 将当前元素插到正确的位置上
        j = i-1
        while j >= 0 and key < arr[j] : 
                arr[j + 1] = arr[j] 
                j -= 1
        arr[j + 1] = key 
    return arr

arr = [64, 34, 25, 12, 22, 90, 11 ] 
  
print(insertSort(arr))
# 结果 [11, 12, 22, 25, 34, 64, 90]

5 Quick sort

1. 通过取一个伪随机元素并将其用作主元，将集合分成两个(大致)相等的部分。

2. 比主元小的元素移到主元的左边，比主元大的元素移到主元的右边。

3. 对于主节点左侧的集合以及主节点右侧的元素数组，都会重复此过程，直到整个数组排序完毕。

def partition(arr, low, high): 
    i = (low-1)         # 较小元素的索引
    pivot = arr[high]     # 中心元素 
  
    for j in range(low, high): 
  
        # 如果当前元素小于等于中心元素
        if arr[j] <= pivot: 
  
            # 向右移
            i = i+1
            arr[i], arr[j] = arr[j], arr[i] 
  
    arr[i+1], arr[high] = arr[high], arr[i+1] 
    return (i+1) 
  
# 实现快速排序的主要函数
# arr[] --> 要sort的array, 
# low  --> 开始的索引, 
# high  --> 结束的索引 
  
# Function to do Quick sort 


def quickSort(arr, low, high): 
    if len(arr) == 1: 
        return arr 
    if low < high: 
  
        # pi是分区索引，arr[p]现在在正确的地方
        pi = partition(arr, low, high) 
  
        # 分别排序分区之前和分区之后的元素
        quickSort(arr, low, pi-1) 
        quickSort(arr, pi+1, high) 
    return arr    
# 测试用例
arr = [64, 34, 25, 12, 22, 90, 11 ]  
n = len(arr) 
print(quickSort(arr, 0, n-1))
# 结果 [11, 12, 22, 25, 34, 64, 90]

总结

这个链接 可以通过视觉直观的角度帮助大家更好的理解不同的sort算法是怎么工作的。强推观看！！！

不同排序方法的时间复杂度

Algorithm	Best	Average	Worst
Bubble Sort	O(n)	O(n^2)	O(n^2)
Select Sort	O(n^2)	O(n^2)	O(n^2)
Insertion Sort	O(n)	O(n^2)	O(n^2)
Mergesort	O(n log(n))	O(n log(n))	O(n log(n))
Quicksort	O(n log(n))	O(n log(n))	O(n^2)