python算法练习
6.
约瑟夫环问题：已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到k的那个人被杀掉；他的下一个人又从1开始报数，数到k的那个人又被杀掉；依此规律重复下去，直到圆桌周围的人只剩最后一个。
def get_live(lens=10, k=1): """k is step""" flag = 0 if k == 1: return lens else: people = [ x for x in range(1, (lens + 1 )) ] print(people) while True: if flag == 0: mod = k % lens #deal with step > len(people) flag = k #print(people) if mod == 0: mod = lens people.pop(mod-1) lens = lens -1 if lens == 0: break flag = (flag + k - 1 ) % lens mod = flag print(people)
5. 生成140个随机数，在1到100范围内，然后统计重复的数字：
1 def gen_random_numbers(min=0, max=100, numbers=40): 2 """随机生成N个随机数""" 3 i = 0 4 li_random = [] 5 li = [ random.randint(min,max) for x in range(0, numbers)] 6 return li 7 8 def get_de(l): 9 """显示l里面重复过的元素""" 10 set_ = set() 11 for i in l: 12 temp = l.pop(l.index(i)) 13 if temp in l: 14 set_.add(temp) 15 return set_ 16 17 def get_repeat(list_count): 18 """获取list里面重复的元素和次数""" 19 set_nums = set(list_count) 20 print('!',set_nums) 21 dict_re = {} 22 for i in set_nums: 23 count = list_count.count(i) 24 print('count {} > {}'.format(i,count)) 25 if count >1: 26 dict_re[i] = count 27 return dict_re 28 29 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))
