python算法（一）查找&排序

python算法（一）查找&排序

---

一、查找

1、线性查找

def linear_search(li,val):#li:要查找的列表；val:要查找的对象
    for ind,v in enumerate(li):
        if v==val:
            return ind
    else:
        return None

2、二分查找

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
        else:
            left=mid+1
    else:
        return None

二、排序

1.1、冒泡排序

def bubble_sort(li):
    for i in range(len(li)-1):
        exchang=False
        for j in range(len(li)-i-1):
            if li[j]>li[j+1]:
                li[j],li[j+1]=li[j+1],li[j]
                exchang=True
        if exchang is False:
                return

1.2、选择排序

一趟排序记录最小的数，将其放到第一个位置
再一趟排序记录列表无序区最小的数，放到第二个位置
……

def slect_sort(li):
    for i in range(len(li)-1):
        min_loc=i   #先假设第i个最小
        for j in range(i+1,len(li)): #无序区，注意range是左包右不包
            if li[j]<li[min_loc]:
                min_loc=j
        li[i],li[min_loc]=li[min_loc],li[i]
        print(li)

1.3、插入排序

假设有n张牌，先抽一张，牌上数字为a。再从n-1张中抽一张，如果比a大，则插入a的右边。反之插在a的右边。

def insert_sort(li):
    for i in range(1,len(li)):
        j=i-1
        tmp=li[i]
        while  j>=0 and li[j]>tmp:
            li[j+1]=li[j]
            j-=1
        li[j+1]=tmp
        print(li)

2.1、快速排序

时间复杂度O(nlogn)

def partition(li, left, right):
    tmp = li[left]
    while left < right:
        while left < right and li[right] >= tmp:  # 从右侧找出比tmp小的数的下标
            right -= 1  # 往做走一步
        li[left] = li[right]  # 将右边找到的值写到左边
        while left < right and li[left] <= tmp:
            left += 1
        li[right] = li[left]
    li[left] = tmp  # 将tmp归位
    return left


def quick_sort(li, left, right):
    if left < right:  # 至少两个元素
        mid = partition(li, left, right)  # 以li[mid]为分割点
        quick_sort(li, left, mid - 1)
        quick_sort(li, mid + 1, right)


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

2.2、堆排序

时间复杂度O(nlogn)

def sift(li,low,high):
    """
    :param li: 列表
    :param low: 堆的根节点位置
    :param high: 堆的最后一个元素的位置
    :return:
    """
    i=low   #最开始指向根节点
    j=2*i+1 #j开始是左孩子（2*i+1是左孩子，2*i+2是右孩子）
    tmp=li[low] #把堆顶存储起来
    while j<=high:
        if j+1<=high and li[j+1]>li[j]: #如果右孩子有且比左孩子大
            j=j+1   #j指向右孩子
        if li[j]>tmp:
            li[i]=li[j]
            i=j
            j=2*i+1
        else:   #tmp更大，把tmp放到i的位置上
            li[i]=tmp   #把tmp放到某一级领导位置上
            break
    else:
        li[i]=tmp   #把tmp放到叶子节点上

def heap_sort(li):
    # 建堆
    n=len(li)
    for i in range((n-2)//2,-1,-1):#i表示建堆时候调整的部分的根的下标
        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) #i-1是新的high

li=[5,3,6,2,8,1,4,7,9]
heap_sort(li)
print(li)
python堆排序有内置模块headq
import heapq 
import random

li = list(range(10))
random.shuffle(li)  # 打乱

print(li)

heapq.heapify(li)  # 建堆

n = len(li)
for i in range(n):
    print(heapq.heappop(li), end=',')

堆排序的topk问题：
“”"
1、取列表前k个元素建立一个小根堆，堆顶就是目前第k大的数
2、依次向后遍历原列表，对于列表中的元素，如果小于堆顶，则忽略该元素；
如果大于堆顶，则将堆顶更换为该元素，并且对堆进行一次调整
3、遍历列表所有元素后，倒序弹出堆顶
“”"

def sift(li, low, high):
    i = low
    j = 2 * i + 1
    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 * i + 1
        else:
            break
        li[i] = tmp


def topk(li, k):
    heap = li[0:k]
    # 建堆
    for i in range((k - 2) // 2, -1, -1):
        sift(heap, i, k - 1)
    # 遍历
    for i in range(k, len(li)):
        if li[i] > heap[0]:
            heap[0] = li[i]
            sift(heap, 0, k - 1)
    # 出数
    for i in range(k - 1, -1, -1):
        heap[0], heap[i] = heap[i], heap[0]
        sift(heap, 0, i - 1)
    return heap


import random

li = list(range(100))
random.shuffle(li)

print(topk(li, 5))

2.3、归并排序

时间复杂度O(nlogn)

def merge(li, low, mid, high):
    i = low
    j = mid + 1
    ltmp = []
    while i <= mid and j <= high:
        if li[i] < li[j]:
            ltmp.append(li[i])
            i += 1
        else:
            ltmp.append(li[j])
            j += 1
    while i <= mid:
        ltmp.append(li[i])
        i += 1
    while j <= high:
        ltmp.append(li[j])
        j += 1
    li[low:high + 1] = ltmp  # 切片右不包

def merge_sort(li, low, high):
    if low < high:  # 至少有两个元素
        mid = (low + high) // 2
        merge_sort(li, low, mid)
        merge_sort(li, mid + 1, high)
        merge(li, low, mid, high)


li = list(range(20))
import random

random.shuffle(li)
print(li)
merge_sort(li, 0, len(li) - 1)
print(li)

3.1、总结

稳定性：列表排序猴，相同元素的相对位置不改变。例如：
{‘name’:‘a’,‘age’:18}
{‘name’:‘b’,‘age’:20}
{‘name’:‘a’,‘age’:25}
对上述字典按’name’排序之后为：
{‘name’:‘a’,‘age’:18}
{‘name’:‘a’,‘age’:25}
{‘name’:‘b’,‘age’:20}
– 快速排序、堆排序、归并排序总结
三种排序算法的时间复杂度都是O(nlogn)
一般情况下，就运行时间而言：快速排序<归并排序<堆排序
缺点：快速排序-极端情况下排序效率低（例如，数列是倒序时）；归并-需要额外的内存开销；堆排序-在以上三种排序中速度偏慢

4.1、希尔排序

def insert_sort_gap(li,gap):
    for i in range(gap,len(li)):
        tmp=li[i]
        j=i-gap
        while j>=0 and li[j]>tmp:
            li[j+gap]=li[j]
            j -= gap
        li[j+gap]=tmp

def shell_sort(li):
    d=len(li) // 2
    while d>=1:
        insert_sort_gap(li,d)
        d //=2

import  random
li=list(range(20))
random.shuffle(li)
print(li)

shell_sort(li)
print(li)
5.1、计数排序
一直列表中的数范围都在0-100之间，设计时间复杂度为O(n)的算法
def count_sort(li, max_count=100):
    count = [0 for i in range(max_count + 1)]
    for val in li:
        count[val] += 1
    li.clear()
    for ind, val in enumerate(count):
        for i in range(val):
            li.append(ind)

import random
li=[random.randint(0,100) for i in range(20)]
print("排序前",li)
count_sort(li)
print("排序后",li)

4.2、桶排序

将元素分在不同的桶中，在对每个桶中的元素排序

def bucket_sort(li,n=100,max_num=10000):
    """
    :param n: 分桶编号
    :param max_num: 数的范围
    """
    buckets=[[] for i in range(n)]#创建桶
    for var in li:
        i = min(var//(max_num//n),n-1)# i表示var放到几号桶，当var=10000时，计算得100，但实际应该放到99号桶
        buckets[i].append(var)  #把var放到桶里
        for j in range(len(buckets[i])-1,0,-1):#排列每个桶里的顺序
            if buckets[i][j]<buckets[i][j-1]:
                buckets[i][j],buckets[i][j-1]=buckets[i][j-1],buckets[i][j]
            else:
                break
    # 接收每个桶里列表的数
    sorted_li=[]
    for buc in buckets:
        sorted_li.extend(buc)
    return sorted_li

import  random
li=[random.randint(0,10000) for i in range(100)]
print(li)
li=bucket_sort(li)
print(li)
5.3、基数排序
时间复杂度O(nk)，k指数字的位数
def radix_sort(li):
    #先按个位数排好序，再按十位排好序，以此类推
    max_num = max(li)
    it = 0
    while 10 ** it <= max_num:
        buckets = [[] for _ in range(10)]
        for var in li:  #建桶
            digit = (var // (10 ** it)) % 10
            buckets[digit].append(var)
        li.clear()
        for buc in buckets:
            li.extend(buc)
        it += 1

import random

li = list(range(100))
random.shuffle(li)
print(li)
radix_sort(li)
print(li)

三、练习题

1、给两个字符串s和t，判断t是否为s的重新排列后组成的单词.
例如，[s=“anagram”,t=“nagaram”,return true.] [s=“rat”,t=“car”,return false]

def search(s,t):
    s=sorted(s,reverse=True)
    t=sorted(t,reverse=True)
    return s==t

# def search(s,t):      #方法二
#     dict1={}
#     dict2={}
#     for ch in s:
#         dict1[ch]=dict1.get(ch,0)+1
#     for ch in t:
#         dict2[ch]=dict2.get(ch,0)+1
#     return dict1==dict2


s="rat"
t="car"
print(search(s,t))

2、给定一个m*n的二位列表，查找一个数是否存在。列表有下列特征：
每一行的列表从左到右已经排好序
每一行第一个数比上一行最后一个数大

# def searchMatrix(matrix,target):#方法一，比较慢，时间复杂度O(m*n)
#     for line in matrix:
#         if target in line:
#             return True
#     return False

def searchMatrix(matrix,target):#因为列表有序，所以选择二分查找
    h=len(matrix)   #列表的行数m
    if h ==0:
        return False #[]
    w=len(matrix[0])    #列表的列数n
    if w==0:
        return False    #[[],[],[],[]]
    left=0
    right=w*h-1
    while left<=right:
        mid=(left+right)//2
        i=mid//w
        j=mid%w #i，j为mid在列表的位置
        if matrix[i][j]==target:
            return True
        elif matrix[i][j]>target:
            right=mid-1
        else:
            left=mid+1
    else:
        return False

matrix=[[1,3,5,7],[10,11,16,20],[23,30,34,50]]
target=5
print(searchMatrix(matrix,target))

3、给定一个列表和一个整数，设计算法找到两个数的下标，使得两个数之和为给定的整数。题目保证仅有一个结果。
例如，列表[1,2,5,4]与目标整数3，有1+2=3，所以结果为(0,1)

# def towSum(li,target):  #时间复杂度O(n^2/2)
#     for i in range(len(li)):
#         for j in range(i):
#             if  li[i]+li[j]==target:
#                 return i,j

def binary_search(li, left, right, val):
    while left <= right:
        mid = (left + right) // 2
        if li[mid][0] == val:
            return mid
        elif li[mid][0] > val:
            right = mid - 1
        else:
            left = mid + 1
    else:
        return None


def towSum(li, target): #时间复杂度O(nlogn)
    new_li = [[num, i] for i, num in enumerate(li)]  # 保留原列表的值和位置
    new_li.sort(key=lambda x: x[0])  # 按列表内元组的第一个元素排列
    for i in range(len(new_li)):
        a = new_li[i][0]
        b = target - a
        if b >= a:
            j = binary_search(new_li, i + 1, len(new_li) - 1, b)
        else:
            j = binary_search(new_li, 0, i - 1, b)
        if j:
            break
    return sorted([new_li[i][1], new_li[j][1]])


li = [1,2,5,4]
target = 3
print(towSum(li, target))