算法 常用

二分法

# 二分法
# 时间复杂度O(logN)
'''
思路:
先取得该列表的索引中间值mid,如len(li)==0,则没有这个值
判断如li[mid]>最终值,则后再在递归调用前半部分,
判断如li[mid]<最终值,则后再在递归调用后半部分,如li[mid]=最终值,就找到结果.
'''
def binarysearch(li,value):
        if len(li)==0:
            print('not got it')
            return
        mid = len(li) // 2
        if li[mid] == value:
            print('got it')
            return mid
        elif li[mid] > value:
            binarysearch(li[:mid], value)
        elif li[mid] < value:
            binarysearch(li[mid+1:], value)

binarysearch(li, value)

　　

快速排序

'''
#快速排序
   好写的排序算法里最快的
   快的排序算法里最好写的
快排思路：
取一个元素p（第一个元素），使元素p归位；
列表被p分成两部分，左边都比p小，右边都比p大；
递归完成排序。

详细思路:
归位第一个值,归位值的前半段和后半段进行排序
归位:
    最左边的值定义tmp
    如左边的索引大于右边,且最右边的值大于等于tmp,最右的索引-1.最左边的值赋值给最右边
    如左边的索引大于右边,且最右边的值小于等于tmp,最左的索引+1.最右边的值赋值给最左边
    如左边的索引非大于右边,那temp就还是最左边的值
    返回最左边值的索引


'''
### O(n)
def partition(li, left, right):
    tmp = li[left]
    while left < right:
        while left < right and li[right] >= tmp:
            right = right - 1
        li[left] = li[right]
        while left < right and li[left] <= tmp:
            left = left + 1
        li[right] = li[left]
    li[left] = tmp
    return left

## 时间复杂度: O(nlogn)
def _quickSort(li, left, right):
    if left < right:
        mid = partition(li, left, right) ### O(n)
        _quickSort(li, left, mid - 1)   ### O(logn)
        _quickSort(li, mid + 1, right)
@caltime
def quickSort(li, left, right):
    _quickSort(li, left, right)

　　

计数排序

现在有一个列表，列表中的数范围都在0到100之间，列表长度大约为100万。设计算法在O(n)时间复杂度内将列表进行排序。

'''
计数排序:创建一个列表，用来统计每个数出现的次数。

思路:
count定义循环列出1到10的数(按需求),如果li中有值在count中,定义count[index]计数+1
清空li
枚举count,把计算添加进li

'''
def countSort(li):
    count = [0 for i in range(11)]

    for index in li:
        count[index] += 1

    li.clear()

    for index, val in enumerate(count):
        print(index, val)
        for i in range(val):
            li.append(index)


li = [10,4,6,3,8,4,5,7]
countSort(li)
print(li)

li = [random.randint(1,100) for _  in range(10000)]
BubbleSort(li)

li = [random.randint(1,100) for _  in range(10000)]
selectSort(li)

li = [random.randint(1,100) for _  in range(10000)]
insertSort(li)

li = [random.randint(1,100) for _  in range(100000)]
print(li)
quickSort(li, 0, len(li)-1)
print(li)

现在有n个数（n>10000），设计算法，按大小顺序得到前10大的数。

 

'''
现在有n个数（n>10000），设计算法，按大小顺序得到前10大的数。

应用场景：榜单TOP 10

解析：
　　　　因为只要最大的十个数，所以没有必要将整个数据进行排序，因为剩下的数据是否有序不影响结果。
　　　　所以可以新建一个数量为10的数组，并将这个数组进行排序，使其有序。
　　　　然后从第11位开始取数据，拿取到的数据和十位的列表中的最小的那个做比较，如果不够大就继续循环取数，如果比最小的数大，就把取出的数据覆盖掉最小的数，并再对十位的数组排序。直至数据取完，十位数组里面储存的就是最大的十个数字。
　　　　按照这个思路可以用插入排序或者堆排序实现，下面用的是插入排序。
'''

# 将一个数组按照左大右小顺序排好
def inser_sort(list):
    for i in range(1, len(list)):
        tem = list[i]
        j = i - 1
        while j >= 0 and list[j] < tem:
            list[j + 1] = list[j]
            j = j - 1
        list[j + 1] = tem

def topk(li, k):
    list = li[0:k]  # 创建一个长度为k的数组来储存最大的k个数
    inser_sort(list)  # 将这个K数组先按照大小顺序用插入偶排序排好
    print(list)
    print(list[-1])

    for i in range(k, len(li)):  # 将剩下的数字依次拿到
        # 将拿到的数字和数组中最小的数字做对比
        if li[i] > list[-1]:  # 如果比最小的数字大，就做交换，把最小的数字换成取到的数
            list[-1] = li[i]
            # 交换之后进行排序
            inser_sort(list)
    print(list)

　　

 给定一个列表和一个整数,找到两个数的下标,使得这两个数的各为给定的整数,保证肯定仅有一个结果

 

'''
算法例子一:
给定一个列表和一个整数,找到两个数的下标,
使得这两个数的各为给定的整数,保证肯定仅有一个结果
'''
# 穷举法:
def brute_force(li,target):
    n=len(li)

    for i in range(0,n):
        for j in range(i+1,n):
            if li[i]+li[j]==target:
                return i,j
# 二分查找法:
def bin_search(li, val):
    low = 0
    high = len(li) - 1

    while low <= high:
        mid = (low + high) // 2
        if li[mid] == val:
            return mid
        elif li[mid] > val:
            high = mid - 1
        else:
            low = mid + 1
    return None

def search_index(li, target):
    li.sort()

    for i in range(0, len(li)):
        j=bin_search(li[i + 1:], target - li[i])
        if j:
            return i,j
'''
方法三
先给列表排序,然后循环遍历列表,如果列表第一个数与列表最后一个数相加的和大于target,把被加数向左偏移一位,

如果列表第一个数与列表最后一个数相加的和小于target,把加数向右偏移一位

如果列表中两个数相加等于target,则返回列表中的两个数的下标
'''
def search_index(li,target):
    li.sort()

    j=len(li)-1

    for i in range(j):
        if li[i] + li[j] < target:
            i += 1
        elif li[i] + li[j] > target:
            j -=1
        else:
            return i,j

　　

给定一个升序列表和一个整数,返回该整数在列表中的下标范围

'''
算法例子二:给定一个升序列表和一个整数,返回该整数在列表中的下标范围
思路:先使用二分法找到val在列表中的下标,然后把下标分别向左和向中移动,直到下标的值不等于目标整数时返回下标的元组
'''
def bin_search(li,val):
    low=0
    high=len(li)-1

    while low <= high:
        mid=(low + high) // 2

        if li[mid] == val:
            return mid
        elif li[mid] > val:
            high = mid -1
        else:
            low=mid + 1

    return None

def search_index(li,val):
    i=0
    j=0

    mid=bin_search(li,val)
    i=mid-1
    j=mid + 1

    while li[i] ==val:
        i -= 1

    while li[j] == val:
        j += 1

    return (i+1,j-1)

　　

two_sum求两数之和

# two_sum求两数之和
# 给定一个列表和一个整数,设计算法找到两个数的下标,使得两个数之和为给定的整数,保证肯定仅有一个结果.
# 例:列表li=[0, 1, 2, 3, 4, 5, 6]与目标整数6,结果为{0: 6, 1: 5, 2: 4, 3: 3}.
li = [0, 1, 2, 3, 4, 5, 6]

# 解法1:
def two_sum_1(li, target):
    for i in range(len(li)):
        for j in range(i + 1, len(li)):
            if li[i] + li[j] == target:
                return i, j
print(two_sum_1(li, 6))

# 解法2
def two_sum_2(li, target):
    d = {}
    for i in range(len(li)):
        b = target - li[i]
        if b in d:
            return d[b], i
        else:
            d[li[i]] = i
print(two_sum_2(li, 6))

# 解法3
# 结合二分查找法,可以找到所有的可能组合.
# 缺点:提供的列表必须是有序的,否则这个办法没有作用.
class Solution:
    # 二分查找法
    def binary_search(self, li, val, start, end):
        while start <= end:
            mid = (start + end) // 2
            if li[mid] < val:
                start = mid + 1
            elif li[mid] > val:
                end = mid - 1
            else:
                return mid
        else:
            return None

    # 给定一个列表和一个整数,设计算法找到两个数的下标,使得两个数之和为给定的整数.
    def two_sum3(self, li, target):
        dic = {}
        for i in range(len(li)):
            a = li[i]
            b = target - a
            # 写0时,{0: 6, 1: 5, 2: 4, 3: 3, 4: 2, 5: 1, 6: 0}
            # 写i时,{0: 6, 1: 5, 2: 4, 3: 3}
            # 写i+1时,{0: 6, 1: 5, 2: 4}
            res = self.binary_search(li, b, i, len(li) - 1)
            if res != None:
                dic[i] = res
        return dic

# 实例化对象
s = Solution()
# 调用类方法
print(s.two_sum3(li, 6))