python实现时间复杂度平均为N^2的冒泡选择插入排序

Posted 2021-10-21 Tuki_a

时间复杂度平均为N^2

• • 冒泡排序
  • • 冒泡排序代码：
  • 选择排序
  • • 选择排序代码：
  • 冒泡和选择排序算法的不同（两点）
  • 插入排序
  • • 插入排序代码：
  • 冒泡和插入排序算法的不同

冒泡排序

冒泡排序是最基础的排序算法，由于其直观性，经常作为首个介绍的排序算法。其原理为:

• 内循环: 使用相邻双指针j，j + 1从左至右遍历，依次比较相邻元素大小,若左元素大于右元素则将它们交换;遍历完成时,最大元素会被交换至数组最右边。
• 外循环:不断重复「内循环」 ，每轮将当前最大元素交换至剩余未排序数组最右边，直至所有元素都被交换至正确位置时结束。
  

冒泡排序代码：

def bubble_sort(nums:list):
    n = len(nums)
    for i in range(n-1):        #最后一个元素后边没有元素了，所以要减一，不然会溢出
        for j in range(n-i-1):      #后边的已经是比较过的了，不需要再比了
            if nums[j] > nums[j+1]:
                nums[j],nums[j+1] = nums[j+1], nums[j]
                #因为外层循环只是决定了里边这个过程执行几次，并不是索引
                #所以索引只用到j就够了
    return nums

nums = [6,1,3,2,9,7]
print(bubble_sort(nums))

选择排序

选择排序的思想是：双重循环遍历数组，每经过一轮比较，找到最小元素的下标，将其交换至首位。
选择排序使用两层循环，时间复杂度为O(n^2); 只使用有限个变量，空间复杂度 O(1)。

选择排序代码：

def selection_sort(nums:list):
    for i in range(len(nums) - 1):      #-1也是防止溢出
        min_index = i                   #记录最小值的下标
        for j in range(i+1,len(nums)):
            if nums[j] < nums[min_index]:   #后边未比较的与目前最小的比较
                # 注意必须用min_index，因为min_index一直在更新
                min_index = j               #如果上边的成立，那么更新最小的下标
        if i != min_index:                  #当跑了一轮后，如果最小下标变了，就交换
            nums[i],nums[min_index]= nums[min_index],nums[i]
    return nums

nums = [8,7,4,9,1,5]
print(selection_sort(nums))

冒泡和选择排序算法的不同（两点）

• 1、冒泡在比较过程中比如第一个和第二个比较，第一个大就立马交换了，边比边交换；而选择排序是第一个和第二个比较，第二个小，先把下标记下来，再和第三个比，更小的话更新下标，直到这一轮比完了才交换，然后再进行下一轮
• 2、冒泡稳定：不改变相等元素的相对位置；选择不稳定：有可能改变相等元素的相对位置
  （比如5、8、5、2、9，第一次会让5，2交换这个时候其实两个5的相对位置已经变了之后也不会再交换，稳定性就被破坏了）

插入排序

在新数字插入过程中，与前面的数字不断比较，前面的数字不断向后挪出位置，当新数字找到自己的位置后，插入一次即可。

就是对已排序的部分和未排序的部分，在比较时，只先移动，不插入，等不满足比选出来的元素大这个条件了再插入，这就需要一个中间变量来存储。

时间/空间复杂度：

插入排序代码：

"""
    第一层循环控制循环次数，第二层循环比较元素，并向后移动元素供待插入元素插入。
    被选中的排序的值（顶替的值）已经被temp存起来了，这个位置就相当于空出来了，和前面的比较后就能让前面的往后挪了
"""
def insert_sort(nums:list):
    for i in range(1, len(nums)):      #默认第一个是已排序部分，后边的是未排序部分，从第二个比起
        #nums[i]就是选中的要排序的数，也就是temp把它存起来了
        temp = nums[i]          #这个时候其实nums[i](nums[j+1])这个位置已经空出来了
        j = i-1
        while j>=0 and temp < nums[j]:
            nums[j+1] = nums[j]         #待排序的比已排序的小，那前面的就往后移给更小的让位
            j -= 1
        nums[j+1] = temp        #前面的再没有比temp小的了，所以让temp插入到空出来的位置即可
    return nums

nums = [3,9,7,1,2,4,5]
print(insert_sort(nums))

冒泡和插入排序算法的不同

元素的移动次数是相同的，但总的交换次数冒泡排序大于插入排序。
移动一次，我们可以不计较，如果数据很多，两者的效率差别很轻易的就比较出来了。