数据结构与算法01

时间复杂度

 空间复杂度

说的简单一点就是占用内存空间的多少，但是现在不怎么考虑了

递归

1. 调用自己

2.终止条件

汉诺塔问题

# 汉诺塔问题

def hannoi(n,a,b,c):
    if n>0:
        hannoi(n-1,a,c,b)
        print("from %s to %s"%(a,c))
        hannoi(n-1,b,a,c)


if __name__ == '__main__':
    hannoi(3,"a","b","c")

查找

顺序查找

def search(li,div):
    for ind,v in enumerate(li):
        if v==div:
            return ind
    else:return None


div=3
li=[1,2,3,4,5,6,7]

print(search(li,div))

二分查找

注意 ：二分查找要基于数据是排好序的状态才能使用

'''
这个编程 是二分法查找
'''
def binary_search(li,val):
    left=0;
    right=len(li)-1
    while left<=right:
        mid=(left+right)//2
        if(li[mid]==val):
            return mid
        elif(li[mid]>val):
            right=mid-1
        elif(li[mid]<val):
            left=mid+1

    else:return None

if __name__ == '__main__':

    li=[1,2,3,4,5,6,7,8,9,10]

    print(binary_search(li,3))

排序

 选择排序

原理是 每次都挑选出来列表中最小的一个数出来 将他放在前面

list =[1,5,3,7,6,4,2,8]

for i in range(len(list)):
    min=i
    for j in range(i+1,len(list)):
        if(list[min]>list[j]):
            list[min],list[j]=list[j],list[min]


print(list)

插入排序

摸牌排序

def insert_sort(li):
    for i in range(1,len(li)):
        temp=li[i]  # 要摸n-1次
        j=i-1 #j是手中的牌
        while j>=0 and li[j]>temp:
            li[j+1]=li[j]
            j-=1

        li[j+1]=temp

if __name__ == '__main__':
    list=[0,1,3,5,4,7,6,9,8]
    insert_sort(list)
    print(list)

Nb三人组

快速排序

思路： 找一个值作为分界点，将头和尾部进行遍历与分界点的值进行比较，左边全为比分界点的值要小的值，右边是比分界点的值要大的值。通过递归进行更加细致的排列，最终形成有序

def partition(li,left,right):
    temp=li[left]
    while left<right:

        while left<right and li[right]>=temp:
            right-=1  #一直往右找比基准值小的数

        li[left]=li[right]
        while left<right and li[left]<=temp:
            left+=1
        li[right]=li[left]
    li[left]=temp
    return left

def quick_sort(li,left,right):
    if(left<right):
        mid=partition(li,left,right)
        quick_sort(li,left,mid-1)
        quick_sort(li,mid+1,right)

list=[5,7,8,6,4,3,1,2,5]
print(list)
partition(list,0,len(list)-1)
print(list)
quick_sort(list,0,len(list)-1)
print(list)

堆排序

树：由字面理解，数据排布方式就像一颗树一样有根和叶

有比较特殊的两种树 如下图显示

 

顺序的存储方式其实就是从上往下再加上从左往右的顺序去数

大根堆与小根堆

 

堆排序的过程

 代码

def sift(li,low,high):
    '''

    :param li: 列表
    :param low:堆的根节点
    :param high: 堆的最后一个叶子节点
    :return:
    '''
    i=low #i是最开始指向根节点
    j=2*i+1 #j是开始的左孩子
    tmp=li[low] #把顶部存起来
    while j<=high:
        if j+1<=high and li[j+1]>li[j]:
            j=j+1
        if li[j]>tmp:
            li[i]=li[j]
            i=j
            j=2*j+1
        else:
            li[i]=tmp
            break
    else:li[i]=tmp

def heap_sort(li):
    n=len(li)
    for i in range((n-2)//2,-1,-1):
        sift(li,i,n-1)
    #堆建完了
    for i in range(n-1,-1,-1):
        li[0],li[i]=li[i],li[0]
        sift(li,0,i-1)

if __name__ == '__main__':
    li=[i for i in range(100)]
    import random
    random.shuffle(li)
    print(li)
    heap_sort(li)
    print(li)

 

堆排序topk问题

就是找到前k个最大或者最小的数

 注意：关于稳定，是指相同值的两个数排序后的相对位置是否发生改变

归并排序

思路：将无序列表切割，分成各个部分，再进行组合形成有序

def merge(li,low,high):
    i=low
    mid=(low+high)//2
    j=mid+1
    litmp=[]
    while i<=mid and j<=high:
        if li[i]<li[j]:
            litmp.append(li[i])
        else:
            litmp.append(li[j])

    while i<=mid:
        litmp.append(li[i])
    while j<=high:
        litmp.append(li[j])
    li[low:high+1]=litmp

def merge_sort(li,low,high):
    if low<high:
        mid=(low+high)//2
        merge(li,low,mid)
        merge(li,mid+1,high)
        merge(li,low,mid,high)

if __name__ == '__main__':
    import random
    li=[i for i in range(100)]
    random.shuffle(li)
    print(li)
    merge_sort(li,0,len(li)-1)
    print(li)

 其他排序

希尔排序