python算法练习

6.

约瑟夫环问题：已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到k的那个人被杀掉；他的下一个人又从1开始报数，数到k的那个人又被杀掉；依此规律重复下去，直到圆桌周围的人只剩最后一个。

def get_live(lens=, k=):
    """k is step"""
    flag =
    if k == :
        return lens
    else:
        people = [ x for x in range(, (lens +  )) ]
        print(people)
        while True:
            if flag == :
                mod = k  % lens #deal with step > len(people)
                flag = k
            #print(people)
            if mod == :
                mod = lens
            people.pop(mod-)
            lens = lens -
            if lens == :
                break
            flag = (flag + k -  ) % lens

            mod = flag
            print(people)

5. 生成140个随机数，在1到100范围内，然后统计重复的数字：

 def gen_random_numbers(min=0, max=100, numbers=40):
     """随机生成N个随机数"""
     i = 0
     li_random = []
     li = [ random.randint(min,max) for x in range(0, numbers)]
     return li

 def get_de(l):
     """显示l里面重复过的元素"""
     set_ = set()
     for i in l:
         temp = l.pop(l.index(i))
         if temp in l:
             set_.add(temp)
     return set_

 def get_repeat(list_count):
     """获取list里面重复的元素和次数"""
     set_nums = set(list_count)
     print('!',set_nums)
     dict_re = {}
     for i in set_nums:
         count = list_count.count(i)
         print('count {} > {}'.format(i,count))
         if count >1:
             dict_re[i] = count
     return dict_re

 if __name__ == '__main__':

4. 快速排序：

一般选取low为第一次的基准值，先从右边往左边找，找到小于基准值的值，j停下，否则一直j -= 1,  然后从左往右找，找到大于基准值的值，i停下，此时交换i,j的位置的list中的值，然后继续寻找， 继续交换值，左边的都是比基准值小的，右边都是比基准值大的，知道当i==j值，交换基准值于list[i]的值，一轮查找结束/////////////第二轮的时候，基准值的左边和右边，分为两队，直接递归就行了，

def q_sort(listB, low, high):
    i = low
    j = high
    if i> j:
        return listB
    pov = listB[low]
    while i<j:
        while i<j and listB[i] <= listB[j]:
            j -= 1
        while i<j and listB[i] <= listB[j]:
            i += 1
        if i<j:
            listB[i], listB[j] = listB[j], listB[i]
        elif i == j:
            listB[low], listB[i] = listB[i], listB[low]

    q_sort(listB,low, i-1)
    q_sort(listB,j+1,high)
    return listB

3. 选择排序：

选择排序原理即：在选择排序中，不再只比较两个相邻的数据。因此需要记录下某一个数据的下标，进行选择排序就是把所有的数据扫描一遍，从中挑出（按从小到大排序）最小的一个数据，这个最小的数据和最左端下标为0的数据交换位置。之后再次扫描数据，从下标为1开始，还是挑出最小的然后和1号位置进行交换，这个过程一直持续到所有的数据都排定。而程序中需要有一个标识变量来标识每次挑出最小数据的下标。

选择排序减少了交换数值的次数，只记录下标，最后交换最小的下标。

选择排序改进了冒泡排序，将必要的交换次数从 O（N2）减少到 O（N）次。不幸的是比较次数仍然保持为 O（N2）。然而，选择排序仍然为大记录量的排序提出了一个非常重要的改进，因为这些大量的记录需要在内存中移动，这就使交换的时间和比较的时间相比起来，交换的时间更为重要

listA = [1123,11,3,1,222,33,76,1,12345]

def select_sort(li):
    for i in range(0, len(li)):
        flag = i
        for j in range(i+1, len(li)):
            if li[i] > li[j]:
                flag = j
        li[i], li[flag] = li[flag], li[i]

    print(li)

if __name__ == '__main__':
    select_sort(listA)

2. 冒泡排序：

linum = [88,77,44,55,9,111,222,777,55,3,22]

def bubu_order(unsorted):
    for i in range(0, len(unsorted)):
        for j in range(0, len(unsorted)-1):
            if unsorted[j] > unsorted[j]:
                unsorted[j],unsorted[j+1] = unsorted[j+1],unsorted[j]
    return unsorted

if __name__ == '__main__':
    print(bubu_order(linum))

for i in list2:

i =33

//这样是不能修改list本身的~~~

//获取对应值的index:

listA.index('33')

//另外一种获取list序号的方法：

for i,j in enumerate(listA):

print(i,j)

//str转list

str1.split(）

//list转str

' '.join(listA)

1. 插入排序：

　　插入排序默认第一个为已经排好顺序的列表，后面的每一个都与之比较并排序，排好之后，所有的自然都已经排好， 第二种优化的算法，如果已经插入， 说明找对了位置，那么下面就break，如果不需要排序， 那么就说明已经是最大的了， 因为前面的已经排好了，排好之后，也不需要再排了，可以break了。

import time

start = lambda : time.time()
list1 = [66,33,1,3,111,3,10,29,7,123,56,23] * 50

def busorted(unsorted):
    l = len(unsorted)
    for i in range(0,l):
        key = unsorted[i]
        for x in range(i,0,-1):
            if unsorted[x] < unsorted[x-1]:
                unsorted[x], unsorted[x-1] = unsorted[x-1], unsorted[x]
    return unsorted

def optimizesorted(unsorted):
    l = len(unsorted)
    for i in range(0,l):
        key = unsorted[i]
        for x in range(i,0,-1):
            if unsorted[x] < unsorted[x-1]:
                unsorted[x], unsorted[x-1] = unsorted[x-1], unsorted[x]
            else :
                break
    return unsorted

if __name__ == '__main__':
    print(list1)
    t1 = start()
    print(busorted(list1))
    t2 = start()
    print('-----------Time is {}'.format(t2-t1))