算法

递归

#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author: JianBao Yu

#递归使用
# def xiaoliyu(depth):
#     if depth == 0:
#         print('我的小鲤鱼',end='')
#     else:
#         print('抱着',end='')
#         xiaoliyu(depth-1)
#         print('的我',end='')
#
# xiaoliyu(4)


import random
#二分查找
def gene_person(n):
    ids = list(range(1,n+1))
    yi = ['赵','钱','孙','李',]
    er = ['立','大','杰','',]
    san = ['军','春','伟','国',]

    for i in range(n):
        id = ids[i]
        age = random.randint(18,60)
        name = random.choice(yi)+random.choice(er)+random.choice(san)
        print(name)

gene_person(10)

二分查找

#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author: JianBao Yu

import time
import random

def cal_time(func):
    def wrapper(*args,**kwargs):
        t1 = time.time()
        result = func(*args,**kwargs)
        t2 = time.time()
        print("%s running time: %s secs." % (func.__name__,t2-t1))
        return result
    return wrapper

#二分查找针对有序数组查找
@cal_time
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


data = list(range(1000000))
print(bin_search(data,15544))

排序

#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author: JianBao Yu

import random
import time
import copy
import sys

def cal_time(func):
    def wrapper(*args,**kwargs):
        t1 = time.time()
        result = func(*args,**kwargs)
        t2 = time.time()
        print('%s running time: %s secs' % (func.__name__,t2-t1))
        return result
    return wrapper

#冒泡排序
@cal_time
def bubble_sort(li):
    for i in range(len(li)-1):
        for j in range(len(li)- i -1):
            if li[j] > li[j+1]:
                li[j],li[j+1]=li[j+1],li[j]

#冒泡排序优化版
@cal_time
def bubble_sort_l(li):
    for i in range(len(li)-1):
        exchange = False
        for j in range(len(li)- i -1):
            if li[j] > li[j+1]:
                li[j],li[j+1]=li[j+1],li[j]
                exchange = True
        if not exchange:
            break

#选择排序,寻找索引进行排序
@cal_time
def select_sort(li):
    for i in range(len(li) -1):
        min_loc = 1
        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]

#插入排序,找到应该去的地方，j是手里的牌，i是每次抓的牌，j是有序区，i是无序区、左边小右边大
@cal_time
def insert_sort(li):
    for i in range(1,len(li)):
        tmp = li[i]
        j = i -1
        while j >= 0 and li[j] > tmp:
            li[j+1]=li[j]
            j = j -1
        li[j+1] = tmp

#快速排序，找到一个元素，使得它左边的元素都比它小，右边的元素都比它大，归位
def quick_sort_x(data,left,right):
    if left < right:
        mid = partition(data,left,right)
        quick_sort_x(data,left,mid-1)
        quick_sort_x(data,mid+1,right)

def partition(data,left,right):
    tmp = data[left]
    while left < right:
        while left < right and data[right] >= tmp:
            right -= 1
        data[left] = data[right]
        while left < right and data[left] <= tmp:
            left += 1
        data[right] = data[left]
    data[left] = tmp
    return left

@cal_time
def quick_sort(data):
    quick_sort_x(data,0,len(data) - 1)


#堆排序，调整
def sift(data,low,high):
    i = low
    j = 2 * i + 1
    tmp = data[i]
    while j <= high:  #只要没到子树的最后,孩子在堆里
        if j < high and data[j] < data[j+1]:         #如果有右孩子且比左孩子大
            j += 1   #j指向右孩子
        if tmp < data[j]:   #如果领导不能干，孩子比最高领导大
            data[i] = data[j]   #孩子填到父亲的空位上
            i = j               #孩子成为新父亲
            j = 2 * i +1         #新孩子
        else:
            break
    data[i] = tmp                #最高领导放到父亲位置


@cal_time
def heap_sort(data):
    n = len(data)
    for i in range(n // 2 -1,-1,-1):
        sift(data,i,n-1)
    #堆建好了
    for i in range(n-1,-1,-1):            #i指向堆的最后
        data[0],data[i] = data[i],data[0]  #领导退休，孩子上位
        sift(data,0,i-1)                    #调整出新领导



#归并排序
# @cal_time
def merge(li,low,mid,high):
    i = low
    j = mid + 1
    ltmp = []
    while i <= mid and j <= high:
        if li[i] < li[j]:
            ltmp.append(li[i])
            i += 1
        else:
            ltmp.append(li[j])
    while i <= mid:
        ltmp.append(li[i])
        i += 1
    while j <= high:
        ltmp.append(li[j])
        j += 1
    li[low:high+1] = ltmp



def _mergesort(li,low,high):
    if low < high:
        mid = (low + high) // 2
        _mergesort(li,low,mid)
        _mergesort(li,mid+1,high)
        merge(li,low,mid,high)

@cal_time
def mergesort(li):
    _mergesort(li,0,len(li)-1)






sys.setrecursionlimit(10000)
data = list(range(1000,1,-1))
# data.sort()
random.shuffle(data)
data1 = copy.deepcopy(data)
data2 = copy.deepcopy(data)
data3 = copy.deepcopy(data)
data4 = copy.deepcopy(data)
data5 = copy.deepcopy(data)
data6 = copy.deepcopy(data)

bubble_sort(data1)
select_sort(data2)
insert_sort(data3)
quick_sort(data4)
heap_sort(data5)
mergesort(data6)

#希尔排序
@cal_time
def shell_sort(li):
    gap = int(len(li) // 2)
    while gap >= 1:
        for i in range(gap, len(li)):
            tmp = li[i]
            j = i - gap
            while j >= 0 and tmp < li[j]:
                li[j + gap] = li[j]
                j -= gap
            li[i - gap] = tmp
        gap = gap // 2

约瑟夫问题

#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author: JianBao Yu

#__author__ = 'Administrator'

n = 9999
m = 1200

#约瑟夫问题列表解决方式
def Yuesefu(n, m):
    people = [i for i in range(1, n+1)]
    x = 0
    while len(people)>0:
        dead_location = (x + (m-1))%len(people)
        yield people.pop(dead_location)
        x = dead_location

print(list(Yuesefu(n, m)))

class LinkList:
    """链表 头结点保存链表的长度"""
    class Node:
        def __init__(self, item=None):
            self.item = item
            self.next = None

    class LinkListIterator:
        def __init__(self, node):
            self.node = node
        def __next__(self):
            if self.node:
                cur_node = self.node
                self.node = cur_node.next
                return cur_node.item
            else:
                raise StopIteration
        def __iter__(self):
            return self

    def __init__(self, iterable=None):
        self.head = LinkList.Node(0)
        self.tail = self.head
        self.extend(iterable)

    def append(self, obj):
        s = LinkList.Node(obj)
        self.tail.next = s
        self.tail = s

    def extend(self, iterable):
        for obj in iterable:
            self.append(obj)
        self.head.item += len(iterable)

    def remove_nth_node(self, node, m):
        for i in range(m - 2):
            node = node.next
        p = node.next
        node.next = p.next
        self.head.item -= 1
        return p

    def __iter__(self):
        return self.LinkListIterator(self.head.next)

    def __len__(self):
        return self.head.item

    def __str__(self):
        return "<<" + ", ".join(map(str,self)) + ">>"

#约瑟夫问题链表解决方案
def yuesefu_link(n, m):
    people = LinkList([i for i in range(1, n+1)])
    people.tail.next = people.head.next
    x = people.head.next
    while len(people)>0:
        p = people.remove_nth_node(x, m)
        x = p.next
        yield p.item

print(list(yuesefu_link(n, m)))