python常用的简单算法,二分查找、冒泡排序、数组翻转等

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)
时间: 2024-10-10 15:36:56

python常用的简单算法,二分查找、冒泡排序、数组翻转等的相关文章

数据结构和算法————二分查找

  二分查找 这些天深刻的体会到了巩固知识的重要性.对数据结构和算法的学习有一年的时间,然后搁置了一年,最后发现都忘记了. 不过还好不是失忆,看了之前做过的笔记,还是能回想起来的. 现在想在写一遍,算是对本子上的笔记做一个备份,更重要的是加深我的印象. 首先说一下二分查找的思想:假设数据是按升序排序的,对于给定值val,从序列的中间位置开始比较. 如果当前位置值等于val,则查找成功: 若val小于当前位置值,则在数列的前半段中查找 若val大于当前位置值,则在数列的后半段中继续查找. 重复以上

查找算法-二分查找

查找算法-二分查找 标题 二分查找也称折半查找(Binary Search),它是一种效率较高的查找方法.但是,折半查找要求线性表必须采用顺序存储结构,而且表中元素按关键字有序排列. 过程 首先,假设表中元素是按升序排列,将表中间位置记录的关键字与查找关键字比较,如果两者相等,则查找成功:否则利用中间位置记录将表分成前.后两个子表,如果中间位置记录的关键字大于查找关键字,则进一步查找前一子表,否则进一步查找后一子表.重复以上过程,直到找到满足条件的记录,使查找成功,或直到子表不存在为止,此时查找

python函数:递归函数及二分查找算法

本文和大家分享的主要是python的递归函数及二分查找算法相关内容,一起来看看吧,希望对大家学习python有所帮助. 一.递归的定义 def story(): s = """ 从前有个山,山里有座庙,庙里老和尚讲故事, 讲的什么呢? """ print(s) story() story() 老和尚讲故事 递归的定义 -- 在一个函数里再调用这个函数本身.这种魔性的使用函数的方式就叫做 递归 . 递归的最大深度:997 1.python递归最大层

oldboy seventeenth day. I love Python. 万恶之神: 递归; 初始算法: 二分查找;

一, 昨日内容讲解 内置函数:重点说几个: max(*args,key=None) min(*args,key=None) zip(*args,key=None) sorted(*args,key=None,reverse=False) reversed() 翻转 返回的是迭代器 filter(key,*args) map(key,*args) 匿名函数: lambda x: x*x二, 作业讲解 三, 今日内容 递归: 设置递归次数: import sys sys.setrecursionli

入门算法-二分查找,二分排序,插入排序,冒泡排序

1.二分查找(nlogn) 二分查找,需要将业务模拟一个有序数组.然后查找某个值在该数组中的位置. 二分查找的关键是: 1)查找的值一定在某次的范围中间.即使值是最后一个,也要按照二分法的规则去查找. 2)有左右边界的查找范围作为一个循环不变式 function bsearch(A, x) { // A 是有序升数组:x是待查值; 结果要返回x在A中的位置 // 循环不变式 let l = 0,r = A.length-1, guess; while(i <= r) { guess = Math

八大排序算法二分查找

import java.util.ArrayList;import java.util.Arrays;import java.util.List; import org.junit.Test; public class InsertSort { public static void display(int[] arr){ System.out.print("["); for(int i=0;i<arr.length;i++){ if(i == arr.length-1){ Sys

java——类型转换,冒泡排序,选择排序,二分查找,数组的翻转

一.类型转换 p { margin-bottom: 0.25cm; direction: ltr; color: #000000; line-height: 120%; text-align: justify; widows: 0; orphans: 0 } p.western { font-family: "Calibri", sans-serif; font-size: 10pt } p.cjk { font-family: "宋体"; font-size: 1

初级算法:二分查找

如果有这样一个列表,让你从这个列表中找到66的位置,你要怎么做? l = [2,3,5,10,15,16,18,22,26,30,32,35,41,42,43,55,56,66,67,69,72,76,82,83,88] 你说,so easy! l.index(66)... 我们之所以用index方法可以找到,是因为python帮我们实现了查找方法.如果,index方法不给你用了...你还能找到这个66么?   上面这个方法就实现了从一个列表中找到66所在的位置了. 但我们现在是怎么找到这个数的

[经典算法] 二分查找

题目说明: 二分查找法是对一组有序的数字中进行查找,传递相应的数据,进行比较查找到与原数据相同的数据,查找到了返回对应的数组下标,失败返回-1. 题目解析: 二分查找又称折半查找,优点是比较次数少,查找速度快,平均性能好:其缺点是要求待查表为有序表,且插入删除困难.因此,折半查找方法适用于不经常变动而查找频繁的有序列表. 二分查找可以解决(预排序数组的查找)问题:只要数组中包含T(即要查找的值),那么通过不断缩小包含T的范围,最终就可以找到它.其算法流程如下: 1.一开始,范围覆盖整个数组. 2