1、二分查找：主要用于查询元素数量较多的列表，采用二分查找，取中位值，进行大小比较，可以提高效率
1 #二分查找，用于在较大的数据列表中查询某个值，考虑到元素比较多，单纯的遍历会造成内存压力过大，考虑使用二分查找 2 #二分查找的关键在于查询中间值，将需要查找的值与中间值进行比较，然后确定查找方向 3 def binary_search(data_source,find_n): 4 #取中位数 5 mid=int(len(data_source)/2) 6 7 if len(data_source)>=1: 8 if data_source[mid]>find_n: #中位数大于要查找的数，则要查找的数在左半部分，继续调用二分算法进行查找 9 binary_search(data_source[:mid],find_n) 10 elif data_source[mid]<find_n: #中位数小于要查找的数，则要查找的数在右半部分 11 binary_search(data_source[mid:],find_n) 12 else: #中位数等于要查找的数 13 print("找到了：",data_source[mid]) 14 15 else: 16 print("没有找到") 17 18 19 if __name__=="__main__": 20 data=list(range(1,100000)) 21 binary_search(data,88888)
2、生成一个5*5的2维数组，并按顺时针方向旋转90度
1 #算法基础：生成一个4*4的2维数组并将其顺时针旋转90度 2 3 array=[[col for col in range(5)]for row in range(5)] #初始化一个4X4的数组 4 #输出数组，查看数组旋转前其格式 5 for row in array: 6 print(row) 7 ''' 分析 8 数组旋转前 9 [0, 1, 2, 3] 10 [0, 1, 2, 3] 11 [0, 1, 2, 3] 12 [0, 1, 2, 3] 13 ''' 14 ''' 15 数组旋转后,顺时针旋转90度,由上下图对比可知，每次只需将第一行的元素和第一列的元素位置互换 16 即形成部分旋转，以此类推循环，实现最终的旋转 17 [0, 0, 0, 0] 18 [1, 1, 1, 1] 19 [2, 2, 2, 2] 20 [3, 3, 3, 3] 21 ''' 22 name="旋转前后分割线" 23 print(name.center(60,"*")) 24 for i,row in enumerate(array): #把行先遍历出来 25 # print(i,row) 26 for index in range(i,len(row)): #获取每一行元素的下标，并且每次循环不断缩小调整的范围 27 temp=array[i][index] #获取 28 array[i][index]=array[index][i] 29 array[index][i]=temp 30 for r in array:print(r) 31 print("------one loop---------")
3、冒泡排序，将一组列表中的元组按从小到大的顺序排列；每次内部循环只移一位元素
1 #冒泡排序，将一组列表中的元组按从小到大的顺序排列；每次内部循环只移一位元素 2 #冒泡排序相对较费时间，本例中加入算法运行耗时的计算 3 import time 4 time1=time.time() 5 data = [10,4,33,21,54,3,8,11,5,22,2,1,17,13,6] 6 print("冒泡排序之前：",data) 7 8 for i in range(len(data)): #外层循环，用于遍历所有的元素 9 for j in range(len(data)-1): #内层循环，用于取值与其之后的元素对比，每次循环只改变一个值的位置 10 if data[j]>data[j+1]: 11 tmp=data[j] 12 data[j]=data[j+1] 13 data[j+1]=tmp 14 print(data) 15 print("冒泡排序之后：",data) 16 time2=time.time(); 17 print('花费的时间为：',time2-time1)
时间复杂度
（1）时间频度 一个算法执行所耗费的时间，从理论上是不能算出来的，必须上机运行测试才能知道。但我们不可能也没有必要对每个算法都上机测试，只需知道哪个算法花费的时间多，哪个算法花费的时间少就可以了。并且一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。一个算法中的语句执行次数称为语句频度或时间频度。记为T(n)。
（1）时间频度 一个算法执行所耗费的时间，从理论上是不能算出来的，必须上机运行测试才能知道。但我们不可能也没有必要对每个算法都上机测试，只需知道哪个算法花费的时间多，哪个算法花费的时间少就可以了。并且一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。一个算法中的语句执行次数称为语句频度或时间频度。记为T(n)。
（2）时间复杂度 在刚才提到的时间频度中，n称为问题的规模，当n不断变化时，时间频度T(n)也会不断变化。但有时我们想知道它变化时呈现什么规律。为此，我们引入时间复杂度概念。 一般情况下，算法中基本操作重复执行的次数是问题规模n的某个函数，用T(n)表示，若有某个辅助函数f(n),使得当n趋近于无穷大时，T(n)/f(n)的极限值为不等于零的常数，则称f(n)是T(n)的同数量级函数。记作T(n)=Ｏ(f(n)),称Ｏ(f(n)) 为算法的渐进时间复杂度，简称时间复杂度。
指数时间一个问题求解所需要的计算时间m(n)，依数据输入的大小，呈指数增长（即输入数据的数量依线性增长，而所花的时间以指数增长），如下第二个例子所示：
for (i=1; i<=n; i++) x++; for (i=1; i<=n; i++) for (j=1; j<=n; j++) x++;
第一个for循环的时间复杂度为Ο(n)，第二个for循环的时间复杂度为Ο(n2)，则整个算法的时间复杂度为Ο(n+n2)=Ο(n2)。第一个循环的时间复杂度可以忽略
常数时间：
若对于一个算法，的上界与输入大小无关，则称其具有常数时间，记作时间。一个例子是访问数组中的单个元素，因为访问它只需要一条指令。但是，找到无序数组中的最小元素则不是，因为这需要遍历所有元素来找出最小值。这是一项线性时间的操作，或称时间。但如果预先知道元素的数量并假设数量保持不变，则该操作也可被称为具有常数时间。
对数时间 ：
若算法的T(n) = O(log n)，则称其具有对数时间
常见的具有对数时间的算法有二叉树的相关操作和二分搜索。
对数时间的算法是非常有效的，因为每增加一个输入，其所需要的额外计算时间会变小。
递归地将字符串砍半并且输出是这个类别函数的一个简单例子。它需要O（log n）的时间因为每次输出之前我们都将字符串砍半。 这意味着，如果我们想增加输出的次数，我们需要将字符串长度加倍。
线性时间
如果一个算法的时间复杂度为O(n)，则称这个算法具有线性时间，或O(n)时间。非正式地说，这意味着对于足够大的输入，运行时间增加的大小与输入成线性关系。例如，一个计算列表所有元素的和的程序，需要的时间与列表的长度成正比。