python--数据结构--顺序查找法、折半查找法

# search_linear_table.py
from collections import deque


class Recode:
    """记录类型"""
    def __init__(self, key, other_info=None):
        self.key = key
        self.other_info = other_info


class RecodeList:
    """记录列表类型"""
    def __init__(self, recode_list: deque):
        self.recode_list = recode_list
        self.length = len(self.recode_list)


def seq_search(recode_list: RecodeList, key):
    """
    顺序查找法：设置监视哨

    算法思想：
            在表的一端设置一个称为"监视哨"的附加单元，存放要去查找元素的关键字。从表的另一端开始查找，如果在"监视哨"
        找到要查找元素的关键字，返回失败信息，否则返回相应下标。

    算法分析：
            用平均查找长度(ASL)分析顺序查找算法的性能。假设列表长度为n，那么查找第i个元素时需进行n-i+1次比较，即
        Ci = n-i+1。又假设查找每个数据元素的概率相等，即Pi=1/n，则顺序查找成功时的平均查找长度为。
            ASL =


    :param recode_list: 创建好的记录列表对象
    :param key: 所要查找的关键字
    :return: 成功返回关键字在传进来的参数recode_list的下标，失败返回-1
    """
    recode_list_ = recode_list
    recode_list_.appendleft(Recode(key))
    i = recode_list_.length
    while recode_list_.recode_list[i].key != key:
        i -= 1
    return i-1  # 因recode_list_前面有个观察哨返回时需减1


def seq_search_(recode_list: RecodeList, key):
    """
    顺序查找法：不设置监视哨

    算法对比：
            与设置监视哨相比，循环控制条件中增加了i>-1，用以判断查找过程是否越界。加上“监视哨”可省去这个条件，
        从而提高查找效率。

    :param recode_list: 创建好的记录列表对象
    :param key: 所要查找的关键字
    :return: 成功返回关键字在记录列表中的下标，失败返回-1
    """
    i = recode_list.length-1
    while i > -1 and recode_list.recode_list[i].key != key:
        i -= 1
    if i > -1:
        return i
    else:
        return -1


def bin_search(record_list: RecodeList, key):
    """
    折半查找法

    对待查列表的要求：
        (1) 必须采用顺序存储结构
        (2) 必须按关键字大小有序排列

    算法思想：
            首先，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前后两个子表
        如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。
	
	算法分析：
        该部分内容在文章补充部分说明。

		折半查找方法的优点是比较次数少，查找速度快，平均性能号；其缺点是要求待查表为有序表，且插入删除困难。因此折半查找方法适
		用于不经常变动而查找频繁的有序列表。

    :param record_list: 创建好的记录列表对象
    :param key: 所要查找的关键字
    :return: 成功返回关键字在记录列表中的下标，失败返回-1
    """
    low = 0
    high = record_list.length
    while low <= high:
        mid = (low + high)//2
        if record_list.recode_list[mid].key == key:
            return mid  # 成功返回key在record_list.recor_list中的下标
        elif record_list.recode_list[mid].key > key:
            # 未找到待查元素，则继续在前半区间进行查找
            high = mid - 1
        else:
            # 未找到待查元素，则继续在后半区间进行查找
            low = mid + 1
    return -1  # 未找到返回-1

# test_serach_linear_table.py
from collections import deque
from search_linear_table import Recode, RecodeList, seq_search, seq_search, bin_search


if __name__ == '__main__':
    # 测试顺序查找算法seq_search/seq_search_
    # recode0 = Recode('1')
    # recode1 = Recode('y')
    # recode2 = Recode('4')
    # recode3 = Recode('h')
    # recode4 = Recode('b')
    # recode5 = Recode('2')
    # recode6 = Recode('c')
    # recode7 = Recode('a')
    #
    #
    # recode_list = RecodeList(deque([recode0, recode1, recode2, recode3, recode4, recode5, recode6, recode7]))
    # index = seq_search(recode_list, 'b')
    # print(index)
    # recode_list = RecodeList(deque([recode0, recode1, recode2, recode3, recode4, recode5, recode6, recode7]))
    # index = seq_search_(recode_list, 'b')
    # print(index)

    # 测试折半查找算法bin_search
    recode0 = Recode(0)
    recode1 = Recode(1)
    recode2 = Recode(2)
    recode3 = Recode(3)
    recode4 = Recode(4)
    recode5 = Recode(5)
    recode6 = Recode(6)
    recode7 = Recode(7)

    recode_list = RecodeList(deque([recode0, recode1, recode2, recode3, recode4, recode5, recode6, recode7]))
    index = bin_search(recode_list, 5)
    print(index)

补充：

bin_search算法分析

算法分析：

用平均查找长度(ASL)分析折半查找算法的性能。折半查找过程可用二叉判定树的描述，判定树中每一结点对应表中一个记录，但结点值不是记录的关键字，而是记录在表中的位置序号。根结点对应当前区间的中间记录，左子树对应前一子表，右子树对应后一子表。

显然，找到有序表中任一记录的过程，对应判定树中从根结点到与该记录相应的结点的路径，而所做比较的次数恰为该结点在判定树上的层次数。因此，折半查找成功时，关键字比较次数最多不超过判定树的深度。

由于判定树的叶节点所在层次之差最多为1，故n个结点的判定树的深度与n各结点的完全二叉树的深度相等，均为⌊log₂n⌋+1。这样，折半查找成功时，关键字比较次数最多不超过⌊log₂n⌋+1。相应第，折半查找失败时，对应判定树中从根结点到某个含空指针的结点的路径，因此，折半查找成功时，关键字比较次数最多不闯过判定树的深度⌊log₂n⌋+1。

为了便于讨论，假定表的长度n = 2**h - 1，则相应判定树必为深度是h的们二叉树，h=log₂(n+1)。又假设每个记录的查找概率相等，则折半查找成功是的平均查找长度为：