数据结构基础理论—查找与排序问题
查找算法
在一堆东西中,找到一个东西
最基本写法:
- 从头到尾依次寻找,如果找到,就反馈,最后循环完成后,反馈失败
def find_value(data, val):
for i,x in enumrate(data):
if x == val:
return i
return -1
- 监视哨
def find_value(data, val):
i = len(data)
while i >= 0:
if data[i] == val:
return i
i -= 1
return -1
时间复杂度 : O(N)
改进方案:
-
二分查找法
原数据必须有序,===》 构造一个二分查找树
O(logN) -
哈希查找法
x1 -----> 存储在一个物理地址,一个索引上
查找x1,能够构造一个函数,把x1传入后,就能得到这个索引 f(x1) = index1 就把x1放到index1的位置上 存储
f(x2) = index2 就把x2放到index2的位置上 存储
查找x3
f(x3) = index3 通过index3去看下源空间,有没有x3所有的原数据,都经过一个哈希函数进行加工,加工的结果,尽量保证原数据没有重复索引,利用这个索引,把原数据放置在空间中
当需要查找一个新的值val, 把val还是带入该哈希函数,得到一个新的索引值,利用这个索引值,看空间的值和val是否相等
常用的哈希函数结构: 1. 线性结构 y = kx+b 2. 取整法 3. 采样差值法 4. 质数求模法 10 88 44 7 求模 N % 7 = [0-6] 10 % 7 = 3 88 % 7 = 4 44 % 7 = 2
字典无序
k-v
k 就会通过内部的哈希函数映射成一个固定的索引值
字典查找数据时,实际消耗的时间就跟这个哈希函数的执行时间,跟原空间大小的N没有关系
a = {}
# 字典的key值是唯一的
a['100'] = 'aaa'
a['100'] = 'bbb' # 覆盖原来的值
列表有序
分离的元素外置式
排序算法
冒泡排序:
- ⽐较相邻的元素。如果第⼀个⽐第⼆个⼤(升序),就交换他们两个。
- 对每⼀对相邻元素作同样的⼯作,从第⼀对到结尾的最后⼀对。这步做完后,最后的元素会是最⼤的数。
- 针对所有的元素重复以上的步骤,除了最后⼀个。
- 持续每次对越来越少的元素重复上⾯的步骤,直到没有任何⼀对数字需要⽐较。
# 冒泡排序
import random
def bubble_sort(data:list):
# 每轮减少一个
for i in range(len(data)-1,0,-1):
for j in range(i):
if data[j] > data[j+1]:
data[j],data[j+1]= data[j+1],data[j]
def test():
li = [random.randint(10,100) for v in range(10)]
print('原列表',li)
bubble_sort(li)
print('冒泡后',li)
if __name__ == "__main__":
test()
# 正常的时间复杂度: O(N^2)
选择排序:
-
⾸先在未排序序列中找到最⼩(⼤)元素,存放到排序序列的起始位置;
-
然后,再从剩余未排序元素中继续寻找最⼩(⼤)元素;
扫描二维码关注公众号,回复: 5345179 查看本文章 -
然后放到已排序序列的末尾。
-
以此类推,直到所有元素均排序完毕
# 选择排序
import random
# 选择排序: 先比较记录索引,最后在交换位置
def selection_sort(data):
n = len(data)
# 需要进⾏n-1次选择操作
for i in range(n-1):
minindex = i
# 从i+1位置到末尾选择出最⼩数据
for j in range(i+1,n):
if data[j] < data[minindex]:
minindex = j
# 如果选择出的数据不在正确位置,进⾏交换
if minindex != i:
data[i],data[minindex]=data[minindex],data[i]
def test():
li = [random.randint(10,100) for v in range(10)]
print('原列表',li)
selection_sort(li)
print('选择排序后',li)
if __name__ == "__main__":
test()
插入排序:
- 通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插
⼊。 - 插⼊排序在实现上,在从后向前扫描过程中,需要反复把已排序元素逐步向后挪位,为最
新元素提供插⼊空间
快速排序:
-
通过⼀趟排序将要排序的数据分割成独⽴的两部分,
-
其中⼀部分的所有数据都⽐另外⼀部分的所有数据都要⼩,
-
然后再按此⽅法对这两部分数据分别进⾏快速排序,
-
整个排序过程可以递归进⾏,以此达到整个数据变成有序序列
步骤为:
-
从数列中挑出⼀个元素,称为"基准"(pivot),
-
重新排序数列,所有元素⽐基准值⼩的摆放在基准前⾯,所有元素⽐基准值⼤的摆在基准
的后⾯(相同的数可以到任⼀边)。在这个分区结束之后,该基准就处于数列的中间位
置。这个称为分区(partition)操作。 -
递归地(recursive)把⼩于基准值元素的⼦数列和⼤于基准值元素的⼦数列排序。
import random
def quick_sort(data):
less = []
equal = []
bigger = []
if len(data)>1:
# 默认选择第一个为基准
pivot = data[0]
for v in data:
# 值小于基准,放入小的列表
if pivot > v:
less.append(v)
elif pivot == v:
equal.append(v)
# 值小于基准,放入大的列表
elif pivot < v:
bigger.append(v)
# 递归再次快速排序
return quick_sort(less) + equal + quick_sort(bigger)
else:
return data
def test():
li = [random.randint(10,100) for v in range(10)]
print('原列表',li)
data = quick_sort(li)
print('快速排序后',data)
if __name__ == "__main__":
test()
归并排序
-
归并排序是采⽤分治法的⼀个⾮常典型的应⽤。归并排序的思想就是先递归分解数组,再合并数
组。 -
将数组分解最⼩之后,然后合并两个有序数组,基本思路是⽐较两个数组的最前⾯的数,谁⼩就先取
谁,取了后相应的指针就往后移⼀位。然后再⽐较,直⾄⼀个数组为空,最后把另⼀个数组的剩余部
分复制过来即可。
def merge_sort(alist):
if len(alist) <= 1:
return alist
# ⼆分分解
num = len(alist)/2
left = merge_sort(alist[:num])
right = merge_sort(alist[num:])
# 合并
return merge(left,right)
def merge(left, right):
'''合并操作,将两个有序数组left[]和right[]合并成⼀个⼤的有序数组'''
#left与right的下标指针
l, r = 0, 0
result = []
while l<len(left) and r<len(right):
if left[l] < right[r]:
result.append(left[l])
l += 1
else:
result.append(right[r])
r += 1
result += left[l:]
result += right[r:]
return result
alist = [54,26,93,17,77,31,44,55,20]
sorted_alist = mergeSort(alist)
print(sorted_alist)