HSP_07章 排序和查找

P96_ 冒泡排序

排序的基本介绍

冒泡排序介绍

冒泡排序思路分析

• 代码

# 说明,如果只是完成排序功能,我们可以直接使用list的方法sort
# 排序的列表
num_list=[24,69,80,57,13,0,900,-1]
print("排序前".center(32,"-"))
print(f"num_list: {num_list}")
print("排序后".center(32,"-"))
# 使用sort方法完成排序
# num_list.sort()
# print(num_list)

def bubble_sort(my_list):

    # 使用冒泡排序，自己完成排序、目的了解底层原理，深刻理解
    # 以后遇到不同业务,需要定制排序,也能处理)
    """
        第一轮排序:把最大的数放到最后的位置
        第1次比较:[24,69,80,57,13]
        第2次比较:[24,69,80,57,13]
        第3次比较:[24,69,57,80,13]
        第4次比较:[24,69,57,13,80]
    """
    for i in range(1,len(my_list)):
        for j in range(0,len(my_list)-i):
            # 如果前面的元素 >后面的元素,就交换
            if my_list[j] > my_list[j+1]:
                my_list[j],my_list[j+1]=my_list[j+1],my_list[j]
        print(f"第{i}轮排序后的结果 my_list",my_list)

bubble_sort(num_list)

P97_顺序查找

查找的基本介绍

1. 顺序查找
2. 二分查找
3. 插值查找
4. 斐波那契查找
5. 树表查找
6. 分块查找
7. 哈希查找

#编写顺序查找函数seq_search
def seq_search(my_list,find_val):
    """
    功能: 顺序查找指定的元素
    :param my_list: 传入的列表(即要查找的列表)
    :param find_val: 要在找的值 / 元素
    :return:如果查找到则返回对应的索引下标，否则返回 -1
    """
    pass
    """
        思路分析
        1. 对列表进行遍历,如果找到了,则返回对应的下标
        2. 如果遍历结束,没有找到,则返回-1
        
    """
    find_index  = -1
    for i in range(len(my_list)):
        if my_list[i] == find_val:
           print(f"恭喜,找到对应的值{find_val},下标是{i}")
           find_index =i
           break
    else:
        print(f"没有找到对应的值{find_val}")
    return  find_index
# 测试
res_index = seq_search(name_list,find_name)
print("res_index:",res_index)

P98_二分查找

1. 二分查找的思路分析

2. 二分查找的代码实现

"""
 二分查找的思路分析:
    前提: 该列表是一个排号序的列表(为了分析方便,就以从小到大的列表为例分析)
    1. 找到列表的中间数mid_val 和 find_val 比较
    2. 如果mid_val > find_val ,则到mid_val的左边查找
    3. 如果mid_val < find_val ,则到mid_val的右边查找
    4. 如果mid_val == find_val,则找到,返回对应的下标即可
    5. 不断的重复1-4步骤,这里就是不断的折半,使用while
    6. 如果while结束时,都没有找到,说明find_val没有在列表

"""
# 要查找的列表
num_list = [1, 8, 10, 89, 1000, 1234]


# 编写二分查找的函数
def binary_search(my_list, find_val):
    """
    功能: 完成二分查找
    :param my_list: 要查找的列表(默认有大小顺序)
    :param find_val: 要查找的元素/值
    :return: 如果找到返回对应的下标,如果没有找到,返回-1
    """
    # 定义左右边的索引
    left_index, right_index = 0, len(my_list) - 1
    find_index = -1
    # 使用while循环,不断的折半比较，比较的前提是满足left_index<=right_index
    while left_index <= right_index:
        # 中间数的下标/索引
        mid_index = (left_index + right_index) // 2
        # 2. 如果mid_val > find_val ,则到mid_val的左边查找
        if my_list[mid_index] > find_val:
            right_index = mid_index - 1
        # 3. 如果mid_val < find_val ,则到mid_val的右边查找
        elif my_list[mid_index] < find_val:
            left_index = mid_index + 1
        # 4. 如果mid_val == find_val,则找到,返回对应的下标即可
        elif my_list[mid_index] == find_val:
            find_index = mid_index
            break

    return find_index

# 测试
res_index = binary_search(num_list,1000)
if res_index == -1:
    print("没有找到该数")
else:
    print(f"找到数,对应的下标{res_index}")

注意事项和使用细节:

1. 二分查找的前提是改列表已经是一个排好序的列表(从小到大或者从大到小)
2. 排列的顺序是从小到大还是从大到小,会影响二分查找的代码逻辑

P99_作业练习

# 1、编程题 homework01.py
# 随机生成10个整数(1-100的范围)保存到列表，使用冒泡排序，对其进行从大到小排序
import random

rli = []

# 生成10个随机整数,并保存到列表
for x in range(10):
    r = random.randint(1, 100)
    rli.append(r)
print("排序开始前".center(32, "-"))

# 冒泡排序,对其进行从大到小排序
print("rli: ", rli)


def bubble_sort(rli):
    for i in range(1, len(rli)):
        for j in range(0, len(rli) - i):
            if rli[j] < rli[j + 1]:
                rli[j], rli[j + 1] = rli[j + 1], rli[j]


bubble_sort(rli)
print("排序后".center(32, "-"))
# 冒泡排序
print("rli: ", rli)


# 编程题 homework02.py
# 在第1题的基础上，使用二分查找，查找是否有8这个数,如果有，则返回对应的下标,如果没有，返回-1老韩提示: 注意这里要查找的列表是从大到小…

def binary_search(my_list, find_val):
    find_index = -1

    left_index, right_index = 0, len(my_list) - 1


    while left_index <= right_index:
        mid_index = (left_index + right_index) // 2
        if my_list[mid_index] > find_val:
            left_index = mid_index + 1
        elif my_list[mid_index] < find_val:
            right_index = mid_index - 1
        elif find_val == my_list[mid_index]:
            find_index = mid_index
            break
    return print("未找到该数") if find_index == -1 else print(f"已找到{find_val},对应的下标是{find_index}")


# 测试
binary_search(rli, 10)
# print(binary_search(rli, 10))