排序算法 ||蟒蛇 ||数据结构和算法-Python教程-PHP中文网

Sorting Algorithms || Python || Data Structures and Algorithms

排序算法

1. 冒泡排序

在此，我们将较高的元素与其相邻的元素交换，直到到达数组的末尾。现在最高的元素位于最后一个位置。因此，我们更改边界并将其比上一个减少 1。最坏的情况下，我们必须迭代 n 次才能对数组进行排序。

def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        swapped = False

        # Last i elements are already in place, so we don't need to check them
        for j in range(0, n-i-1):
            # Swap if the element found is greater than the next element
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]  # Swap the elements
                swapped = True
        if not swapped:
            break

    return arr

登录后复制

算法 -

迭代数组并找到最大元素，然后将其交换到最后一个。
比较所有相邻元素，如果较大的元素在较小的元素之前，则交换。继续这样做，直到到达数组的末尾。
维护一个标志：如果没有元素被交换，那么我们可以打破循环，因为数组已排序。

时间复杂度：

最佳情况 - 如果数组已经排序，则只需要一次迭代。时间复杂度 - O(n)
平均情况 - 如果数组是随机排序的，则时间复杂度 - O(n2)
最坏情况 - 如果数组按降序排列，那么我们将需要 n*2 次迭代。

空间复杂度 - O(1)，不需要额外的内存。

优点 -

无需额外内存。
稳定，因为元素保持其相对顺序。

缺点 -

时间复杂度 - O(n2)，对于大型数据集来说非常高。

应用-

仅当数据集非常小时才可以使用，并且由于时间复杂度较高，简单性胜过低效率。

2. 选择排序

在此，我们找到数组中最小的元素并将其替换为第一个元素。然后，我们将边界增加 1 并重复相同的步骤，直到到达数组的末尾。

def selectionSort(a):
    i = 0
    while i<len(a):

        smallest = min(a[i:])
        index_of_smallest = a.index(smallest)
        a[i],a[index_of_smallest] = a[index_of_smallest],a[i]

        i=i+1
    return a

登录后复制

算法 -

迭代数组并找到最小元素。
与第一个元素交换位置，指针加1。
重复此过程，直到到达数组末尾。

时间复杂度：在所有三种情况下其时间复杂度均为 O(n2)：最佳、平均和最差。这是因为我们必须选择最小元素并且每次都交换它，无论数组是否已经排序。

空间复杂度 - O(1)，不需要额外的内存。

优点 -

无需额外内存。
比冒泡排序进行的交换更少。

缺点 -

时间复杂度 - O(n2)，对于大型数据集来说非常高。
不稳定，因为它不保持相等元素的相对顺序。

应用程序 -

它可以在内存有限的系统中使用，因为它不需要额外的存储空间。
它用于最小化交换次数至关重要的系统，例如写入操作缓慢的系统。

3.插入排序

这是一种算法，通过从元素位置到数组开头迭代地向后检查，将未排序的元素插入到正确的位置。

def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        swapped = False

        # Last i elements are already in place, so we don't need to check them
        for j in range(0, n-i-1):
            # Swap if the element found is greater than the next element
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]  # Swap the elements
                swapped = True
        if not swapped:
            break

    return arr

登录后复制

算法 -

从数组的第二个元素开始，与第一个元素进行比较。如果当前元素小于第一个元素，则交换它们。
现在增加指针并对第三个元素执行此操作：将其与第二个和第一个元素进行比较。
对其余元素重复相同的过程，将它们与之前的所有元素进行比较，并将它们插入到合适的位置。

时间复杂度：

- 最佳情况 - 如果数组已经排序，则只需要一次迭代。时间复杂度为 O(n)
- 平均情况 - 如果数组是随机排序的，那么时间复杂度是 O(n2)
- 最坏情况 - 如果数组按降序排列，那么我们将需要 n2 次迭代。

空间复杂度 - O(1)，不需要额外的内存。

优点 -

不需要额外的内存。
稳定，因为元素保持其相对顺序。

缺点 -

时间复杂度 - O(n2)，对于大型数据集来说非常高。
不稳定，因为它不保持相等元素的相对顺序。

应用-

对于实时数据流等元素实时到达且需要排序的场景非常高效。

4. 归并排序

归并排序是一种遵循分而治之方法的算法。它有两个主要步骤：首先，递归地划分数组，其次，按排序顺序合并划分后的数组。

def selectionSort(a):
    i = 0
    while i<len(a):

        smallest = min(a[i:])
        index_of_smallest = a.index(smallest)
        a[i],a[index_of_smallest] = a[index_of_smallest],a[i]

        i=i+1
    return a

登录后复制

算法 -

通过计算中点将数组分成两半。
继续划分，直到每个子数组的长度为1。
在两半上调用合并函数：左半部分和右半部分。
使用三个指针进行合并过程：

左半数组的第一个指针。
右半数组的第二个指针。
已排序数组的第三个指针。

迭代两半并比较它们的元素。将较小的元素插入已排序的数组中，并将相应的指针加 1。
递归地重复此过程，直到整个数组排序完毕。

时间复杂度：归并排序在所有三种情况下的时间复杂度均为O(n log n)：最佳、平均和最差。这是因为，无论数组是否已经排序，每次划分和合并都会遵循相同的步骤。

O( log n ) - 在除法阶段的每一步，数组大小减半。

O(n) - 在合并过程中，我们必须迭代所有元素一次。

所以总时间复杂度为 O (n) * O(log n) = O (n log n)

空间复杂度 - O(n)，合并过程中需要额外的内存来存储临时数组。

优点 -

稳定，因为元素保持其相对顺序。
即使对于大型数据集，时间复杂度也是 O (n log n)。
适合并行处理，因为子数组是独立合并的。

缺点 -

时间复杂度 - O(n2)，对于大型数据集来说非常高。
合并过程需要额外的内存。
未到位，因为需要额外的内存。
对于大多数数据集来说通常比快速排序慢。

应用程序 -

用于数据太大而无法放入内存的情况，例如合并大文件。
它用于对链表进行排序，因为不需要随机访问。

5. 快速排序

快速排序是一种遵循分而治之方法的算法。我们选择一个主元元素，并将主元放在正确的排序位置后，围绕主元元素对数组进行分区。

第一步是选择主元元素，然后围绕主元对数组进行分区。所有小于主元的元素都将位于左侧，所有大于主元的元素将位于其右侧。然后枢轴位于正确的排序位置。递归地，通过将数组分为两半来应用相同的过程：前半部分包含主元之前的元素，后半部分包含主元之后的元素。重复这个过程，直到每个子数组的长度达到1。

def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        swapped = False

        # Last i elements are already in place, so we don't need to check them
        for j in range(0, n-i-1):
            # Swap if the element found is greater than the next element
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]  # Swap the elements
                swapped = True
        if not swapped:
            break

    return arr

登录后复制

算法 -

通过计算中点将数组分成两半。
选择一个枢轴；可以选择任何元素作为基准。
迭代数组并将每个元素与主元进行比较。
将所有小于主元的元素放置在左侧，将所有大于主元的元素放置在右侧。
将枢轴与左指针交换，使枢轴位于正确的排序位置。
递归地重复这个过程，直到分区的长度大于1。

时间复杂度：

1。最佳情况 - 时间复杂度 - O(n log n)，当主元将数组分成相等的两半时。
2.平均情况 - 时间复杂度 - O(n log n)，当主元将数组分成相等的两半时。但不一定相等。
3.最坏情况 - 时间复杂度 - O(n2) ，当 -

在已经排序的数组中选择最小的元素作为主元。
选择最大元素作为按降序排序的数组中的主元。

O( log n ) - 在除法阶段的每一步，数组大小减半。

O(n) - 在元素排序期间。

所以，总时间复杂度为 O(n) * O(log n) = O (n log n)

空间复杂度：

最佳和平均情况 - O(log n) - 用于递归堆栈。
最坏情况 - O(n) - 对于递归堆栈。

优点 -

对于大型数据集非常有效，除非枢轴选择不当。
它是缓存友好的，因为我们在同一个数组上进行排序，并且不将数据复制到任何辅助数组。
在不需要稳定性时，用于大数据的最快通用算法之一。

缺点 -

时间复杂度 - O(n2)，对于大型数据集来说非常高。
不稳定，因为它不能维持相等元素的相对顺序。

应用程序 -

它用于编程库和框架。例如-Python的sorted()函数和Java的Array.sort()基于快速排序。
它通过在查询执行期间有效地对行进行排序来使用 indDatabase 查询优化。
由于其缓存友好的特性，它非常适合大型数据集的内存排序。

6.堆排序

堆排序是一种基于比较的排序算法。它是选择排序的扩展。在堆排序中，我们创建一个二叉堆并将最大或最小元素与最后一个元素交换。然后，我们将堆大小减少 1。重复此过程，直到堆的长度大于 1。

def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        swapped = False

        # Last i elements are already in place, so we don't need to check them
        for j in range(0, n-i-1):
            # Swap if the element found is greater than the next element
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]  # Swap the elements
                swapped = True
        if not swapped:
            break

    return arr

登录后复制

算法 -

使用 heapify 进程构建最大堆。 Heapify 是一种用于维护二叉堆数据结构的堆属性的方法。
如果数组大小为 n，则包含 n//2 个父节点。
对于索引 i 处的父级：

a.它的左子节点位于索引 2i 1

b.它的右子节点位于索引 2i 2

迭代所有父级从索引 n//2 到 0 的子树，并对它们调用 heapify 函数。
现在，数组成为最大堆，最大元素位于索引 0。
将堆的第一个元素与最后一个元素交换，并将堆的大小减少 1。
重复这个过程，直到堆的长度大于1

时间复杂度：堆排序在所有三种情况下的时间复杂度均为 O(n log n)：最佳、平均和最差。这是因为，无论数组是否已经排序，每次创建最大堆和交换元素时都会遵循相同的步骤。

O( log n ) - 创建最大堆

O(n) - 创建最大堆并且交换元素 n 次。

所以总时间复杂度为 O(n) * O(log n) = O(n log n)

空间复杂度：对于所有情况 - O(log n) - 对于递归堆栈。

优点 -

即使对于大型数据集，时间复杂度也是 O (n log n)。
内存使用率几乎恒定。

缺点 -

不稳定，因为它不能维持相等元素的相对顺序。
与合并排序相比，需要很多交换。

应用程序 -

对于实现频繁提取最大或最小元素的优先级队列非常有用。
在需要就地排序且内存使用至关重要的系统中很有用。
用于需要排名的场景。

7.计数排序和基数排序

计数排序是一种非基于比较的排序算法。当输入值的范围与要排序的元素的数量相比较小时，它特别有效。计数排序背后的基本思想是计算输入数组中每个不同元素的频率，并使用该信息将元素放置在正确的排序位置。

基数排序使用计数排序作为子例程。它将计数排序应用于数字的每个数字位并重复排序，直到处理完数组中最大数字的所有数字。

def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        swapped = False

        # Last i elements are already in place, so we don't need to check them
        for j in range(0, n-i-1):
            # Swap if the element found is greater than the next element
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]  # Swap the elements
                swapped = True
        if not swapped:
            break

    return arr

登录后复制

def selectionSort(a):
    i = 0
    while i<len(a):

        smallest = min(a[i:])
        index_of_smallest = a.index(smallest)
        a[i],a[index_of_smallest] = a[index_of_smallest],a[i]

        i=i+1
    return a

登录后复制

算法 -