查找算法 python

最新推荐文章于 2023-08-21 17:12:58 发布
最新推荐文章于 2023-08-21 17:12:58 发布
阅读量112 收藏
点赞数
文章标签： python 数据结构与算法
原文链接：http://www.cnblogs.com/sjxm2017/p/10441861.html
版权

转载：https://www.cnblogs.com/lsqin/p/9342929.html

 

查找算法 -- 简介

    查找（Searching）就是根据给定的某个值，在查找表中确定一个其关键字等于给定值的数据元素。
    查找表（Search Table）：由同一类型的数据元素构成的集合
    关键字（Key）：数据元素中某个数据项的值，又称为键值
    主键（Primary Key）：可唯一的标识某个数据元素或记录的关键字
查找表按照操作方式可分为：
        1.静态查找表（Static Search Table）：只做查找操作的查找表。它的主要操作是：
        ①查询某个“特定的”数据元素是否在表中
        ②检索某个“特定的”数据元素和各种属性
        2.动态查找表（Dynamic Search Table）：在查找中同时进行插入或删除等操作：
        ①查找时插入数据
        ②查找时删除数据

顺序查找

算法简介

       顺序查找又称为线性查找，是一种最简单的查找方法。适用于线性表的顺序存储结构和链式存储结构。该算法的时间复杂度为O(n)。

基本思路

       从第一个元素m开始逐个与需要查找的元素x进行比较，当比较到元素值相同(即m=x)时返回元素m的下标，如果比较到最后都没有找到，则返回-1。

优缺点

    缺点：是当n 很大时，平均查找长度较大，效率低；
    优点：是对表中数据元素的存储没有要求。另外，对于线性链表，只能进行顺序查找。

算法实现
# 最基础的遍历无序列表的查找算法
# 时间复杂度O(n)
 
def sequential_search(lis, key): length = len(lis) for i in range(length): if lis[i] == key: return i else: return False if __name__ == '__main__': LIST = [1, 5, 8, 123, 22, 54, 7, 99, 300, 222] result = sequential_search(LIST, 123) print(result)

二分查找

算法简介

    二分查找（Binary Search），是一种在有序数组中查找某一特定元素的查找算法。查找过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则查找过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。如果在某一步骤数组为空，则代表找不到。
    这种查找算法每一次比较都使查找范围缩小一半。
算法描述 

    给予一个包含 n个带值元素的数组A 

        1、 令 L为0 ， R为 n-1 ；
        2、 如果L>R，则搜索以失败告终 ；
        3、 令 m (中间值元素)为  ⌊(L+R)/2⌋；
        4、 如果 Am<T，令 L为 m + 1 并回到步骤二 ；
        5、 如果 Am>T，令 R为 m - 1 并回到步骤二；
复杂度分析 

    时间复杂度：折半搜索每次把搜索区域减少一半，时间复杂度为 O(logn)
    空间复杂度：O(1)

算法实现
# 针对有序查找表的二分查找算法
 
def binary_search(lis, key):   low = 0   high = len(lis) - 1   time = 0   while low < high:     time += 1     mid = int((low + high) / 2)     if key < lis[mid]:       high = mid - 1     elif key > lis[mid]:       low = mid + 1     else:       # 打印折半的次数       print("times: %s" % time)       return mid   print("times: %s" % time)   return False   if __name__ == '__main__':   LIST = [1, 5, 7, 8, 22, 54, 99, 123, 200, 222, 444]   result = binary_search(LIST, 99)   print(result)

插值查找

算法简介

    插值查找是根据要查找的关键字key与查找表中最大最小记录的关键字比较后的 查找方法，其核心就在于插值的计算公式 (key-a[low])/(a[high]-a[low])*(high-low)。
    时间复杂度o(logn)但对于表长较大而关键字分布比较均匀的查找表来说，效率较高。
算法思想
    基于二分查找算法，将查找点的选择改进为自适应选择，可以提高查找效率。当然，差值查找也属于有序查找。
    注：对于表长较大，而关键字分布又比较均匀的查找表来说，插值查找算法的平均性能比折半查找要好的多。反之，数组中如果分布非常不均匀，那么插值查找未必是很合适的选择。
复杂度分析 

    时间复杂性：如果元素均匀分布，则O（log log n）），在最坏的情况下可能需要 O（n）。
    空间复杂度：O（1）。

算法实现
# 插值查找算法
 
def binary_search(lis, key): low = 0 high = len(lis) - 1 time = 0 while low < high: time += 1 # 计算mid值是插值算法的核心代码 mid = low + int((high - low) * (key - lis[low])/(lis[high] - lis[low])) print("mid=%s, low=%s, high=%s" % (mid, low, high)) if key < lis[mid]: high = mid - 1 elif key > lis[mid]: low = mid + 1 else: # 打印查找的次数 print("times: %s" % time) return mid print("times: %s" % time) return False if __name__ == '__main__': LIST = [1, 5, 7, 8, 22, 54, 99, 123, 200, 222, 444] result = binary_search(LIST, 444) print(result)

斐波那契查找

算法简介

    斐波那契数列，又称黄金分割数列，指的是这样一个数列：1、1、2、3、5、8、13、21、····，在数学上，斐波那契被递归方法如下定义：F(1)=1，F(2)=1，F(n)=f(n-1)+F(n-2) （n>=2）。该数列越往后相邻的两个数的比值越趋向于黄金比例值（0.618）。
算法描述 
    斐波那契查找就是在二分查找的基础上根据斐波那契数列进行分割的。在斐波那契数列找一个等于略大于查找表中元素个数的数F[n]，将原查找表扩展为长度为F[n](如果要补充元素，则补充重复最后一个元素，直到满足F[n]个元素)，完成后进行斐波那契分割，即F[n]个元素分割为前半部分F[n-1]个元素，后半部分F[n-2]个元素，找出要查找的元素在那一部分并递归，直到找到。
复杂度分析 
    最坏情况下，时间复杂度为O(log2n)，且其期望复杂度也为O(log2n)。
算法实现
# 斐波那契查找算法
# 时间复杂度O(log(n))
 
def fibonacci_search(lis, key):   # 需要一个现成的斐波那契列表。其最大元素的值必须超过查找表中元素个数的数值。   F = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144,      233, 377, 610, 987, 1597, 2584, 4181, 6765,      10946, 17711, 28657, 46368]   low = 0   high = len(lis) - 1       # 为了使得查找表满足斐波那契特性，在表的最后添加几个同样的值   # 这个值是原查找表的最后那个元素的值   # 添加的个数由F[k]-1-high决定   k = 0   while high > F[k]-1:     k += 1   print(k)   i = high   while F[k]-1 > i:     lis.append(lis[high])     i += 1   print(lis)       # 算法主逻辑。time用于展示循环的次数。   time = 0   while low <= high:     time += 1     # 为了防止F列表下标溢出，设置if和else     if k < 2:       mid = low     else:       mid = low + F[k-1]-1           print("low=%s, mid=%s, high=%s" % (low, mid, high))     if key < lis[mid]:       high = mid - 1       k -= 1     elif key > lis[mid]:       low = mid + 1       k -= 2     else:       if mid <= high:         # 打印查找的次数         print("times: %s" % time)         return mid       else:         print("times: %s" % time)         return high   print("times: %s" % time)   return False   if __name__ == '__main__':   LIST = [1, 5, 7, 8, 22, 54, 99, 123, 200, 222, 444]   result = fibonacci_search(LIST, 444)   print(result)

树表查找

1、二叉树查找算法。

        算法简介

    二叉查找树是先对待查找的数据进行生成树，确保树的左分支的值小于右分支的值，然后在就行和每个节点的父节点比较大小，查找最适合的范围。 这个算法的查找效率很高，但是如果使用这种查找方法要首先创建树。 

      算法思想
　　二叉查找树（BinarySearch Tree）或者是一棵空树，或者是具有下列性质的二叉树：
　　    1）若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
　　    2）若任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
　　    3）任意节点的左、右子树也分别为二叉查找树。
　　二叉查找树性质：对二叉查找树进行中序遍历，即可得到有序的数列。
     复杂度分析 

     它和二分查找一样，插入和查找的时间复杂度均为O(logn)，但是在最坏的情况下仍然会有O(n)的时间复杂度。原因在于插入和删除元素的时候，树没有保持平衡。

     算法实现
# 二叉树查找 Python实现
class BSTNode:
    """ 定义一个二叉树节点类。 以讨论算法为主，忽略了一些诸如对数据类型进行判断的问题。 """ def __init__(self, data, left=None, right=None): """ 初始化 :param data: 节点储存的数据 :param left: 节点左子树 :param right: 节点右子树 """ self.data = data self.left = left self.right = right class BinarySortTree: """ 基于BSTNode类的二叉查找树。维护一个根节点的指针。 """ def __init__(self): self._root = None def is_empty(self): return self._root is None def search(self, key): """ 关键码检索 :param key: 关键码 :return: 查询节点或None """ bt = self._root while bt: entry = bt.data if key < entry: bt = bt.left elif key > entry: bt = bt.right else: return entry return None def insert(self, key): """ 插入操作 :param key:关键码 :return: 布尔值 """ bt = self._root if not bt: self._root = BSTNode(key) return while True: entry = bt.data if key < entry: if bt.left is None: bt.left = BSTNode(key) return bt = bt.left elif key > entry: if bt.right is None: bt.right = BSTNode(key) return bt = bt.right else: bt.data = key return def delete(self, key): """ 二叉查找树最复杂的方法 :param key: 关键码 :return: 布尔值 """ p, q = None, self._root # 维持p为q的父节点，用于后面的链接操作 if not q: print("空树！") return while q and q.data != key: p = q if key < q.data: q = q.left else: q = q.right if not q: # 当树中没有关键码key时，结束退出。 return # 上面已将找到了要删除的节点，用q引用。而p则是q的父节点或者None（q为根节点时）。 if not q.left: if p is None: self._root = q.right elif q is p.left: p.left = q.right else: p.right = q.right return # 查找节点q的左子树的最右节点，将q的右子树链接为该节点的右子树 # 该方法可能会增大树的深度，效率并不算高。可以设计其它的方法。 r = q.left while r.right: r = r.right r.right = q.right if p is None: self._root = q.left elif p.left is q: p.left = q.left else: p.right = q.left def __iter__(self): """ 实现二叉树的中序遍历算法, 展示我们创建的二叉查找树. 直接使用python内置的列表作为一个栈。 :return: data """ stack = [] node = self._root while node or stack: while node: stack.append(node) node = node.left node = stack.pop() yield node.data node = node.right if __name__ == '__main__': lis = [62, 58, 88, 48, 73, 99, 35, 51, 93, 29, 37, 49, 56, 36, 50] bs_tree = BinarySortTree() for i in range(len(lis)): bs_tree.insert(lis[i]) # bs_tree.insert(100) bs_tree.delete(58) for i in bs_tree: print(i, end=" ") # print("\n", bs_tree.search(4))
2、平衡查找树之2-3查找树（2-3 Tree）
     2-3查找树定义

   和二叉树不一样，2-3树运行每个节点保存1个或者两个的值。对于普通的2节点(2-node)，他保存1个key和左右两个自己点。对应3节点(3-node)，保存两个Key，2-3查找树的定义如下： 
　　 1）要么为空，要么： 
　　 2）对于2节点，该节点保存一个key及对应value，以及两个指向左右节点的节点，左节点也是一个2-3节点，所有的值都比key要小，右节点也是一个2-3节点，所有的值比key要大。 
　　 3）对于3节点，该节点保存两个key及对应value，以及三个指向左中右的节点。左节点也是一个2-3节点，所有的值均比两个key中的最小的key还要小；中间节点也是一个2-3节点，中间节点的key值在两个跟节点key值之间；右节点也是一个2-3节点，节点的所有key值比两个key中的最大的key还要大。

     2-3查找树的性质

　　 1）如果中序遍历2-3查找树，就可以得到排好序的序列； 
　　 2）在一个完全平衡的2-3查找树中，根节点到每一个为空节点的距离都相同。（这也是平衡树中“平衡”一词的概念，根节点到叶节点的最长距离对应于查找算法的最坏情况，而平衡树中根节点到叶节点的距离都一样，最坏情况也具有对数复杂度。） 

　 2-3树的查找效率与树的高度是息息相关的。 

    距离来说，对于1百万个节点的2-3树，树的高度为12-20之间，对于10亿个节点的2-3树，树的高度为18-30之间。 
　　对于插入来说，只需要常数次操作即可完成，因为他只需要修改与该节点关联的节点即可，不需要检查其他节点，所以效率和查找类似。

    算法实现
class Node(object):
    def __init__(self,key): self.key1=key self.key2=None self.left=None self.middle=None self.right=None def isLeaf(self): return self.left is None and self.middle is None and self.right is None def isFull(self): return self.key2 is not None def hasKey(self,key): if (self.key1==key) or (self.key2 is not None and self.key2==key): return True else: return False def getChild(self,key): if key<self.key1: return self.left elif self.key2 is None: return self.middle elif key<self.key2: return self.middle else: return self.right class 2_3_Tree(object): def __init__(self): self.root=None def get(self,key): if self.root is None: return None else: return self._get(self.root,key) def _get(self,node,key): if node is None: return None elif node.hasKey(key): return node else: child=node.getChild(key) return self._get(child,key) def put(self,key): if self.root is None: self.root=Node(key) else: pKey,pRef=self._put(self.root,key) if pKey is not None: newnode=Node(pKey) newnode.left=self.root newnode.middle=pRef self.root=newnode def _put(self,node,key): if node.hasKey(key): return None,None elif node.isLeaf(): return self._addtoNode(node,key,None) else: child=node.getChild(key) pKey,pRef=self._put(child,key) if pKey is None: return None,None else: return self._addtoNode(node,pKey,pRef) def _addtoNode(self,node,key,pRef): if node.isFull(): return self._splitNode(node,key,pRef) else: if key<node.key1: node.key2=node.key1 node.key1=key if pRef is not None: node.right=node.middle node.middle=pRef else: node.key2=key if pRef is not None: node.right=Pref return None,None def _splitNode(self,node,key,pRef): newnode=Node(None) if key<node.key1: pKey=node.key1 node.key1=key newnode.key1=node.key2 if pRef is not None: newnode.left=node.middle newnode.middle=node.right node.middle=pRef elif key<node.key2: pKey=key newnode.key1=node.key2 if pRef is not None: newnode.left=Pref newnode.middle=node.right else: pKey=node.key2 newnode.key1=key if pRef is not None: newnode.left=node.right newnode.middle=pRef node.key2=None return pKey,newnode
3、平衡查找树之红黑树（Red-Black Tree）
     红黑树的定义

　　 红黑树是一种具有红色和黑色链接的平衡查找树，同时满足： 
　　   ① 红色节点向左倾斜 ；
　　   ②一个节点不可能有两个红色链接；
       ③整个树完全黑色平衡，即从根节点到所以叶子结点的路径上，黑色链接的个数都相同。

     红黑树的性质

     整个树完全黑色平衡，即从根节点到所以叶子结点的路径上，黑色链接的个数都相同（2-3树的第2）性质，从根节点到叶子节点的距离都相等）。

     复杂度分析

    最坏的情况就是，红黑树中除了最左侧路径全部是由3-node节点组成，即红黑相间的路径长度是全黑路径长度的2倍。 
　　下图是一个典型的红黑树，从中可以看到最长的路径(红黑相间的路径)是最短路径的2倍：

     算法实现
#红黑树
from random import randint

RED = 'red'
BLACK = 'black' class RBT: def __init__(self): # self.items = [] self.root = None self.zlist = [] def LEFT_ROTATE(self, x): # x是一个RBTnode y = x.right if y is None: # 右节点为空，不旋转 return else: beta = y.left x.right = beta if beta is not None: beta.parent = x p = x.parent y.parent = p if p is None: # x原来是root self.root = y elif x == p.left: p.left = y else: p.right = y y.left = x x.parent = y def RIGHT_ROTATE(self, y): # y是一个节点 x = y.left if x is None: # 右节点为空，不旋转 return else: beta = x.right y.left = beta if beta is not None: beta.parent = y p = y.parent x.parent = p if p is None: # y原来是root self.root = x elif y == p.left: p.left = x else: p.right = x x.right = y y.parent = x def INSERT(self, val): z = RBTnode(val) y = None x = self.root while x is not None: y = x if z.val < x.val: x = x.left else: x = x.right z.PAINT(RED) z.parent = y if y is None: # 插入z之前为空的RBT self.root = z self.INSERT_FIXUP(z) return if z.val < y.val: y.left = z else: y.right = z if y.color == RED: # z的父节点y为红色，需要fixup。 # 如果z的父节点y为黑色，则不用调整 self.INSERT_FIXUP(z) else: return def INSERT_FIXUP(self, z): # case 1:z为root节点 if z.parent is None: z.PAINT(BLACK) self.root = z return # case 2:z的父节点为黑色 if z.parent.color == BLACK: # 包括了z处于第二层的情况 # 这里感觉不必要啊。。似乎z.parent为黑色则不会进入fixup阶段 return # 下面的几种情况，都是z.parent.color == RED: # 节点y为z的uncle p = z.parent g = p.parent # g为x的grandpa if g is None: return # return 这里不能return的。。。 if g.right == p: y = g.left else: y = g.right # case 3-0:z没有叔叔。即：y为NIL节点 # 注意，此时z的父节点一定是RED if y == None: if z == p.right and p == p.parent.left: # 3-0-0:z为右儿子,且p为左儿子，则把p左旋 # 转化为3-0-1或3-0-2的情况 self.LEFT_ROTATE(p) p, z = z, p g = p.parent elif z == p.left and p == p.parent.right: self.RIGHT_ROTATE(p) p, z = z, p g.PAINT(RED) p.PAINT(BLACK) if p == g.left: # 3-0-1:p为g的左儿子 self.RIGHT_ROTATE(g) else: # 3-0-2:p为g的右儿子 self.LEFT_ROTATE(g) return # case 3-1:z有黑叔 elif y.color == BLACK: if p.right == z and p.parent.left == p: # 3-1-0:z为右儿子,且p为左儿子,则左旋p # 转化为3-1-1或3-1-2 self.LEFT_ROTATE(p) p, z = z, p elif p.left == z and p.parent.right == p: self.RIGHT_ROTATE(p) p, z = z, p p = z.parent g = p.parent p.PAINT(BLACK) g.PAINT(RED) if p == g.left: # 3-1-1:p为g的左儿子，则右旋g self.RIGHT_ROTATE(g) else: # 3-1-2:p为g的右儿子，则左旋g self.LEFT_ROTATE(g) return # case 3-2:z有红叔 # 则涂黑父和叔，涂红爷，g作为新的z，递归调用 else: y.PAINT(BLACK) p.PAINT(BLACK) g.PAINT(RED) new_z = g self.INSERT_FIXUP(new_z) def DELETE(self, val): curNode = self.root while curNode is not None: if val < curNode.val: curNode = curNode.left elif val > curNode.val: curNode = curNode.right else: # 找到了值为val的元素,正式开始删除 if curNode.left is None and curNode.right is None: # case1:curNode为叶子节点：直接删除即可 if curNode == self.root: self.root = None else: p = curNode.parent if curNode == p.left: p.left = None else: p.right = None elif curNode.left is not None and curNode.right is not None: sucNode = self.SUCCESOR(curNode) curNode.val, sucNode.val = sucNode.val, curNode.val self.DELETE(sucNode.val) else: p = curNode.parent if curNode.left is None: x = curNode.right else: x = curNode.left if curNode == p.left: p.left = x else: p.right = x x.parent = p if curNode.color == BLACK: self.DELETE_FIXUP(x) curNode = None return False def DELETE_FIXUP(self, x): p = x.parent # w:x的兄弟结点 if x == p.left: w = x.right else: w = x.left # case1:x的兄弟w是红色的 if w.color == RED: p.PAINT(RED) w.PAINT(BLACK) if w == p.right: self.LEFT_ROTATE(p) else: self.RIGHT_ROTATE(p) if w.color == BLACK: # case2:x的兄弟w是黑色的，而且w的两个孩子都是黑色的 if w.left.color == BLACK and w.right.color == BLACK: w.PAINT(RED) if p.color == BLACK: return else: p.color = BLACK self.DELETE_FIXUP(p) # case3:x的兄弟w是黑色的，而且w的左儿子是红色的，右儿子是黑色的 if w.left.color == RED and w.color == BLACK: w.left.PAINT(BLACK) w.PAINT(RED) self.RIGHT_ROTATE(w) # case4:x的兄弟w是黑色的，而且w的右儿子是红 if w.right.color == RED: p.PAINT(BLACK) w.PAINT(RED) if w == p.right: self.LEFT_ROTATE(p) else: self.RIGHT_ROTATE(p) def SHOW(self): self.DISPLAY1(self.root) return self.zlist def DISPLAY1(self, node): if node is None: return self.DISPLAY1(node.left) self.zlist.append(node.val) self.DISPLAY1(node.right) def DISPLAY2(self, node): if node is None: return self.DISPLAY2(node.left) print(node.val) self.DISPLAY2(node.right) def DISPLAY3(self, node): if node is None: return self.DISPLAY3(node.left) self.DISPLAY3(node.right) print(node.val) class RBTnode: '''红黑树的节点类型''' def __init__(self, val): self.val = val self.left = None self.right =

转载于:https://www.cnblogs.com/sjxm2017/p/10441861.html

weixin_30544657
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
四种经典查找算法（python实现）
sinceNow的博客
05-20 590
四种经典排序算法（python实现） 顺序查找 二分查找 差值查找 二叉树查找 一、顺序查找 ''' 顺序查找： 1.算法思想：顺序查找，对于一个无序序列，遍历数组中的所有元素，对比每一个元素是否和要查询 元素相等 2.时间复杂度：o(n) 3.空间复杂度：o(1) ''' 代码实现： def sequential_search(li, key): ...
Python如何实现的二分查找算法
09-16
总结起来，Python实现的二分查找算法主要涉及以下几个关键点： 1. 初始化搜索范围：`low`和`high`分别表示数组的起始和结束下标。 2. 计算中间位置：`mid = (low + high) // 2`，确保向下取整。 3. 比较中间元素：...
查找算法-Python
qq_39434183的博客
06-05 104
一，顺序查找 条件：无序或有序队列。 原理：按顺序比较每个元素，直到找到关键字为止。 时间复杂度：O(n) def sequential_search(lis, key): length = len(lis) for i in range(length): print(lis[i], key) if lis[i] == key: return i return False if __name__ == '__main__':
python-查找算法
adminwg的博客
09-02 2229
python-查找算法
python查找算法
weixin_49189239的博客
07-22 127
二分查找 # 返回 x 在 arr 中的索引，如果不存在返回 -1 def binarySearch(arr, l, r, x): # 基本判断 if r >= l: mid = int(l + (r - l) / 2) # 元素整好的中间位置 if arr[mid] == x: return mid # 元素小于中间位置的元素，只需要再比较左边的元素 elif arr
查找算法（Python 3.7）
day day up
04-09 721
1.二分查找 最优时间复杂度：O（1） 最坏时间复杂度：O（logn） 非递归法 ## 非递归 def binary_search(alist,item): first=0 last=len(alist)-1 while first<=last: mid=(first+last)//2 if alist[mid]==item: ...
python实现二分查找算法
09-21
### Python 实现二分查找算法 #### 算法简介 二分查找算法是一种高效的查找技术，它通过将目标值与有序数组中间元素进行比较，从而缩小搜索范围，实现快速定位目标值的目的。该算法的基本思想是：首先将待查找的...
简介二分查找算法与相关的Python实现示例
09-21
在本文中，我们将深入理解二分查找算法的基本思想，并通过Python代码示例来展示其具体实现。 二分查找的核心在于将查找问题分解为更小的子问题，直到找到目标值或确定目标值不存在。在每次迭代中，算法首先计算当前...
python有序查找算法 二分法实例解析
09-17
### Python有序查找算法：二分法实例解析 #### 一、引言 在计算机科学领域，数据结构与算法是核心的基础知识。对于有序数组或列表的查找操作，有一种高效的算法——**二分查找**（也称作折半查找）。本文将详细介绍...
KMP 算法 python实现
最新发布
10-10
KMP算法是一种高效字符串匹配算法,可以在一个字符串中快速查找子串。以下是使用KMP算法在Python中实现字符串匹配的步骤
4.查找算法（python）
qq_42720463的博客
02-27 1341
写在前面 小弟初识数据结构与算法，本文是个人的学习记录 4. 查找 4.1 算法综述 查找(Searching)的主要作用是通过一定的方法，在一些(有序或无序的)数据元素中找出与给定关键值相同的数据元素 按照操作方式可分成两种类别： 静态查找表：仅进行查找操作，不能改变表中的数据元素 动态查找表：在查找的同时进行创建、扩充、修改、删除等操作 具体的： 查找算法特性： 算法 结构 时间复杂度 ASL(平均查找长度) 最坏情况查找长度 线性查找 随意 O(N) (N+1)/2 N+1
查找算法与Python实现
weixin_39910711的博客
10-03 765
目录 1. 基本概念 2 无序表查找 2.1 顺序查找 2.1.1 算法简介 2.1.2 算法描述 2.1.3 python实现 2.1.4 算法评价 3 有序表查找 3.1 二分查找(Binary Search) 3.1.1 算法简介 3.1.2 算法描述 3.1.3 python实现 3.1.4 算法评价 3.2 插值查找 3.2.1 算法简介 3.2.2 算法...
python实现查找算法
m0_67656269的博客
03-31 1011
1.线性查找： 没啥好说的就是从列表第一个元素开始到列表末尾查找每一个元素，直到找到对应值，返回，没有就返回Fulse 2.二分查找（又叫折半查找） 1.思想： 1.就是从有序列表的初始候选区开始，通过对查找的值与候选区的值比较， 2.假如候选区的值都是从大到小的，然而中间值比查找的值要小，则去掉中间值以及中间值之前的数，如果比它大则之后的数， 3.然后接着从剩下的值中取中间值，与查找值比较，然后依次类推 2.简单的实例： 需求： 从列表【1，2，3，4，5，6，7，8，9】中找3 代码
七大查找算法（Python）
【CSDN官方推荐】
01-26 711
前言 本文的文字及图片来源于网络,仅供学习、交流使用,不具有任何商业用途,如有问题请及时联系我们以作处理。 PS：如有需要Python学习资料的小伙伴可以加点击下方链接自行获取 python免费学习资料、代码以及群交流解答点击即可加入 查找算法 -- 简介 查找（Searching）就是根据给定的某个值，在查找表中确定一个其关键字等于给定值的数据元素。 查找表（Search Table）：由同一类型的数据元素构成的集合 关键字（Key）：数据元素中某个数据项的值，又称为键值 主键（Primary
查找算法总结_python实现
越吃越胖的博客
07-22 326
1. 顺序查找 说明：顺序查找适合于存储结构为顺序存储或链接存储的线性表。 基本思想：顺序查找也称为线形查找，属于无序查找算法。从数据结构线形表的一端开始，顺序扫描，依次将扫描到的结点关键字与给定值k相比较，若相等则表示查找成功；若扫描结束仍没有找到关键字等于k的结点，表示查找失败。 复杂度分析：查找成功时的平均查找长度为：（假设每个数据元素的概率相等） ASL = 1/n(1+2+3+…+n) = (n+1)/2 ；当查找不成功时，需要n+1次比较，时间复杂度为O(n)。 def sequenceSear
(python)常用算法-查找算法
marst437730201的博客
08-21 2062
Python 中常用的算法有很多，分析一下实现的原理和demo.查找算法：顺序查找， 二分查找，插值查找， 哈希查找，二叉查找树， 平衡二叉查找树， B树， 布隆过滤器等.
经典查找算法及其Python实现
Kaiyuan_sjtu的博客
05-10 4816
写在前面 上一篇介绍了几大排序算法，从基本原理解释到Python代码实现，平时有空的话还需要经常翻出来复习复习。今天就主要来看看另外一大类算法：经典查找算法。 参考资料： 《大话数据结构》、《算法第4版》（配套视频：Algorithms, Part I，Algorithms, Part II） 本篇相关python代码已上传至Github：使劲儿点！ 1.基本概念 查找就是根据给定的某...
python查找算法有哪几种_实现基本有效的“搜索”算法：Python
weixin_42456278的博客
02-21 355
模拟搜索算法这是我的问题：在给定的文档(字符串)中，例如："hello there my name is dominic and my name is very special"和searchTerm(列表)，例如：['my','dominic'] or ['dominic','my'] (shouldn't matter)算法将返回包含以下内容的文档的最短摘录：>>> 'dom...
python之三大查找算法
hsw的博客
03-07 375
顺序查找   算法简介 顺序查找又称为线性查找，是一种最简单的查找方法。适用于线性表的顺序存储结构和链式存储结构。该算法的时间复杂度为O(n)。 基本思路 从第一个元素m开始逐个与需要查找的元素x进行比较，当比较到元素值相同(即m=x)时返回元素m的下标，如果比较到最后都没有找到，则返回-1。 优缺点 缺点：是当n 很大时，平均查找长度较大，效率低； 优点：是对表中数据元素的存储没有要求。另外，对...
二叉查找算法python
09-16
在Python中，可以使用递归来实现二叉查找算法。下面是一个简单的二叉查找算法的Python代码实现： ```python class Solution: def searchBST(self, root: TreeNode, val: int) -> TreeNode: if not root: return ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值