python简单算法整理

冒泡排序

def func(alist):
    for x in range(1,len(alist)):
        for i in range(0,len(alist)-x):
            if alist[i] > alist[i+1]:
                alist[i], alist[i+1] = alist[i+1], alist[i]
    return alist
print(func([1,4,2,3,6,7,8,9,0,5]))

选择排序

def func(alist):
    for x in range(0,len(alist)):
        min_num = alist[x]
        for i in range(x+1,len(alist)):
            if alist[i] < min_num:
                alist[i], min_num = min_num, alist[i]
        alist[x] = min_num
    return alist
print(func([1,4,2,3,6,7,8,9,0,5]))

斐波那契

def func(n):
    a = 0
    b = 1
    alist = []
    if n <= 2:
        alist.append(a)
        alist.append(b)
        return alist
    else:
        for i in range(n):
            alist.append(a)
            a, b = b, a + b
        return alist

print(func(9))

二分法

def func(alist, item):
    low = 0
    high = len(alist)-1
    n = 0
    while low <= high:
        mid = int((low + high)/2)
        n += 1
        if alist[mid]==item:
            return mid
        if alist[mid]<item:
            low = mid + 1
        else:
            high = (mid-1)
    return None

m=[1,2,3,4,8,9,11,12,14,18,19,20,28]
print(func(m,14))

链表

class Node:
    def __init__(self, initdata):
        self.__data = initdata
        self.__next = None

    def getData(self):
        return self.__data

    def getNext(self):
        return self.__next

    def setData(self, newdata):
        self.__data = newdata

    def setNext(self, newnext):
        self.__next = newnext

class SinCycLinkedlist:
    def __init__(self):
        self.head = Node(None)
        self.head.setNext(self.head)

    def add(self, item):
        temp = Node(item)
        temp.setNext(self.head.getNext())
        self.head.setNext(temp)

    def remove(self, item):
        prev = self.head
        while prev.getNext() != self.head:
            cur = prev.getNext()
            if cur.getData() == item:
                prev.setNext(cur.getNext())
            prev = prev.getNext()

    def search(self, item):
        cur = self.head.getNext()
        while cur != self.head:
            if cur.getData() == item:
                return True
            cur = cur.getNext()

        return False

    def empty(self):
        return self.head.getNext() == self.head

    def size(self):
        count = 0
        cur = self.head.getNext()
        while cur != self.head:
            count += 1
            cur = cur.getNext()

        return count

if __name__ == '__main__':
    s = SinCycLinkedlist()
    print('s.empty() == %s, s.size() == %s' % (s.empty(), s.size()))

    s.add(19)
    s.add(86)
    print('s.empty() == %s, s.size() == %s' % (s.empty(), s.size()))

    print('86 is%s in s' % ('' if s.search(86) else ' not',))
    print('4 is%s in s' % ('' if s.search(4) else ' not',))
    print('s.empty() == %s, s.size() == %s' % (s.empty(), s.size()))

    s.remove(19)
    print('s.empty() == %s, s.size() == %s' % (s.empty(), s.size()))

青蛙跳台阶

一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

fib = lambda n: n if n < 2 else 2 * fib(n - 1)

计数排序

题目1:现在有一个列表，列表中的数范围都在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)


题目2:现在有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)



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

'''
算法例子一:
给定一个列表和一个整数,找到两个数的下标,
使得这两个数的各为给定的整数,保证肯定仅有一个结果
'''
# 穷举法:
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


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

'''
算法例子二:给定一个升序列表和一个整数,返回该整数在列表中的下标范围
思路:先使用二分法找到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)




题目5: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))

快排

#! /usr/bin/env python
# -*- coding: utf-8 -*-
def quick(list):
    if len(list) < 2:
        return list

    tmp = list[0]  # 临时变量 可以取随机值
    left = [x for x in list[1:] if x <= tmp]  # 左列表
    right = [x for x in list[1:] if x > tmp]  # 右列表
    return quick(left) + [tmp] + quick(right)

li = [4,3,7,5,8,2]
print quick(li)  # [2, 3, 4, 5, 7, 8]

#### 对[4,3,7,5,8,2]排序
'''
[3, 2] + [4] + [7, 5, 8]                 # tmp = [4]
[2] + [3] + [4] + [7, 5, 8]              # tmp = [3] 此时对[3, 2]这个列表进行排序
[2] + [3] + [4] + [5] + [7] + [8]        # tmp = [7] 此时对[7, 5, 8]这个列表进行排序
'''