算法与数据结构

• 目录
• • 排序算法
  • • 1. 冒泡排序
    • 2. 选择排序
    • 3. 插入排序
    • 4. 希尔排序

目录

此博客开始是为了2022春招

排序算法

1. 冒泡排序

1. 基本思想
   通过对待待排序元素从下标较小元素开始向后，依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部。
2. Python代码实现

   def bubble_sort(arr):
       n = len(arr)
       # i表示一共冒泡多少次
       for i in range(n):
           # j是每一次冒泡需要进行比对的元素
           for j in range(0, n - i - 1):
               if arr[j] > arr[j + 1]:
                   arr[j], arr[j + 1] = arr[j + 1], arr[j]
       return arr
   
   
   if __name__ == '__main__':
       array = [1, 5, 2, 9, 29, 33, 44]
       array = bubble_sort(array)
       print(array)
   

2. 选择排序

1. 基本思想：总共进行n-1次，得到一个按排序码从小到大排列的有序序列。
   1. 第一次从arr[0]~arr[n-1]中选取最小值，与arr[0]交换；
   2. 第二次从arr[1]~arr[n-1]中选取最小值，与arr[1]交换；
   3. 第三次从arr[2]~arr[n-1]中选取最小值，与 arr[2] 交换；
   4. …
   5. 第i次从arr[i-1]~arr[n-1]中选取最小值，与arr[i-1]交换；
   6. 第n-1次从arr[n-2]~arr[n-1]中选取最小值，与arr[n-2]交换。
2. Python代码展示：

   def select_sort(arr) -> object:
       n = len(arr)
       for j in range(n):
           min = arr[j]  # 每一次循环都假定第一个数为最小值
           for i in range(j, n):
               if arr[i] < min:
               	# 更新最小值
                   min, arr[i] = arr[i], min
           # 将最小值与每次循环的第一个值交换
           arr[j] = min
       return arr
   
   
   if __name__ == '__main__':
       array = [2, 5, 1, 9, 29, 6, 44]
       result = select_sort(array)
       print(result)
   

3. 插入排序

1. 基本思想：
   将n个待排序元素看成一个有序表和无序表，开始时有序表只有一个元素，无序表有n-1个元素，排序过程中每次从无序表中取出第一个元素，把它的排序码依次与有序表元素的排序码进行比较，将它插入到有序表中的适当位置，使之成为有序表。
2. Python代码实现

   def insert_sort(arr) -> object:
       # 第i轮排序
       for i in range(1, len(arr)):
           insert_val = arr[i]  # 待插入元素
           insert_index = i - 1  # 有序数组最右边的索引
           # 判断在有序表中的数据不越界的前提下，
           # 并且带插入元素与有序表中元素依次从最优边开始比较，小于就让index-1
           while insert_index >= 0 and insert_val < arr[insert_index]:
               arr[insert_index + 1] = arr[insert_index]
               insert_index -= 1
           # 当退出循环时，insert_index多减了依次，所以索引+1 才能保证插入正确位置
           arr[insert_index + 1] = insert_val
       return arr
   
   
   if __name__ == '__main__':
       array = [8, 5, 1, 9, 15, 6, 12, 3]
       result = insert_sort(array)
       print(result)
   

4. 希尔排序

1. 基本思想：
   希尔排序也是一种插入排序，它克服了当插入的数是较小数时，后移次数明显增多的现象；它其实就是把记录按照下标的一定增量分组，对每组实行直接插入排序；当增量越来越少，每组包含的元素越来越多，当增量减至1时，整个数组被看成一组，算法便终止。

   def shell_sort(arr: object) -> object:
       # 设置增量gap
       n = len(arr)
       gap = n // 2
       while gap >= 1:
       	# 对每组进行插入排序。
           for i in range(gap, n):
               temp = arr[i]
               while i - gap >= 0 and temp < arr[i - gap]:
                   arr[i] = arr[i - gap]
                   i -= gap
               arr[i] = temp
           gap //= 2
       print(arr)
   
   
   if __name__ == '__main__':
       array = [2, 5, 1, 9, 29, 6, 44, 3]
       shell_sort(array)