Python算法学习[7]—内部排序算法&技术解惑

柔情只为你懂 2023-09-29 23:02 55阅读 0赞

#### 内部排序算法&技术解惑 ####

在计算机科学中，排序算法是一种将元素按照特定顺序进行排列的算法。排序算法可以用于许多不同的场景，例如数据库索引、数据压缩和数字信号处理等。本文将介绍四种常见的内部排序算法：冒泡排序、选择排序、插入排序和快速排序，并提供Python代码来实现这些算法。

冒泡排序  
冒泡排序是一种简单的排序算法，它通过对相邻的元素进行比较和交换操作来将最大的元素“冒泡”到数组的末尾。具体实现方法如下：

def bubble_sort(arr):
        n = len(arr)
        for i in range(n):
            for j in range(0, n-i-1):
                if arr[j] > arr[j+1]:
                    arr[j], arr[j+1] = arr[j+1], arr[j]

在上述代码中，我们使用两个嵌套循环来遍历整个数组并进行比较和交换操作。外层循环控制要排序的范围，而内层循环则执行实际的比较和交换操作。

选择排序  
选择排序是一种简单的排序算法，它通过选取最小的元素并将其放置在数组的开头来逐步构建有序序列。具体实现方法如下：

def selection_sort(arr):
        n = len(arr)
        for i in range(n):
            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]

在上述代码中，我们使用两个嵌套循环来遍历整个数组并找到最小的元素。外层循环控制要排序的范围，而内层循环则查找最小的元素并将其放置在正确的位置上。

插入排序  
插入排序是一种简单的排序算法，它将未排序的元素依次插入到已排序的部分中，从而逐步构建有序序列。具体实现方法如下：

def insertion_sort(arr):
        n = len(arr)
        for i in range(1, 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

在上述代码中，我们使用一个for循环来遍历整个数组，并使用一个while循环来将未排序的元素插入到已排序的部分中。外层循环控制要排序的范围，而内层循环则执行实际的插入操作。

快速排序  
快速排序是一种高效的排序算法，它使用分治策略将大的问题分割成小的子问题，并使用递归来解决这些子问题。具体实现方法如下：

def quick_sort(arr, low, high):
        if low < high:
            pivot_index = partition(arr, low, high)
            quick_sort(arr, low, pivot_index - 1)
            quick_sort(arr, pivot_index + 1, high)
    
    def partition(arr, low, high):
        pivot = arr[high]
        i = low - 1
        for j in range(low, high):
            if arr[j] <= pivot:
                i += 1
                arr[i], arr[j] = arr[j], arr[i]
        arr[i+1], arr[high] = arr[high], arr[i+1]
        return i+1

在上述代码中，我们使用快速排序算法将数组分为两个子数组。首先，我们定义了一个quick\_sort函数和一个partition函数。quick\_sort函数使用递归来将整个数组进行排序，而partition函数则用于确定分割点（pivot），并将数组划分为两个子数组。

具体来说，partition函数首先将pivot设置为待排序数组的最后一个元素，并将i初始化为low-1。接下来，使用一个for循环遍历数组中的每一个元素，并将小于等于pivot的元素与大于pivot的元素分别放置在左右两侧，并将i逐步向右移动。最后，将pivot放置在正确的位置上，并返回该位置的索引。

quick\_sort函数则首先判断是否需要对子数组进行排序。如果需要，就调用partition函数来找到分割点，并递归地对两个子数组进行相同的操作。

测试  
为了测试我们的排序算法，我们可以使用以下代码来生成一个随机数组：

import random
    
    arr = [random.randint(0, 100) for i in range(10)]
    print(arr)

然后，我们可以使用以下代码来测试不同的排序算法：

bubble_sort(arr)
    print(arr)
    
    selection_sort(arr)
    print(arr)
    
    insertion_sort(arr)
    print(arr)
    
    quick_sort(arr, 0, len(arr)-1)
    print(arr)

运行结果可能如下：

[35, 51, 70, 31, 66, 27, 98, 36, 87, 77]
    [27, 31, 35, 36, 51, 66, 70, 77, 87, 98]
    [27, 31, 35, 36, 51, 66, 70, 77, 87, 98]
    [27, 31, 35, 36, 51, 66, 70, 77, 87, 98]
    [27, 31, 35, 36, 51, 66, 70, 77, 87, 98]

从结果中，我们可以看到这些算法能够正确地对随机数组进行排序。

总结  
本文介绍了四种常见的内部排序算法：冒泡排序、选择排序、插入排序和快速排序，并提供Python代码来实现这些算法。这些算法在不同的场景中有着广泛的应用，具有较高的效率和准确性。希望通过本文的介绍，您能够更好地理解和掌握这些排序算法的原理和实现方法。