经典例题

一,冒泡排序

　　给出一个纯数字列表. 请对列表进行排序(升级题). 
　　思路: 
　　1. 完成a和b的数据交换. 例如, a = 10, b = 24 交换之后, a = 24, b = 10
　　2. 循环列表. 判断a[i]和a[i+1]之间的大小关系, 如果a[i]比a[i+1]大. 则进行互换. 循环结束的时候.

　　　当前列表中最大的数据就会被移动到最右端. 
　　3. 想一想, 如果再次执行一次上面的操作. 最终第二大的数据就移动到了右端. 以此类推. 如果反

　　　复的进行执行相应的操作. 那这个列表就变成了一个有序列表.

lst = [88,5,8,6,1,23]
for a in range(len(lst)):   # 记录内部排序的次数
    i = 0
    while i < len(lst) - 1: # 把最大值移动到右端
        if lst[i] > lst[i+1]:   # 比较,
            lst[i], lst[i+1] = lst[i+1], lst[i] # 交换
        i = i + 1
print(lst)


lis=[12,3,5,8,2,45,1]
for n in range(len(lis)):
    for i in range(len(lis)-1):
        if lis[i]>lis[i+1]:
            lis[i],lis[i+1]=lis[i+1],lis[i]
print(lis)

二,

　　写函数，传入n个数,返回字典{‘max’:最大值,’min’:最小值}
　　例如:min_max(2,5,7,8,4) 返回:{‘max’:8,’min’:2}(此题用到max(),min()内置函数)

def func(*args):
    m = args[0] # 假设第0项就是最大值
    mi = args[0]
    for el in args:
        if el > m:
            m = el # 当前这个元素比假设的那个大. 记录当前这个比较大的数
        if el < mi:
            mi = el
    return {"最大值":m, "最小值":mi}

print(func(5,7,12,1,46,87,3))

三,

　　有如下值li=[11,22,33,44,55,66,77,88,99,90],将所有大于66的值保存至字典的第一个key中,

　　将小于66的值保存至第二个key的值中(在原有代码上补充不允许改变原有代码)

li = [11,22,33,44,55,77,88,99,90]
result = {}
for row in li:
    if row < 66:
        l = result.get("k1")    # 上来就拿k1
        if l == None:   # k1不存在. 没有这个列表
            result["k1"] = [row]    # 创建一个列表扔进去
        else:   # k1如果存在
            result['k1'].append(row)    # 追加内容
    else:
        l = result.get("k2")  # 上来就拿k1
        if l == None:  # k1不存在. 没有这个列表
            result["k2"] = [row]  # 创建一个列表扔进去
        else:  # k1如果存在
            result['k2'].append(row)  # 追加内容
print(result)

四,

　　写代码完成99乘法表

a = 1
while a <=9:

    b = 1
    while b <= a:
        print("%dx%d=%d	" % (a, b, a*b), end="")
        b = b + 1
    print() # 换行
    a = a + 1

五.递归的应⽤:

我们可以使⽤递归来遍历各种树形结构, 比如我们的⽂件夹系统. 可以使⽤递归来遍历该 ⽂件夹中的所有⽂件

import  os
filePath = "d:sylarpython_workspace"

def read(filePath, n):
    it = os.listdir(filePath)   # 打开文件夹
    for el in it:
        #  拿到路径
        fp = os.path.join(filePath, el) # 获取到绝对路径
        if os.path.isdir(fp):   # 判断是否是文件夹
            print("	"*n,el)
            read(fp, n+1)    # 又是文件夹. 继续读取内部的内容 递归入口
        else:
            print("	"*n,el)    # 递归出口

read(filePath, 0)

六.⼆分查找

判断 n 是否在 lst 中出现. 如果出现请返回 n 所在的位置

第一种:     ⼆分查找---⾮递归算法
lst = [11,22,33,44,55,66,77,88,99,123,234,345,456,567,678,789,1111]
n = 567
left = 0
right = len(lst) - 1
count = 1
while left <= right:
    middle = (left + right) // 2
    if n > lst[middle]:
        left = middle + 1
    elif n < lst[middle]:
        right = middle - 1
    else:
        print(count)
        print("存在")
        print(middle)
        break
    count = count + 1
else:
    print("不存在")

第二种:     普通递归版本⼆分法
lst = [11,22,33,44,55,66,77,88,99,123,234,345,456,567,678,789,1111]
def binary_search(left, right, n):
    middle = (left + right)//2
    if left > right:
        return -1
    if n > lst[middle]:
        left = middle + 1
    elif n < lst[middle]:
        right = middle - 1
    else:
        return middle
    return binary_search(left, right, n)    # 这个return必须要加. 否则接收
到的永远是None.
print(binary_search(0, len(lst)-1, 65) )


第三种:# 另类⼆分法, 很难计算位置.

lst = [11,22,33,44,55,66,77,88,99,123,234,345,456,567,678,789,1111]

def binary_search(lst, n): left = 0 right = len(lst) - 1 middle = (left + right) // 2 if right <= 0: print("没找到") return if n > lst[middle]: lst = lst[middle+1:] elif n < lst[middle]: lst = lst[:middle] else: print("找到了") return binary_search(lst, n) binary_search(lst, 65)