python算法笔记1

二分查找

二分查找,输入是一个有序的元素列表，如果要查找的元素包含在列表中，二分查找返回其位置，否则返回null 每次排除一半的数字，n个元素列表，最多需要log2n步 列表有序二分查找才管用 binary_search low=0,high=len(list)-1 每次检查中间的元素，mid=(low+high)/2

def binary_search(my_list,item):
    low=0
    high=len(my_list)-1
    while low<=high:
        mid=round((high+low)/2)
        guess=my_list[mid]
        if guess==item:
            return mid
        elif guess>item:
            high=mid-1
        else:
            low=mid+1
    return None
my_list=[1,2,3,4,5,6,9,10,11,23]
print(binary_search(my_list,10))

大O表示法

一般而言，应该选择效率最高的算法，以最大限度地减少运行时间或占用空间 不同算法的运行增速不同，需要知道运行时间如何随列表的增长而增长 ###算法运行时间----大O表示法 指出了算法运行时间的增速，O(n),O(log n)，O(n*log n),O(n^2),O(n!) 大O表示法：O(n),n指代操作数，说的是最糟糕的情形
小结：
1、算法的速度指的并非是时间，而是操作数的增速
2、谈论算法的速度时，说的是随着输入的增加，其运行时间将以什么样的速度增加
3、算法的运行时间用大O表示法表示

选择排序

数组和链表优缺点
数组,在内存上给出了连续的空间.链表,内存地址上可以是不连续的

1、链表的优势：每个链表的节点包括原来的内存和下一个节点的信息(单向的一个,双向链表的话,会有两个)
链表中添加元素很容易，只需将其放入内存，并将其地址存到前一个元素中
劣势：跳跃读取链表元素，效率很低。在链表中元素并非靠在一起，必须从第一个开始访问
2、数组的优势：需要随机读取元素时数组的效率很高，因为可以迅速找到数组中的任意元素。从0开始对数组元素进行编号，元素的位置叫做索引
劣势：需要连续内存，牵一发而动全身，不能随意添加元素

运行时间：数组：读取O(1),插入O(n)
链表：读取O(n),插入O(1)

#从小到大排序
def findsmallest(arr):
    smallest=arr[0]
    smallest_index=0
    for i in range(1,len(arr)):
        if smallest>arr[i]:
            smallest=arr[i]
            smallest_index=i
    return smallest_index
def sort(arr):
    new_arr=[]
    for i in range(len(arr)):
        smallest=findsmallest(arr)
        new_arr.append(arr.pop(smallest))
    return new_arr
arr=[1,45,89,6,3,4,5,2,3]
sort(arr)

运行时间为O（n^2）

递归——一种优雅的问题解决方法

递归函数就是直接或间接调用自身的函数。每个递归函数由两部分组成：基线条件和 递归条件。递归函数指的是函数调用自己，而基线条件则指的是函数不再调用自己，从而避免实现无限循环。
分而治之（divide and conquer,D&C）
步骤：
（1）找出基线条件，这种条件必须尽可能简单
（2）不断将问题分解（缩小规模），直到符合基线条件。

快速排序

步骤：
（1）选择基准值
（2）将数组分成两个子数组：小于基准值的元素和大于基准值的元素
（3）对这两个子数组进行快速排序

def quicksort(array):
    if len(array)<2:
        return array
    else:
        pivot=array[0]
        less=[i for i in array[1:] if i<=pivot]
        greater=[i for i in array[1:] if i>pivot]
        return quicksort(less)+[pivot]+quicksort(greater)

快速排序的独特之处在于，其速度取决于选择的基准值。下图是常见的大O运行时间。

大O表示法中的常量有时候事关重大，这就是快速排序比合并排序快的原因。比较简单查找和二分查找的时候，常量几乎无关紧要，因为列表很长时，O(log n)的速度比O（n）快得多。

散列表

1、散列函数：将输入映射到数字
散列函数总是将同样的输入映射到相同的索引。
散列函数将不同的输入映射到不同的索引。
散列函数知道数组有多大，只返回有效的索引。
2、散列表（hash table）
散列表使用散列函数来确定元素的存储位置。也被称为散列映射、映射、字典和关联数组。Python提供的散列表表现为字典，可使用函数dict来创建散列表。散列表由键和值组成，将键映射到值。
创建散列表的快捷方式：{}
DNS解析：将网址映射到IP地址
缓存是一种常见的加速方式，所有大型网站都是用缓存，而缓存的数据则存储在散列表中。页面URL映射到页面数据。

cache={}
def get_page(url):
    if cache.get(url):
        return cache[url]
    else:
        data=get_data_from_server(url)
        cache[url]=data
        return data

散列表小结：

模拟映射关系
防止重复
缓存/记住数据，以免服务器再通过处理生成他们

哈希表是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。O(1)

冲突（collision）：给两个键分配的位置相同
解决方法：在这个位置存储一个链表；选择好的散列函数