Python算法学习[6]—查找算法:表、树、散列、斐波那契查找算法&实践操作

查找算法:表、树、散列、斐波那契查找算法&实践操作

本文将介绍查找算法的几种常见实现方式,包括表、树、散列以及斐波那契查找算法,并给出Python代码实现和实践操作。

  1. 表查找算法
    表查找算法是最基础的查找算法之一,其实现方式是将所有元素存储在一个有序表中,然后按照顺序遍历表进行查找。在表中查找元素的时间复杂度为O(n),其中n为表中元素的数量。

下面是一个简单的Python代码,用于实现表查找算法:

def linear_search(arr, x):
    for i in range(len(arr)):
        if arr[i] == x:
            return i
    return -1

在上述代码中,linear_search()函数接收两个参数:arr表示待查找的数组,x表示要查找的元素。首先,使用for循环遍历整个数组,当遇到目标元素时,返回其索引值。如果遍历完整个数组仍未找到目标元素,则返回-1。

  1. 树查找算法
    树查找算法利用二叉查找树的特性,将元素存储在一个有序的二叉树中,然后按照二叉排序树的查找方式进行查找。在二叉排序树中查找元素的时间复杂度为O(logn),其中n为树中节点的数量。

下面是一个简单的Python代码,用于实现二叉排序树查找算法:

class Node:
    def __init__(self, val=None):
        self.val = val
        self.left = None
        self.right = None

def binary_search(root, x):
    if not root or root.val == x:
        return root

    if root.val < x:
        return binary_search(root.right, x)
    else:
        return binary_search(root.left, x)

在上述代码中,我们定义了一个Node类,在该类中定义了节点的val、left和right属性。binary_search()函数接收两个参数:root表示二叉排序树的根节点,x表示要查找的元素。首先,判断根节点是否为空或者是否等于目标元素,如果是则返回根节点。否则,根据二叉排序树的性质,如果目标元素大于根节点的值,则进入右子树进行递归查找;如果小于根节点的值,则进入左子树进行递归查找。

  1. 散列查找算法
    散列查找算法利用散列表的特性,将元素存储在一个散列表中,利用哈希函数计算键对应的桶号,然后在该桶中查找元素。在散列表中查找元素的时间复杂度约为O(1),具体取决于哈希函数的设计和冲突解决策略。

下面是一个简单的Python代码,用于实现散列查找算法:

class HashTable:
    def __init__(self):
        self.size = 10
        self.hash_table = [None] * self.size

    def hash_func(self, key):
        return key % self.size

    def insert(self, key, value):
        index = self.hash_func(key)
        if not self.hash_table[index]:
            self.hash_table[index] = [(key, value)]
        else:
            for i in range(len(self.hash_table[index])):
                if self.hash_table[index][i][0] == key:
                    self.hash_table[index][i] = (key, value)
                    break
            else:
                self.hash_table[index].append((key,value))

	def search(self, key):
    	index = self.hash_func(key)
    	if not self.hash_table[index]:
        	return None
    	else:
        	for i in range(len(self.hash_table[index])):
            	if self.hash_table[index][i][0] == key:
                	return self.hash_table[index][i][1]
        	return None

在上述代码中,我们定义了一个HashTable类,其中包含hash_table属性和三个方法:hash_func()、insert()和search()。其中,hash_func()函数用于计算键对应的桶号;insert()函数用于向散列表中插入元素;search()函数用于在散列表中查找元素。

在insert()函数中,首先计算键对应的桶号,如果该桶为空,则将元素插入到该桶中;否则遍历该桶中的所有元素,如果已经存在该键,则更新其对应的值;否则将该元素插入到该桶中。

在search()函数中,同样先计算键对应的桶号,如果该桶为空,则返回None;否则遍历该桶中的所有元素,如果找到对应的键,则返回其对应的值;否则返回None。

  1. 斐波那契查找算法
    斐波那契查找算法是一种利用黄金分割原理进行查找的算法,其实现是将元素存储在斐波那契数列中,并按照黄金分割点将数列拆分成两段,然后根据目标元素与黄金分割点的大小关系,选择下一次查找的范围。在斐波那契数列中查找元素的时间复杂度为O(logn),其中n为数列中元素的数量。

下面是一个简单的Python代码,用于实现斐波那契查找算法:

def fibonacci_search(arr, x):
    fibo_n2 = 0
    fibo_n1 = 1
    fibo_n = fibo_n1 + fibo_n2
    
    while fibo_n < len(arr):
        fibo_n2 = fibo_n1
        fibo_n1 = fibo_n
        fibo_n = fibo_n1 + fibo_n2

    offset = -1
    while fibo_n > 1:
        i = min(offset + fibo_n2, len(arr) - 1)
        if arr[i] < x:
            fibo_n = fibo_n1
            fibo_n1 = fibo_n2
            fibo_n2 = fibo_n - fibo_n1
            offset = i
        elif arr[i] > x:
            fibo_n = fibo_n2
            fibo_n1 = fibo_n1 - fibo_n2
            fibo_n2 = fibo_n - fibo_n1
        else:
            return i

    if fibo_n1 and arr[offset + 1] == x:
        return offset + 1

    return -1

在上述代码中,我们定义了一个fibonacci_search()函数,接收两个参数:arr表示待查找的数组,x表示要查找的元素。首先,使用while循环计算最大斐波那契数列项数,使得fibo_n大于等于数组长度。然后,设置offset初值为-1,并在while循环中继续查找元素,每次根据目标元素与当前位置的大小关系,选择左半部分或右半部分继续查找。直到找到目标元素或者搜索范围缩小到1时停止查找。最后,检查是否找到目标元素,如果找到则返回其索引值;否则返回-1。

实践操作
为了更好地理解和实践上述算法,我们可以使用Python来实现这些算法,并对其进行测试。

表查找算法实践
下面是一个简单的线性查找算法的示例代码,用于在Python中实现表查找算法:

def linear_search(arr, x):
    for i in range(len(arr)):
        if arr[i] == x:
            return i
    return -1

接下来,我们可以使用以下代码来测试该函数:

arr = [2, 4, 7, 9, 12, 14, 17, 22, 25]
x = 12
print(linear_search(arr, x))

运行结果为:4。这表明,元素12位于数组的第5个位置(因为Python从0开始索引)。

树查找算法实践
下面是一个简单的二叉排序树查找算法的示例代码,用于在Python中实现树查找算法:

class Node:
    def __init__(self, val=None):
        self.val = val
        self.left = None
        self.right = None

def binary_search(root, x):
    if not root or root.val == x:
        return root

    if root.val < x:
        return binary_search(root.right, x)
    else:
        return binary_search(root.left, x)

接下来,我们可以使用以下代码来测试该函数:

root = Node(10)
root.left = Node(6)
root.right = Node(14)
root.left.left = Node(4)
root.left.right = Node(8)
root.right.left = Node(12)
root.right.right = Node(16)

x = 12
result = binary_search(root, x)
if result:
    print("Element found")
else:
    print("Element not found")

运行结果为:Element found。这表明,元素12位于二叉排序树中。

散列查找算法实践
下面是一个简单的散列表查找算法的示例代码,用于在Python中实现散列查找算法:

class HashTable:
    def __init__(self):
        self.size = 10
        self.hash_table = [None] * self.size

    def hash_func(self, key):
        return key % self.size

    def insert(self, key, value):
        index = self.hash_func(key)
        if not self.hash_table[index]:
            self.hash_table[index] = [(key, value)]
        else:
            for i in range(len(self.hash_table[index])):
                if self.hash_table[index][i][0] == key:
                    self.hash_table[index][i] = (key, value)
                    break
            else:
                self.hash_table[index].append((key, value))

    def search(self, key):
        index = self.hash_func(key)
        if not self.hash_table[index]:
            return None
        else:
            for i in range(len(self.hash_table[index])):
                if self.hash_table[index][i][0] == key:
                    return self.hash_table[index][i][1]
            return None

接下来,我们可以使用以下代码来测试该函数:

ht = HashTable()
ht.insert(11, "apple")
ht.insert(23, "banana")
ht.insert(42, "cherry")
ht.insert(18, "grape")

print(ht.search(23))

运行结果为:banana。这表明,键为23的元素的值为“banana”。

斐波那契查找算法实践
下面是一个简单的斐波那契查找算法的示例代码,用于在Python中实现斐波那契查找算法:

def fibonacci_search(arr, x):
    fibo_n2 = 0
    fibo_n1 = 1
    fibo_n = fibo_n1 + fibo_n2
    
    while fibo_n < len(arr):
        fibo_n2 = fibo_n1
        fibo_n1 = fibo_n
        fibo_n = fibo_n1 + fibo_n2

    offset = -1
    while fibo_n > 1:
        i= min(offset + fibo_n2, len(arr) - 1) if arr[i] < x: fibo_n = fibo_n1 fibo_n1 = fibo_n2 fibo_n2 = fibo_n - fibo_n1 offset = i elif arr[i] > x: fibo_n = fibo_n2 fibo_n1 = fibo_n1 - fibo_n2 fibo_n2 = fibo_n - fibo_n1 else: return i

	if fibo_n1 and arr[offset + 1] == x:
    	return offset + 1

	return -1

接下来,我们可以使用以下代码来测试该函数:

arr = [2, 4, 7, 9, 12, 14, 17, 22, 25]
x = 12
print(fibonacci_search(arr, x))

运行结果为:4。这表明,元素12位于数组的第5个位置(因为Python从0开始索引)。

总结
本文介绍了四种常见的查找算法:表查找算法、树查找算法、散列查找算法和斐波那契查找算法,并提供了Python代码来实现和测试这些算法。这些算法在不同的场景中有着广泛的应用,具有较高的效率和准确性。希望通过本文的介绍,您能够更好地理解和掌握这些查找算法的原理和实现方法。

  • 1
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

高山莫衣

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值