Python中的排序算法

排序被定义为按一定顺序排列数据。排序技术用于按升序或降序排列数据（主要是数字）。它是一种用于以更易于理解的格式表示数据的方法。它是计算机科学的一个重要领域。如果我们用于对数据进行排序的方法效率低下，那么对大量数据进行排序可能会占用大量计算资源。该算法的效率与其遍历的项目数成正比。对于少量的数据，复杂的排序方法可能比它的价值更麻烦。另一方面，对于更大量的数据，我们希望尽可能提高效率和速度。我们现在将讨论几种排序技术并比较它们的时间复杂度。

一些现实生活中的排序示例是：

• 电话簿：这是一本按字母顺序包含人们的电话号码和地址的书。
• 字典：它是一个巨大的单词集合以及按字母顺序排列的含义。
• 联系人列表：是手机上按字母顺序排列的联系人号码列表。

在讨论用于对提供给我们的数据进行排序的不同算法之前，我们应该考虑可用于分析排序过程的操作。首先，我们需要比较值以查看哪个更小，哪个更大，以便可以将它们排序成一个顺序，有必要有一种有组织的方式来比较值以查看它们是否按顺序排列。

不同类型的订单是：

• 递增顺序：当每个连续元素大于其前一个元素时，一组值被称为递增顺序。例如：1、2、3、4、5。这里，给定的序列是按升序排列的。
• 递减顺序：当连续元素总是小于前一个元素时，一组值被称为递增顺序。例如：5、4、3、2、1。这里给定的序列是降序的。
• 非递增顺序：如果序列中存在的每个第 i^个元素都大于或等于其第 (i-1)^个元素，则称一组值处于非递增顺序。只要有重复的数字，就会出现此顺序。例如：1、2、2、3、4、5。这里 2 重复了两次。
• 非递减顺序：如果序列中存在的每个第 i^个元素都小于或等于其第 (i-1)^个元素，则称一组值处于非递减顺序。只要有重复的数字，就会出现此顺序。例如：5、4、3、2、2、1。这里 2 重复了两次。

排序技术

Python中排序技术的不同实现是：

• 冒泡排序
• 选择排序
• 插入排序

冒泡排序

冒泡排序是一种简单的排序算法。这种排序算法反复比较两个相邻元素，如果它们的顺序错误，则交换它们。它也被称为下沉排序。它在平均和最坏情况下的时间复杂度为 O(n ² )，在最佳情况下的时间复杂度为 O(n)。冒泡排序可以可视化为一个队列，人们通过相互交换来排列自己，以便他们都可以按照身高升序排列。或者换句话说，我们比较两个相邻的元素，看看它们的顺序是否错误，如果顺序错误，我们交换它们。 （即 arr[i] > arr[j] for 1 <= i < j <= s；其中 s 是数组的大小，如果数组按升序排列，反之亦然）。

例子

这里我们使用冒泡排序对以下序列进行排序

序列：2、23、10、1

第一次迭代

( 2, 23 , 10, 1) -> ( 2, 23 , 10, 1)，这里比较前两个元素并保持不变，因为它们已经按升序排列。

(2, 23, 10 , 1) -> (2, 10, 23 , 1)，这里第 2 和第 3 个元素按照升序进行比较和交换（10 小于 23）。

(2, 10, 23, 1 ) -> (2, 10, 1, 23 ), 这里第3和第4个元素按照升序进行比较和交换(1小于23)

在第一次迭代结束时，最大的元素位于正确排序的最右边。

第二次迭代

( 2, 10 , 1, 23) -> ( 2, 10, 1, 23), 这里再次比较前 2 个元素并保持不变，因为它们已经按升序排列。

(2, 10, 1 , 23) -> (2, 1, 10 , 23)，这里第 2 和第 3 个元素按升序进行比较和交换（1 小于 10）。

在第二次迭代结束时，第二大元素位于最大元素的相邻位置。

第三次迭代

( 2, 1 , 10, 23) -> ( 1, 2 , 10, 23), 这里前2个元素按照升序进行比较和交换。

其余元素已经在第一次和第二次迭代中排序。在三次迭代之后，给定的数组按升序排序。所以最终的结果是 1, 2, 10, 23。

冒泡排序的实现：

Python3

# Python3 program for Bubble Sort Algorithm Implementation
def bubbleSort(arr):
     
    n = len(arr)
 
    # For loop to traverse through all
    # element in an array
    for i in range(n):
        for j in range(0, n - i - 1):
             
            # Range of the array is from 0 to n-i-1
            # Swap the elements if the element found
            #is greater than the adjacent element
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
                 
# Driver code
 
# Example to test the above code
arr = [ 2, 1, 10, 23 ]
 
bubbleSort(arr)
 
print("Sorted array is:")
for i in range(len(arr)):
    print("%d" % arr[i])

输出：

Sorted array is:

1

2

10

23

选择排序

这种排序技术反复找到最小元素并按顺序对其进行排序。冒泡排序不占用任何额外的内存空间。在该算法的执行过程中，维护了两个子数组，一个已经排序的子数组，一个未排序的剩余子数组。在每次迭代执行选择排序期间，未排序子数组的最小元素排列在已排序子数组中。选择排序是一种比冒泡排序更有效的算法。在平均、最差和最好的情况下，排序的时间复杂度为 O(n ² )。

例子

这里我们使用选择排序对以下序列进行排序

顺序：7、2、1、6

(7, 2 , 1 , 6) –> ( 1 , 7, 2, 6)，在第一次遍历中，它找到最小元素（即 1）并将其放置在第一个位置。

(1, 7, 2 , 6) -> (1, 2 , 7, 6)，在第二次遍历中，它找到第二个最小元素（即 2）并将其放置在第二个位置。

(1, 2 , 7, 6 ) -> (1, 2, 6, 7 )，在第三次遍历中，它找到下一个最小元素（即 6）并将其放置在第 3 个位置。

经过上述迭代，最终的数组是有序的，即1、2、6、7。

选择排序的实现

Python3

# Selection Sort algorithm in Python
def selectionSort(array, size):
     
    for s in range(size):
        min_idx = s
         
        for i in range(s + 1, size):
             
            # For sorting in descending order
            # for minimum element in each loop
            if array[i] < array[min_idx]:
                min_idx = i
 
        # Arranging min at the correct position
        (array[s], array[min_idx]) = (array[min_idx], array[s])
 
# Driver code
data = [ 7, 2, 1, 6 ]
size = len(data)
selectionSort(data, size)
 
print('Sorted Array in Ascending Order is :')
print(data)

输出：

Sorted Array in Ascending Order is :

[1, 2, 6, 7]

插入排序

此排序算法维护一个始终排序的子数组。来自数组未排序部分的值被放置在已排序部分的正确位置。它在实践中比选择排序或冒泡排序等其他算法更有效。插入排序在平均和最坏情况下的时间复杂度为 O(n ² )，在最佳情况下为 O(n)。

例子

这里我们使用插入排序对以下序列进行排序

顺序：7、2、1、6

( 7, 2 , 1, 6) -> ( 2, 7 , 1, 6), 在第一次迭代中，比较前 2 个元素，这里 2 小于 7 所以在 7 之前插入 2。

(2, 7, 1 , 6) -> (2, 1, 7 , 6)，在第二次迭代中比较第 2 和第 3 个元素，这里 1 小于 7，所以在 7 之前插入 1。

( 2, 1 , 7, 6) -> ( 1, 2 , 7, 6), 在第二次迭代之后 (1, 7) 元素不是按升序排列的，所以首先排列这两个元素。因此，在 2 之前插入 1。

(1, 2, 7, 6 ) -> (1, 2, 6, 7 )，在此迭代期间，在交换所有先前元素之后，比较和交换最后两个元素。

插入排序的实现

Python3

# Creating a function for insertion sort algorithm
def insertion_sort(list1): 
   
        # Outer loop to traverse on len(list1) 
        for i in range(1, len(list1)): 
   
            a = list1[i] 
   
            # Move elements of list1[0 to i-1],
            # which are greater to one position
            # ahead of their current position 
            j = i - 1 
           
            while j >= 0 and a < list1[j]: 
                list1[j + 1] = list1[j] 
                j -= 1 
                 
            list1[j + 1] = a 
             
        return list1 
            
# Driver code
list1 = [ 7, 2, 1, 6 ] 
print("The unsorted list is:", list1) 
print("The sorted new list is:", insertion_sort(list1))

输出：

The unsorted list is: [7, 2, 1, 6]

The sorted new list is: [1, 2, 6, 7]