冒泡排序
-
冒泡排序思路:
对于从小到大排序,从头到尾以此比较相邻的两个元素的大小,如果前一个元素的值大于后一个元素,则两个元素交换位置,直到最后两个元素比较完成,完成一轮排序,依此类推,完成排序
6 | 2 | 1 | 4 | 7 | 3 |
---|---|---|---|---|---|
2 | 6 | 1 | 4 | 7 | 3 |
2 | 1 | 6 | 4 | 7 | 3 |
2 | 1 | 4 | 6 | 7 | 3 |
2 | 1 | 4 | 6 | 7 | 3 |
2 | 1 | 4 | 6 | 3 | 7 |
依次类推… | |||||
1 | 2 | 4 | 6 | 3 | 7 |
1 | 2 | 4 | 6 | 3 | 7 |
list1 = [6, 2, 1, 4, 7, 3, 5]
for i in range(len(list1)):
for j in range(len(list1) - i - 1):
if list1[j] > list1[j + 1]:
list1[j], list1[j + 1] = list1[j + 1], list1[j]
print(list1)
选择排序
选择排序思路:
- 选定第一个索引位置,然后和后面元素依次比较
- 如果后面的元素, 小于第一个索引位置的元素, 则交换索引的值
- 经过一轮的比较后, 可以确定第一个位置是最小的
- 然后使用同样的方法把剩下的元素逐个比较即可
- 可以看出选择排序,第一轮会选出最小值,第二轮会选出第二小的值,直到最后
def selection_sort(list):
length = len(list)
for i in range(length - 1):
index = i
for j in range(i + 1, length):
if list[index] > list[j]:
index = j
list[i], list[index] = list[index], list[i]
list = [6, 2, 1, 4, 7, 3, 5]
selection_sort(list)
print(list)
插入排序
插入排序的思路:
- 从第一个元素开始,该元素可以认为已经被排序
- 取出下一个元素,在已经排序的元素序列中从后向前扫描
- 如果该元素(已排序)大于新元素,将该元素移到下一位置
- 重复上一个步骤,直到找到已排序的元素小于或者等于新元素的位置
- 将新元素插入到该位置后, 重复上面的步骤.
- 总结:假设一个空教室,里面按照从低到高的身高站座位,教室外面的人进入一个就跟最高的比较 比它高的人就往后移动一个位置 直到找到最后一个移动位置的人 把移动后的位置给新人
def insertion_sort(arr):
length = len(arr)
for i in range(1, length):
j = i
temp = arr[i]
while j > 0 and arr[j-1] > temp:
arr[j] = arr[j-1]
j -= 1
arr[j] = temp
list=[6,2,1,4,7,3,5]
insertion_sort(list)
print(list)
归并排序
基本思想与过程:先递归的分解数列,再合并数列(分治思想的典型应用)
(1)将一个数组拆成A、B两个小组,两个小组继续拆,直到每个小组只有一个元素为止。
(2)按照拆分过程逐步合并小组,由于各小组初始只有一个元素,可以看做小组内部是有序的,合并小组可以被看做是合并两个有序数组的过程。
(3)对左右两个小数列重复第二步,直至各区间只有1个数。
下面对数组【42,20,17,13,28,14,23,15】进行归并排序,模拟排序过程如下:
第一步:拆分数组,一共需要拆分三次;
第一次拆成【42,20,17,13】,【28,14,23,15】,
第二次拆成【42,20】,【17,13】,【28,14】,【23,15】,、
第三次拆成【42】,【20】,【17】,【13】,【28】,【14】,【23】,【15】;
第二步:逐步归并数组,采用合并两个有序数组的方法,每次将两个有序数组的最小数据拿出来比较 谁小 谁就添加进去 其中一个没有数据了就把剩下的全部加进去
第一次归并为【20,42】,【13,17】,【14,28】,【15,23】
第二次归并为【13,17,20,42】,【14,15,23,28】,
第三次归并为【13, 14, 15, 17, 20, 23, 28, 42】
#合并两个列表
def merge(left, right):
result = []
i = j = 0
while i < len(left) and j < len(right):
if left[i] < right[j]:
result.append(left[i])
i += 1
else:
result.append(right[j])
j += 1
result += left[i:]
result += right[j:]
return result
#归并排序
def merge_sort(arr):
length = len(arr)
if length > 1:
index = length // 2
left = arr[:index]
right = arr[index:]
return merge(merge_sort(left), merge_sort(right))
else:
return arr
list=[42,20,17,13,28,14,23,15]
newlist=merge_sort(list)
print(newlist)
快速排序
快速排序的思想:
- 快速排序最重要的思想是分而治之.
- 比如我们有这样一堆数字需要排序: [13,81,92,43,65,31,57,26,75,0]
- 第一步: 从其中选出了65. (其实可以是选出任意的数字, 我们以65举个栗子)
- 第二步: 我们通过算法: 将所有小于65的数字放在65的左边, 将所有大于65的数字放在65的右边.
- 第三步: 递归的处理左边的数据.(比如你选择31来处理左侧), 递归的处理右边的数据.(比如选择75来处理右侧, 当然选择81可能更合适)
- 最终: 排序完成
def quick_sort(arr):
if len(arr) <= 1:
return arr
value = arr[len(arr) // 2]
left = [x for x in arr if x < value]
mid = [x for x in arr if x == value]
right = [x for x in arr if x > value]
return quick_sort(left) + mid + quick_sort(right)
list1 = [13, 81, 92, 43, 65, 31, 57, 26, 75, 0]
new_list = quick_sort(list1)
print(new_list)
顺序搜索
从数据结构的第一个元素开始逐个检查,直到找到目标值或遍历完整个数据集。适用于数组和链表等基本数据结构。
def binary_search(arr, target):
for i in range(len(arr)):
if arr[i] == target:
return i
return False
sorted_array = [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
search_target = 11
result_index = binary_search(sorted_array, search_target)
二分搜索
针对有序数组进行搜索,通过不断将搜索范围减半来提高查找效率。每次都将搜索区间划分为两部分,并基于中间元素与目标值的比较决定是在左半边还是右半边继续搜索。
def binary_search(arr, target):
left, right = 0, len(arr)
while left < right:
mid = left + (right - left) // 2
if arr[mid] == target:
return mid
elif arr[mid] < target:
left = mid + 1
else:
right = mid - 1
return False
sorted_array = [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
search_target = 11
result_index = binary_search(sorted_array, search_target)
时间复杂度
时间复杂度衡量的是执行算法所需的基本操作次数,不考虑具体操作的时间开销,只关注操作次数随输入规模n增加的变化趋势。例如:
- 常数时间复杂度 O(1):算法的运行时间不随输入数据量增大而增大,如访问数组中的一个确定下标的元素。
- 对数时间复杂度 O(log n):算法的时间消耗以对数函数增长,常见于二分查找等算法。
- 线性时间复杂度 O(n):算法所需时间与输入规模成正比,比如遍历一个数组。
- 线性对数时间复杂度 O(n log n):常见于快速排序、归并排序等高效排序算法。
- 二次时间复杂度 O(n²):如冒泡排序、选择排序等简单排序算法,时间消耗与输入规模的平方成正比。
- 立方时间复杂度 O(n³):如果算法中有三层嵌套循环,每层循环都与n有关,则可能达到此复杂度。
- 指数时间复杂度 O(2^n):如完全枚举所有可能性的算法,在问题规模增大时增长极为迅速。
空间复杂度
空间复杂度衡量算法在运行过程中额外需要的存储空间大小。同样,它也采用大O表示法来描述空间需求与n的关系。
- 常数空间复杂度 O(1):算法所需的额外空间与输入数据量大小无关,始终保持不变。
- 线性空间复杂度 O(n):额外空间的需求随着输入规模线性增长,例如复制一份输入数组。
- 其他复杂度:根据算法的具体实现和所需额外存储的数据结构,可以有不同的空间复杂度。