三、排序
1. 冒泡排序
- 思想：每次都是相邻元素进行比较，当后面的元素小于前面元素时，就进行交换位置 。
- 时间复杂度：O(N^2) 空间复杂度：O(1)
- 稳定性：稳定
def bubble_sort_mod(array):
for i in range(len(array)):
is_sorted = True
for j in range(1, len(array) - i):
if (array[j] < array[j - 1]):
array[j], array[j - 1] = array[j - 1], array[j]
is_sorted = False
if (is_sorted): break
return array
2. 选择排序
- 思想：是对冒泡排序的改进，每一轮仅进行一次交换，把最大值换到最后面即可。
- 时间复杂度：O(N^2) 空间复杂度：O(1)
- 稳定性：不稳定
# 这里是每一轮换最大值，把最大值换到数组最后面去
def selection_sort(nums):
for i in range(len(nums)):
pos_max = 0
for j in range(1, len(nums) - i):
if nums[j] > nums[pos_max]:
pos_max = j
nums[len(nums)-i-1], nums[pos_max] = nums[pos_max], nums[len(nums)-i-1]
return nums
3. 插入排序
- 思想：类似于打牌的时候人们插牌的方式，来一张新牌就把它与前面排好的牌进行比对，找到合适的插入位置。
- 时间复杂度：O(N^2) 空间复杂度：O(1)
- 稳定性：稳定
def insert_sort(nums):
for i in range(1, len(nums)):
current_value = nums[i]
position = i
while position > 0 and nums[position-1] > current_value: # while 循环实现
nums[position] = nums[position-1] # 移动操作仅一次赋值，是交换操作的三分之一，此时性能会好一些
position -= 1
nums[position] = current_value # 插入
return nums
4. 希尔排序
- 思想：希尔排序就是再插入排序的基础上多了个gap而已。
- 时间复杂度：O(N^1.3) 空间复杂度：O(1)
- 稳定性：不稳定
def shell_sort(nums):
sublistcount = len(nums) // 2
while sublistcount > 0:
for startposition in range(sublistcount):
gapInsertionSort(nums, startposition, sublistcount)
print("After increments of size", sublistcount, "The list is", nums)
sublistcount = sublistcount // 2
return nums
def gapInsertionSort(nums, start, gap): #插入排序
for i in range(start+gap, len(nums), gap):
currentvalue = nums[i]
position = i
while position >= gap and nums[position-gap] > currentvalue:
nums[position] = nums[position-gap]
position -= gap
nums[position] = currentvalue
5. 计数排序
- 思想：首先找到数组的最大值和最小值，根据这两个值制造一定长度的抽屉。其次要把数字一个个的放到抽屉里面，然后再按顺序拿出来。
- 时间复杂度：O(N) 空间复杂度：O(K), K表示最大值与最小值之差
- 稳定性：稳定
def count_sort(items):
mmax, mmin = max(items), min(items)
nums = mmax - mmin + 1
counts = [0] * nums
for i in range(len(items)):
counts[items[i]-mmin] = counts[items[i] - mmin] + 1
pos = 0
for i range(nums): # 只是从抽屉里把所有的数都拿出来，O(n)复杂度
for j in range(counts[i]):
items[pos] = i + mmin
pos += 1
return items
6. 归并排序
- 思想：将数组持续分为两半，分别对两半运用双指针的办法进行归并排序。是一种递归的方法
- 时间复杂度：O(N) 空间复杂度：O(1)
- 稳定性：稳定
# 更python的写法
def merge_sort(nums):
if len(nums) <= 1: # base情况 也就是递归的结束条件
return nums
# 分解问题，并递归调用
middle = len(nums) // 2
left = merg_sort(nums[:middle]) # 左半部
right = merg_sort(nums[middle:]) # 右半部
# 合并左右半步，完成排序
merged = []
while left and right:
if left[0] <= right[0]:
merged.append(left.pop(0))
else:
merged.append(right.pop(0))
merged.extend(right if right else left)
return merged
7. 快速排序
- 思想：依据一个“中值”数据项把数组分为两半：小于中值的一半和大于中值的一半。然后分别对两半进行快速排序。
- 时间复杂度：O(NlgN) 空间复杂度： 首先就地快速排序使用的空间是O(1)的，也就是个常数级；而真正消耗空间的就是递归调用了，因为每次递归就要保持一些数据；
- 稳定性：不稳定
def quickSort(nums):
quickSortHelper(nums, 0, len(nums)-1)
def quickSortHelper(nums, first, last):
if first < last:
splitpoint = partition(nums, first, last) # 先找到中点
quickSortHelper(nums, first, splitpoint-1)
quickSortHelper(nums, splitpoint+1, last)
def partition(nums, first, last):
pivotvalue = nums[first]
leftmark = first + 1
rightmark = last
done = False
while not done:
while leftmark <= rightmark and nums[leftmark] <= pivotvalue:
leftmark += 1
while leftmark <= rightmark and nums[rightmark] >= pivotvalue:
rightmark -= 1
if rightmark < leftmark:
done = True
else:
nums[leftmark], nums[rightmark] = nums[rightmark], nums[leftmark]
nums[first], nums[rightmark] = nums[rightmark], nums[first]
return rightmark
