面试会问到的基本算法

一、斐波那契数列

　　1、方法一：基本运算

def foo():
    a = 0
    b = 1
    c = []
    for i in range(10):
        c.append(a)
        a, b = b, a+b
    return c
print(foo())

　　2、方法二：列表

def foo():
    c = [0, 1]
    for i in range(8):
        c.append(c[-2]+c[-1])
    return c
print(foo())

　　3、方法三：递归

def foo(n):
    if n == 0:
        return 0
    elif n <= 2:
        return 1
    else:
        return (foo(n-1)+foo(n-2))

for i in range(10):
    foo(i)
    print(foo(i))

二、递归

　　1、求阶乘：（求一个数的阶乘）

def fact(n):
    if n == 1:
        return 1
    return n * fact(n - 1)

print(fact(4))

　　2、求和：（1-100）

def foo(n):
    if n == 1:
        return 1
    else:
        return n+foo(n-1)
    
print(foo(100))

三、闭包

　　1、概念

首先还得从基本概念说起，什么是闭包呢？来看下维基上的解释:

在计算机科学中，闭包（Closure）是词法闭包（Lexical Closure）的简称，是引用了自由变量的函数。这个被引用的自由变量将和这个函数一同存在，即使已经离开了创造它的环境也不例外。所以，有另一种说法认为闭包是由函数和与其相关的引用环境组合而成的实体。闭包在运行时可以有多个实例，不同的引用环境和相同的函数组合可以产生不同的实例。
....

上面提到了两个关键的地方： 自由变量 和 函数, 这两个关键稍后再说。还是得在赘述下“闭包”的意思，望文知意，可以形象的把它理解为一个封闭的包裹，这个包裹就是一个函数，当然还有函数内部对应的逻辑，包裹里面的东西就是自由变量，自由变量可以在随着包裹到处游荡。当然还得有个前提，这个包裹是被创建出来的。

在通过Python的语言介绍一下，一个闭包就是你调用了一个函数A，这个函数A返回了一个函数B给你。这个返回的函数B就叫做闭包。你在调用函数A的时候传递的参数就是自由变量。

　　2、闭包的执行

>>> def func(name):
...     def inner_func(age):
...         print(name,age)
...     return inner_func
...
>>> bb = func("zhangyu")
>>> bb(26)
zhangyu 26

这里面调用func的时候就产生了一个闭包——inner_func,并且该闭包持有自由变量——name，因此这也意味着，当函数func的生命周期结束之后，name这个变量依然存在，因为它被闭包引用了，所以不会被回收。

另外再说一点，闭包并不是Python中特有的概念，所有把函数做为一等公民的语言均有闭包的概念。不过像Java这样以class为一等公民的语言中也可以使用闭包，只是它得用类或接口来实现。

　　3、为什么要使用闭包

基于上面的介绍，不知道读者有没有感觉这个东西和类有点相似，相似点在于他们都提供了对数据的封装。不同的是闭包本身就是个方法。和类一样，我们在 编程时经常会把通用的东西抽象成类，（当然，还有对现实世界——业务的建模），以复用通用的功能。闭包也是一样，当我们需要函数粒度的抽象时，闭包就是一 个很好的选择。

在这点上闭包可以被理解为一个只读的对象，你可以给他传递一个属性，但它只能提供给你一个执行的接口。因此在程序中我们经常需要这样的一个函数对象——闭包，来帮我们完成一个通用的功能，比如后面会提到的——装饰器。

　　4、使用闭包

　　　　4.1 装饰器

def decorator_func(foo):
    def wrapper(*args, **kwargs):
        print("myname:")
        return func(*args, **kwargs)
    return wrapper

@decorator_func
def func(name):
    print(name)

func('zhangyu')
#####结果#####

  myname:
  zhangyu

 四、求100以内的质数

　　1、根据质数的概念去求：

def foo(n):

    a = []
    for i in range(2, n):
        count = 0
        for j in range(1, i+1):
            if i % j == 0:
                count += 1
        if count == 2:
            a.append(i)
    return a
print(foo(100))

 五、二分查找算法

 六、排序

　　1、冒泡排序

def foo():
    a = [10, 8, 23, 6, 53, 3, 16]
    l = len(a)
    for i in range(l-1):   #需要冒泡n-1次
        for j in range(l-1-i): # 已经就位的大数字，不用再比较
            if a[j] > a[j+1]:
                b = a[j]
                a[j] = a[j+1]
                a[j+1] = b

    return a 

print(foo())
####结果#####
[3, 6, 8, 10, 16, 23, 53]

　　2、选择排序

def foo():
    a = [10, 8, 23, 6, 53, 3, 16]
    l = len(a)
    for i in range(l-1):        # 总共比循环比较n-1次
        for j in range(i+1, l): 
            if a[i] > a[j]:　　　# 将i与j比较，并互换位置　
                b = a[i]
                a[i] = a[j]
                a[j] = b
    return a

print(foo())

　　3、插入排序

def insert_sort():

    l = [4, 1, 9, 13, 34, 26, 10, 7, 4]
    for i in range(len(l)):
        min_index = i
        for j in range(i+1, len(l)):
            if l[min_index] > l[j]:
                min_index = j
        tmp = l[i]
        l[i] = l[min_index]
        l[min_index] = tmp
        print(str(l))
    print("result: " + str(l))

insert_sort()
print("insert_sort success!!!")

#其他常见技术戳 ……………

http://3060674.blog.51cto.com/3050674/1791342

来源：http://3060674.blog.51cto.com