精华内容
下载资源
问答
  • 2021-10-09 22:35:04

    散列表

            哈希表(Hash table,也叫散列表),是根据关键码值(Key value)而直接进行访问的数据结构。也就是说,它通过把关键码值映射到表中一个位置来访问记录,以加快查找的速度。映射函数叫做散列函数,存放记录的数组叫做散列表。

    装填因子

            关键字个数 / 表长

    处理冲突

            一般来说冲突不可避免的,只能尽可能地减少冲突的发生。在建立Hash表的时候必须进行冲突处理。
            下面主要介绍线性探测法:也是一种比较常用的处理冲突的方法(但是极易产生堆积问题)

    • 线性探测法 即从发生冲突的地址(记做d)开始,依次探查d的下一个地址,直至找到一个空位置为止。记住这句话。查找时若查到空位置还没有找到需要查找的元素则说明不在列表中,结合前一句话理解一下,还是比较容易理解的。这个为后面计算查找失败的平均长度提供了计算思路。
    • 链地址法 通过单链表将关键字连接起来,利用这种方法不会产生堆积问题。但是所谓的堆积问题,并不能完全通过利用单链表法来避免。毕竟并不是适用于任何问题,在能够利用链地址法不能解决冲突的问题,也许利用线性探测法可以有着不错的效果。

    性能分析

    即本文的主要内容,查找成功与查找失败的分析。

    • 查找成功平均查找长度即找到表中已有表项的平均比较次数
    • 查找失败平均查找长度即找不到待查的表项但能找到插入位置的平均比较次数

    平均查找长度的计算

    直接以题目来理解会比较快些:

            现有长度为11 且初始为空的散列表HT,散列函数H(key) = key % 7,采用线性探查法解决冲突。将关键字序列87,40,30,6,11,22,98,20 依次插入HT后,HT的查找失败的平均长度是多少呢? 查找成功的平均查找长度又是多少呢?
            ① 首先,通过散列函数并且利用线性探测法给他们每个字划分好自己的位置;
            ② 记录每个字冲突的次数,后面在计算查找成功的平均长度会用到;
            ③ 查找失败计算每个查找失败对应地址的查找次数,即从所查位置开始往后查直至查到空位置位置;
            ④ 其实,后面熟悉过程之后,在列出下面的每个关键字对应地址的表格之后就可以秒出答案;

    注意事项 查找失败时对应的地址在这个题目,只能是7 即 0~6 ;

    ASL 查找失败= (9 + 8 + 7 + 6 + 5 + 4 + 3 )/ 7 = 6

    ASL 查找成功= (1 + 1 + 1 + 1 + 1 + 1 + 1 + 2)/ 8 = 9 / 8

    散列地址012345678910
    关键字982230871140620
    冲突次数00000001

    OK,上面把例子说完了,可以再看看下面这个题目,来测试下是否理解了上面的那些需要注意的点。
            将关键字序列(7,8,30,11,18,9,14)散列存储到散列表中。散列表的存储空间是从0开始的一维数组,散列函数为H(key) = (3*key)mod 7,处理冲突采用线性探测法,要求装填因子为0.7。
            (1)画出所构造的散列表。
            (2)分别计算等概率情况下的查找成功和不成功的平均查找长度。(12/7 和 18/7

    (1)数组大小 = 7 / 0.7 = 10

    散列地址0123456789
    关键字71481130189

    (2)
            ①查找成功时

    散列地址0123456789
    关键字71481130189
    冲突次数0100022
    比较次数1211133

            ASL 查找成功= (1 + 2 + 1 + 1 + 1 + 3 + 3 )/ 7 = 12 / 7
            ②查找失败时

    散列地址0123456789
    关键字71481130189
    比较次数3212154

            ASL 查找失败= (3 + 2 + 1 + 2 + 5 + 4)/ 7 = 18 / 7

    【总结】简单吧,主要就是查找失败时除以的分母是 mod 后面的那个数,而不是关键字的个数。

    更多相关内容
  • python list列表的乘除

    万次阅读 2020-04-30 20:46:05
    由于需要对列表数据整体处理,所以需要遍历整个 列表元素,这里 以全int型数据为例 x = [72, 50, 81, 74, 94, 86, 59, 83, 65, 33, 88, 81] x_=[] for i in x: i/=10 #对数据逐个处理 x_.append(i) x=x_ print(x) ...

    1

    由于需要对列表数据整体处理,所以需要遍历整个 列表元素,这里 以全int型数据为例

    x = [72, 50, 81, 74, 94, 86, 59, 83, 65, 33, 88, 81]
    x_=[]
    for i in x:
        i/=10   #对数据逐个处理
        x_.append(i)
    x=x_
    print(x)
    

    2

    上述是利用for 循环实现的,也可不用,如下:

    x = [72, 50, 81, 74, 94, 86, 59, 83, 65, 33, 88, 81]
    s=[10,10,10,10,10,10,10,10,10,10,10,10]
    xx=[a/b for a,b in zip(x,s)]     #利用该语句实现
    x=xx
    print(x)
    
    

    3

    还有一种情况假如要除的数是数值,但是由这个列表内数值计算出的,那么可以用

    x[:]=x[:]/x_std
    

    这条语句来实现,以下面例子来方便读者体会:

        x=[]
        y=[]
        data = [[72, 84], [50, 63], [81, 77], [74, 78], [94, 90], [86, 75], [59, 49], [83, 79], [65, 77], [33, 52],
                [88, 74], [81, 90]]
        for a,b in data:
            x.append(a)
            y.append(b)
        x_mean = np.mean(x)
        x_std = np.std(x)
        y_mean = np.mean(y)
        y_std = np.std(y)
        xx=[]
        yy=[]
        xx[:]=x[:]-x_mean
        xx[:]=x[:]/x_std
        yy[:]=y[:]-y_mean
        yy[:]=y[:]/y_std
    

    4

    当然 可以用numpy数组 ,将列表转为numpy数组,之后循环遍历也可以
    如下:

    import numpy as np
     
    a = np.array([1,1,1])  #这样的确简单,但考虑到可能你还需要再转回list类型,也可以不用这种方法,而用上面几种
    c = a/3
    print(c)
    

    注意以下是不可以的!!!

    a = [1.0, 1.0, 1.0]
    c = a/3          # 这样是不可以的
    #会出现 TypeError: unsupported operand type(s) for /: 'list' and 'int'
    print(c)
    

    另附笔记二维列表不能和数组一样循环遍历

    在这里插入图片描述

    另外对列表的拼接以及元素级的相加,还有相减,相乘等看下面这个blog:
    https://blog.csdn.net/jp_666/article/details/98055191?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-1&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-1

    展开全文
  • 在开放寻址中,所有的元素都存放在散列表里。也就是说,每个表项或包含动态集合的一个元素,或包含NoneNoneNone。当查找某个元素时,要系统地检查所有的表项,直到找到所需的元素,或者最终查明该元素不在表中。不...

    分类目录:《算法设计与分析》总目录
    相关文章:
    ·散列表[哈希表](一):基础知识
    ·散列表[哈希表](二):直接寻址表
    ·散列表[哈希表](三):散列表原理
    ·散列表[哈希表](四):散列函数
    ·散列表[哈希表](五):开放寻址法
    ·散列表[哈希表](六):完全散列


    在开放寻址法中,所有的元素都存放在散列表里。也就是说,每个表项或包含动态集合的一个元素,或包含 N o n e None None。当查找某个元素时,要系统地检查所有的表项,直到找到所需的元素,或者最终查明该元素不在表中。不像链接法,这里既没有链表,也没有元素存放在散列表外。因此在开放寻址法中,散列表可能会被填满,以至于不能插入任何新的元素。该方法导致的一个结果便是装载因子 a a a绝对不会超过1。

    开放寻址法的核心思想是,如果出现了散列冲突,我们就重新探测一一个空闲位置,将其插入。比如,我们可以使用线性探测法。当我们往散列表中插入数据时,如果某个数据经过散列函数散列之后,存储位置已经被占用了,我们就从当前位置开始,依次往后查找,看是否有空闲位置,如果遍历到尾部都没有找到空闲的位置,那么我们就再从表头开始找,直到找到为止。

    当然,也可以将用作链接的链表存放在散列表未用的槽中,但开放寻址法的好处就在于它不用指针,而是计算出要存取的槽序列。于是,不用存储指针而节省的空间,使得可以用同样的空间来提供更多的槽,潜在地减少了冲突,提高了检索速度。

    为了使用开放寻址法插入一个元素,需要连续地检查散列表,或称为探查,直到找到一个空槽来放置待插入的关键字为止。检查的顺序不一定是 0 , 1 , ⋯   , m − 1 0, 1, \cdots, m-1 0,1,,m1,而是要依赖于待插入的关键字。为了确定要探查哪些槽,我们将散列函数加以扩充,使之包含探查号以作为其第二个输入参数。这样,散列函数就变为:
    h : U × { 0 , 1 , ⋯   , m − 1 } → { 0 , 1 , ⋯   , m − 1 } h:U×\{0, 1, \cdots, m-1\}\rightarrow \{0, 1, \cdots, m-1\} h:U×{0,1,,m1}{0,1,,m1}
    对每一个关键字 k k k,使用开放寻址法的探查序列是 < 0 , 1 , ⋯   , m − 1 > <0, 1, \cdots, m-1> <0,1,,m1>的一个排列,使得当散列表逐渐填满时,每一个表位最终都可以被考虑为用来插入新关键字的槽。

    查找关键字 k k k的算法的探查序列与将 k k k插入时的算法一样。因此,查找过程中碰到一个空槽时,查找算法就(非成功地)停止,因为如果 k k k在表中,它就应该在此处,而不会在探查序列随后的位置上(之所以这样说,是假定了关键字不会从散列表中删除)。

    从开放寻址法的散列表中删除操作元素比较困难。当我们从槽 i i i中删除关键字时,不能仅将 N o n e None None置于其中来标识它为空。如果这样做,就会有问题:在插入关键字 k k k时,发现槽 i i i被占用了,则就被插人到后面的位置上;此时将槽 i i i中的关键字删除后,就无法检索到关键字 k k k了。

    有一个解决办法,就是在槽 i i i中置一个特定的值 D E L E T E D DELETED DELETED替代 N o n e None None来标记该槽。这样就将这样的一个槽当做空槽,使得在此仍然可以插入新的关键字。

    线性探查

    给定一个普通的散列函数 h ′ : U → { 0 , 1 , ⋯   , m − 1 } h':U\rightarrow \{0, 1, \cdots, m-1\} h:U{0,1,,m1},称之为辅助,线性探查方法采用的散列函数为:
    h ( k , i ) = ( h ′ ( k ) + i ) m o d    m h(k ,i)=(h'(k)+i)\mod m\quad h(k,i)=(h(k)+i)modm
    给定一个关键字 k k k,首先探查槽 T [ h ′ ( k ) ] T[h'(k)] T[h(k)],即由辅助散列函数所给出的槽位。再探查槽T T [ h ′ ( k ) + 1 ] T[h'(k)+1] T[h(k)+1],依此类推,直至槽 T [ m − 1 ] T[m-1] T[m1]。然后,又绕到槽 T [ 0 ] , T [ 1 ] , ⋯ T[0], T[1], \cdots T[0],T[1],直到最后探查到槽 T [ h ′ ( k ) − 1 ] T[h'(k)-1] T[h(k)1]。在线性探查方法中,初始探查位置决定了整个序列,故只有 m m m种不同的探查序列。

    线性探査方法比较容易实现,但它存在着一个问题,称为一次群集。随着连续被占用的槽不断增加,平均査找时间也随之不断增加。群集现象很容易出现,这是因为当个空槽前有 i i i个满的槽时,该空槽为下一个将被占用的概率是 i + 1 m \frac{i+1}{m} mi+1。连续被占用的槽就会变得越来越长,因而平均查找时间也会越来越大。

    二次探查

    二次探查采用如下形式的散列函数:
    h ( k , i ) = ( h ′ ( k ) + c 1 i + c 2 i 2 ) m o d    m h(k ,i)=(h'(k)+c_1i+c_2i^2)\mod m\quad h(k,i)=(h(k)+c1i+c2i2)modm
    其中 h ′ h' h是一个辅助散列函数, c 1 c_1 c1 c 2 c_2 c2为正的辅助常数。初始的探查位置为 T [ h ′ ( k ) ] T[h'(k)] T[h(k)],后续的探查位置要加上一个偏移量,该偏移量以二次的方式依赖于探查序号 i i i。这种探查方法的效果要比线性探查好得多,但是,为了能够充分利用散列表, c 1 c_1 c1 c 2 c_2 c2 m m m的值要受到限制。此外,如果两个关键字的初始探查位置相同,那么它们的探查序列也是相同的,这是因为 h ( k 1 , 0 ) = h ( k 2 , 0 ) h(k_1,0)=h(k_2,0) h(k1,0)=h(k2,0)蕴涵着 h ( k 1 , i ) = h ( k 2 , i ) h(k_1,i)=h(k_2,i) h(k1,i)=h(k2,i)。这一性质可导致一种轻度的群集,称为二次群集。像在线性探查中一样,初始探查位置决定了整个序列,这样也仅有 m m m个不同的探查序列被用到。

    双重散列

    双重散列是用于开放寻址法的最好方法之一,因为它所产生的排列具有随机选择排列的许多特性。双重散列采用如下形式的散列函数:
    h ( k , i ) = ( h 1 ( k ) + i h 2 ( k ) ) m o d    m h(k ,i)=(h_1(k)+ih_2(k))\mod m\quad h(k,i)=(h1(k)+ih2(k))modm

    其中 h 1 h_1 h1 h 2 h_2 h2均为辅助散列函数。初始探查位置为 T [ h 1 ( k ) ] T[h_1(k)] T[h1(k)],后续的探查位置是前一个位置加上偏移量 h 2 ( k ) h_2(k) h2(k) m m m。因此,不像线性探查或二次探查,这里的探查序列以两种不同方式依赖于关键字 k k k,因为初始探查位置、偏移量或者二者都可能发生变化。下图给出了一个使用双重散列法进行插入的例子。
    双重探查

    为了能查找整个散列表,值 h 2 ( k ) h_2(k) h2(k)必须要与表的大小 m m m互质。当 m m m为素数或者2的幂时,双重散列法中用到了 Θ ( m 2 ) \Theta(m^2) Θ(m2)种探查序列,而线性探查或二次探查中用了 Θ ( m ) \Theta(m) Θ(m)种,故前者是后两种方法的种改进。因为每一对可能的 ( h 1 ( k ) , h 2 ( k ) (h_1(k), h_2(k) (h1(k),h2(k)都会产生一个不同的探查序列。因此,对于 m m m的每一种可能取值,双重散列的性能看起来就非常接近“理想的”均匀散列的性能。

    尽管除素数和2的幂以外的 m m m值在理论上也能用于双重散列中,但是在实际中,要高效地产生 h 2 ( k ) h_2(k) h2(k)确保使其与 m m m互质,将变得更加困难。部分原因是这些数的相对密度中可能较小。

    开放寻址散列的分析

    像在链接法中的分析一样,开放寻址法的分析也是以散列表的装载因子 a = n m a=\frac{n}{m} a=mn来表达的当然,使用开放寻址法,每个槽中至多只有一个元素,因而 n ≤ m n≤m nm,也就意味着 a ≤ 1 a≤1 a1

    假设采用的是均匀散列。在这种理想的方法中,用于插入或查找每一个关键字 k k k的探查序列等可能地为 < 0 , 1 , ⋯   , m − 1 > <0, 1, \cdots, m-1> <0,1,,m1>的任意一种排列。当然,每一个给定的关键字有其相应的唯一固定的探查序列。我们这里想说的是,考虑到关键字空间上的概率分布及散列函数施于这些关键字上的操作,每一种探查序列都是等可能的。

    现在就来分析在均匀散列的假设下,用开放寻址法来进行散列时探查的期望次数。则:

    1. 给定一个装载因子为 a = n m < 1 a=\frac{n}{m}<1 a=mn<1的开放寻址散列表,并假设是均匀散列的,则对于一次不成功的查找,其期望的探查次数至多为 1 1 − a \frac{1}{1-a} 1a1
    2. 假设采用的是均匀散列,平均情况下,向一个装载因子为 a a a的开放寻址散列表中插入一个元素至多需要做 1 1 − a \frac{1}{1-a} 1a1次探查。
    3. 对于一个装载因子为 a < 1 a<1 a<1的开放寻址散列表,一次成功查找中的探查期望数至多为 1 a ln ⁡ 1 1 − a \frac{1}{a}\ln\frac{1}{1-a} a1ln1a1
    展开全文
  • 列表相关题目(线性探测再散列

    千次阅读 多人点赞 2020-12-02 02:05:00
    列表相关题目(线性探测再散列) 一、题目 将关键字序列(7、8、30、11、18、9、14)散列存储到散列表中。散列表的存储空间是一个下标从0开始的一维数组,散列函数为H(key)=(key×3) mod 7,处理冲突采用线性...

    散列表相关题目(线性探测再散列法)


    一、题目

    将关键字序列(7、8、30、11、18、9、14)散列存储到散列表中。散列表的存储空间是一个下标从0开始的一维数组,散列函数为H(key)=(key×3) mod 7,处理冲突采用线性探测再散列法,要求装填(载)因子为0.7。

    1)请画出所构造的散列表。

    2)分别计算等概率情况下查找成功和查找不成功的平均查找长度。

    二、解题思路及步骤

    下面是详细的解题过程及方法思路

    ①第(1)问

    在这里插入图片描述

    ②第(2)问

    在这里插入图片描述

    总结

    (1)注意红字部分的内容!!!
    (2)注意在使用线性探测再散列法找地址时,位置为(H(key)mod表长,此处为10),不是题干给出的哈希函数的7!!!
    (3)计算查找失败的ASL时,要考虑初始地址的范围,是题目中所给出的哈希函数中mod后面的值,本题中为7,范围为0~6。注意不是10!!!

    展开全文
  • 【哈希表 | 散列表】根据关键字的值来计算出关键字在表中的地址 address = H(key) 【哈希函数|散列函数】函数H(key) 举例 构造 查找 查找成功的分析 查找失败的分析 构造哈希函数 哈希函数...
  • Python数据结构-列表

    千次阅读 多人点赞 2021-12-24 10:29:01
    2.3 解析列表 在实际Python使用中,会有很多地方使用到列表,所以Python提供了一种用于创建列表的特殊表示列表解析。下面举例如何使用列表解析来创建 一个由 1~10 的平方组成的列表: 这种表示的主要优点是...
  • python 列表元组加减乘除

    千次阅读 2019-10-07 18:23:16
    元组(typle)列表(list)没有减法和除,但有加法和乘法。 1、加法,即把元素相加。只可以list和tuple相加,不能加其他类型。 t= (1, ) + (2, 3, 4) print(t, type(t))  输出为 (1, 2, 3, 4) <class '...
  • 列表的乘法

    千次阅读 2020-02-25 14:29:58
    a=list(range(1,6)) a ## 方法一 ...##如果列表直接乘5,表示将列表复制五倍,而不是每个元素都乘5 a*5 ##加载一个numpy包 import numpy as np np.array(a) ##此时直接乘5即可实现之前操作 ...
  • 列表之开放定址

    万次阅读 2015-07-12 00:13:46
    列表之开放定址列表的基本操作 插入操作_INSERT 查找操作_SEARCH 删除操作_DELETE 散列表的探查方法probe methods 散列表探查的定义 线性探查 二次探查 双重散列 总结注意: 本文中所有的代码你可以在这里:...
  • 前言 排序(Sorting) 是计算机程序设计中的一种重要操作,它的功能是将一个数据元素(或...通过对列表里的元素大小排序进行阐述。 原文地址:https://blog.zeruns.tech/index.php/archives/297/ 一、选择排序 选择...
  • 作者:闲鱼技术-齐悟玩平台背景    在闲鱼内我们把供给用户的闲鱼红包、支付宝红包、包邮券、宝卡等统称为用户权益。是闲鱼用户运营的重要策略,在拉新、留存、促活、裂变等方面都展现了其...
  • Python基础之:数字字符串和列表

    千次阅读 2021-02-22 19:13:04
    Python的主要应用是进行科学计算,科学计算的基础就是数字,字符串和列表。本文将会详细的给大家介绍一下这三个数据类型的使用情况。
  • 盘点Python列表生成式的三种方法

    千次阅读 2021-02-06 09:03:00
    点击上方“Go语言进阶学习”,进行关注回复“Go语言”即可获赠从入门到进阶共10本电子书今日鸡汤兴来每独往,胜事空自知。一、前言列表生成式即List Comprehensions,是Pyt...
  • 【数据结构】散列表知识点

    千次阅读 2021-04-16 09:29:56
    散列存储:散列表,采用的存储方式是散列存储。那么何为散列存储呢?散列存储是根据元素的关键字直接计算出该元素的存储地址,又称哈希(Hash)存储。采用散列存储的方式存储数据时,具备的优点是在散列表中检索、...
  • 数据结构——拉链(链地址

    千次阅读 2019-12-10 20:54:16
    当存储结构是链表时,多采用拉链,用拉链处理冲突的办法是:把具有相同散列地址的关键字(同义词)值放在同一个单链表中,称为... 例如,按上面例9.4所给的关键字序列,用拉链构造散列表如图9.14所示。  ...
  • 分治( Divide and Conquer)

    千次阅读 2021-12-05 17:08:05
    分治也称为分解、分治策略等。本文梳理下梳理下分治
  • 分别用二分法、试位、不动点迭代、Newton-Raphson和割线求解并比较各方法的收敛速度
  • 列表-拉链

    千次阅读 2014-09-30 11:48:29
    若选定的散列表长度为m,则可将散列表定义为一个由m个头指针组成的指针数组T[0..m-1]。凡是散列地址为i的结点,均插入到以T[i]为头指针的单链表中。T中各分量的初值均应为空指针。在拉链中,装填因子α可以大于1,...
  • 数字电路基础知识——数字逻辑代数(逻辑代数公式、卡洛图的运用、Q-M法化简(列表法)) 本节主要介绍逻辑代数的公式、及逻辑函数的化简、包括公式法化简、卡洛图化简、Q-M列表法化简。 一、逻辑代数的三个基本运算 ...
  • 所谓的开放定址就是一旦发生了冲突,就去寻找下一个空的散列地址,只要散列表足够大,空的散列地址总能找到,并将记录存入。 公式为: fi(key) = (f(key)+di) MOD m (di=1,2,3,......,m-1) 用开放定址解决冲突...
  • 1.链地址 #include <stdio.h> #include <stdlib.h> #include <math.h> #define maxSize 100 typedef struct ListNode { int element; struct ListNode* next; }ListNode; typedef ListNode...
  • 列表及散列冲突解决方案

    千次阅读 2019-06-21 12:42:06
    在我们put了一条key-value数据后,如下图,程序会先将key通过hash(key)这个函数转化成整形,这个整形为数组的下标,插入数据或查找数据。 我们发现,散列表用的是数组支持按照下标随机访问数据的特性(时间...
  • 简而言之,她们的区别在于:前者让散列表做的“对”(把冲突元素按规则安排到合理位置),后者让散列表具有了可扩充性,可以动态调整(不用担心填满了怎么办)。 双散列 我们来考察最后一个冲突解决方法,双散列...
  • 列表查找失败平均查找长度

    万次阅读 多人点赞 2020-11-01 21:04:40
    要想知道 散列表查找失败的平均查找长度,就要知道什么叫做查找失败!举个栗子:8个数字 key%11 如下算好了: 散列地址 0 1 2 3 4 5 6 7 8 9 10 关键字 33 1 13 12...
  • 要给出要筛数值的范围n,找出以内的素数。先用2去筛,即把2留下,把2的倍数剔除掉;再用下一个质数,也就是3筛,把3留下,把3的倍数剔除掉;接下去用下一个质数5筛,把5留下,把5的倍数剔除掉;...
  • 耳切处理多边形三角划分

    万次阅读 多人点赞 2016-10-18 09:23:04
    2016.10.18 孙广东 ...  日文《 ...抱歉, 我下面也只是一个粘贴而已。 和一些自己当时的理解       使用EarClipping三角化多边形(翻译) ---Triangulation by Ear Clipping( ...
  • python 列表编写 刮刮乐游戏

    千次阅读 多人点赞 2020-04-03 17:36:28
    列表的方式编写刮刮乐 # 刮刮乐 import random #使用乱序 reward = ['谢谢惠顾', '谢谢惠顾', '谢谢惠顾', '谢谢惠顾', '谢谢惠顾', '一等奖', '二等奖', '三等奖'] random.shuffle(reward) print(reward) num = ...
  • matlab实现二分法、牛顿与割线

    千次阅读 2021-09-13 07:17:41
    matlab实现二分法、牛顿与割线求方程的解欢迎使用Markdown编辑器二分法二分法的matlab代码功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你...
  • Python列表实现斐波那契数列

    千次阅读 2020-02-10 00:00:00
    对于这个问题我们可以分别让0,1作为列表的前两项,再将前两项的和添加进列表中,并不断下去这样就可以得到我们想要的项了。 (1)设置输入和列表 i = eval(input("请输入第几项:")) list = [0,1] n = 2 (2)建立...
  • 接下来我们看冲突处理中的平方探测(终于写出来了- -、),平方探测顾名思义就是探测增量是1²、-1²、2²、-2²…(线性探测是1、2、3、4……),平方探测与线性探测有点不同,线性探测是查找位置发生冲突后,就...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 215,286
精华内容 86,114
关键字:

列表法怎么做