算法

算法定义：

算法（Algorithm）是指解题方案的准确而完整的描述，是一系列解决问题的清晰指令，算法代表着用系统的方法描述解决问题的策略机制。也就是说，能够对一定规范的输入，在有限时间内获得所要求的输出。如果一个算法有缺陷，或不适合于某个问题，执行这个算法将不会解决这个问题。不同的算法可能用不同的时间、空间或效率来完成同样的任务。一个算法的优劣可以用空间复杂度与时间复杂度来衡量。

一个算法应该具有以下七个重要的特征：

①有穷性（Finiteness）：算法的有穷性是指算法必须能在执行有限个步骤之后终止；

②确切性(Definiteness)：算法的每一步骤必须有确切的定义；

③输入项(Input)：一个算法有0个或多个输入，以刻画运算对象的初始情况，所谓0个输     入是指算法本身定出了初始条件；

④输出项(Output)：一个算法有一个或多个输出，以反映对输入数据加工后的结果。没       有输出的算法是毫无意义的；

⑤可行性(Effectiveness)：算法中执行的任何计算步骤都是可以被分解为基本的可执行       的操作步，即每个计算步都可以在有限时间内完成（也称之为有效性）；

⑥高效性(High efficiency)：执行速度快，占用资源少；

⑦健壮性(Robustness)：对数据响应正确。

时间复杂度：

计算机科学中，算法的时间复杂度是一个函数，它定量描述了该算法的运行时间,时间复杂度常用大O符号（大O符号（Big O notation）是用于描述函数渐进行为的数学符号。更确切地说，它是用另一个（通常更简单的）函数来描述一个函数数量级的渐近上界。在数学中，它一般用来刻画被截断的无穷级数尤其是渐近级数的剩余项；在计算机科学中，它在分析算法复杂性的方面非常有用。）表述，使用这种方式时，时间复杂度可被称为是渐近的，它考察当输入值大小趋近无穷时的情况。

常用排序算法：

import random,time


#生成用于测试排序的无序列表
test_li = list(range(0,1000))
random.shuffle(test_li)
print(test_li)

#测试执行时间的装饰器
def run_time(func):
    def warpper(*args,**kwargs):
        start_time = time.time()
        res = func(*args,**kwargs)
        end_time = time.time()
        t = end_time-start_time
        print('%s----执行时间为%s'%(func.__name__,t))
        return res
    return warpper


#二分查找，明显高于遍历方法
def bin_search(data_set, val):
    low = 0
    high = len(data_set) - 1
    while low <= high:
        mid = (low + high) // 2
        if data_set[mid] == val:
            return mid
        elif data_set[mid] < val:
            low = mid + 1
        else:
            high = mid - 1
    return

#先明确此递归函数的执行流程
def func(x):
    if x == 0:
        print('我的小鲤鱼')
        return
    if x <= 3:
        print('抱着')
        func(x-1)
        print('我的')
# func(3)

#生成测试数据
def create_user(n):
    user_list = []
    ids = list(range(1,n+1))
    yi = ['赵','钱','孙','李','周','吴','郑','王']
    er = ['浩','嘉','泽','连','立','洪','亮','']
    san = ['平','晶','城','康','君','栋','贤']
    for i in range(n):
        person = {}
        id = ids[i]
        age  = random.randint(18,60)
        name = random.choice(yi)+random.choice(er)+random.choice(san)
        person['id'] = id
        person['name'] = name
        person['age'] = age
        user_list.append(person)
    print(user_list)

# userlist = create_user(100)

***************************排序算法*************************
#冒泡排序（优化版）
def bubble_sort(li):
    for i in range(len(li)-1):
        flag = False
        for j in range(0,len(li)-i-1):
            if li[j] > li[j+1]:
                li[j+1],li[j] = li[j],li[j+1]
                flag = True
        if not flag:   #如果已经有序了
            break
    print(li)
bubble_sort(test_li)



#选择排序

'''
一趟趟遍历记录最小的数，放到第一个位置
再一趟趟遍历记录最小的数，继续放置
'''
def select_sort(li):
    for i in range(0,len(li)-1):
        min_loc = i
        for j in range(i+1,len(li)):
            if li[j] < li[min_loc]:
                min_loc = j
        li[i],li[min_loc] = li[min_loc],li[i]


#插入排序（类似于摸取扑克牌进行整理的过程）
'''
列表被分为有序区与无序区，最初有序区只有一个元素，
每次从无序区选择一个元素插入到有序区中的位置，直到无序区变空
'''
def insert_sort(li):
    for i in range(1,len(li)-1):
        temp = li[i]
        j = i-1
        while j > 0 and li[j] > temp:
            li [j+1] = li[j]
            j = j-1
        li[j+1] = temp


#快速排序
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)



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