精华内容
下载资源
问答
  • 手撕代码3.1 创建graph3.2 创建队列3.3创建判断函数3.4 检查代码4.完整代码 在谈广度优先遍历之前,我们需要知道图是什么。 1.图 ​ 图(graph)是表示物件物件之间关系的数学对象,是图论的基本研究对象,图由...

    在谈广度优先遍历之前,我们需要知道图是什么。

    1.图

    ​ 图(graph)是表示物件与物件之间关系的数学对象,是图论的基本研究对象,图由节点(node)和边(edge)组成。图分为两种:1.有向图、2.无向图。

    1.1有向图

    ​ 有向图就类似于我们去打牌,如果A欠B5元,则有一条线段从A指向B,如果B欠A5元,那么就又有一条线由B指向A,这个5元我们称之为权重(weight)。

    在这里插入图片描述

    1.2 无向图

    ​ 如果有一条线段是由A指向B,并且B指向A。那么这两条线段可以合成一条无箭头的线段在A于B中间。
    在这里插入图片描述

    ​ 如果当参加打牌的人数变多时,关系也会变的复杂,如下图所示

    在这里插入图片描述

    ​ 上面表示ALEX欠RAMA钱,RAMA欠ADIT钱,TOM欠RAMA和ADIT的钱。

    ​ 就这么简单!图由节点和边组成。一个节点可能与众多节点直接相连,这些节点被称为邻居。在前面的欠钱图中,Rama是Alex的邻居。Adit不是Alex的邻居,因为他们不直接相连。但Adit既 是Rama的邻居,又是Tom的邻居。

    ​ 图用于模拟不同的东西是如何相连的。

    2.广度优先遍历

    ​ 广度优先搜索是一种用于图的查找算法,可帮助回答两类问题。

    • 第一类问题:从节点A出发,有前往节点B的路径吗?
    • 第二类问题:从节点A出发,前往节点B的哪条路径最短?

    ​ 下面我们举个简单的栗子来理解一下广度优先遍历的妙处。

    ​ 假设你是一个木材厂的老板,你手中有一批上等的好木头,需要寻找一个木材爱好者,把木头卖给他。因此你可以在微信中查找你的朋友是否是木材爱好者或者你可以发朋友圈问朋友他们的朋友中是否有木材爱好者。

    ​ 为此,你首先在朋友中查找。这种查找很简单。首先,创建一个朋友名单。然后,一次查找名单中的每个人,看看他们是否是木材爱好者。

    ​ 假设你没有朋友是木材爱好者,那么你就必须在朋友的朋友中查找。检查名单中的每个人时,你都将其朋友加入名单。

    ​ 这样一来,你不仅在朋友中查找,还在朋友的朋友中查找。别忘了,你的目标是在你的人际关系网中找到一位木材爱好者。因此,如果A不是木材爱好者,就将其朋友也加入到名单中。这意味着你将在她的朋友、朋友的朋友等中查找。使用这种算法将搜遍你的整个人际关系网,直到找到木材爱好者。这就是广度优先搜索算法。

    ​ 那么python中如何来实现呢?我们需要引入队列(deque)。队列支持两种操作:入队和出队。

    ​ 如果你将两个元素加入队列,先加入的元素将在后加入的元素之前出队。因此,你可使用队列来表示查找名单!这样,先加入的人将先出队并先被检查。

    ​ 队列是一种先进先出(First In First Out,FIFO)的数据结构,而栈是一种后进先出(Last In First Out,LIFO)的数据结构。

    3.手撕代码

    ​ 首先,需要使用代码来实现图。图由多个节点组成。每个节点都与邻近节点相连,如果表示类似于“你→Bob”这样的关系呢?它就是字典!

    ​ 我们可以用字典来将你的所有邻居存入以你为关键字,以邻居为值的字典中。
    在这里插入图片描述

    ​ 我们现在来帮木材商(A)查找木材爱好者(I)吧

    3.1 创建graph表

    ​ 我们知道,对于A来说,他有["B","C","F"]三个朋友,B没有朋友,因此为[]。按照这个思路我们就可以构造出如下的一个表

    graph = {}
    graph["A"] = ["B","C","F"]
    graph["B"] = []
    graph["C"] = ["E","F","D"]
    graph["D"] = ["H","G"]
    graph["E"] = ["I"]
    graph["F"] = []
    graph["G"] = []
    graph["H"] = ["I"]
    graph["I"] = []
    

    3.2 创建队列

    ​ 对于队列,我们可以调用python强大的库collections里的deque(另一篇文章有讲该库,可去查看一下)来创建一个双端队列

    from collections import deque  # 从collections库中导入deque类
    search_pepole = deque()  # 创建一个队列
    search_pepole += graph["A"]  # 将A的朋友加入到队列中
    

    3.3创建判断函数

    def person_is_seller(person):  # 创建判断函数,查看该人是否是I
        return person == "I"
    
    
    while search_people:  # 如果队列不为空
        person = search_people.popleft()  # 取出当前队列的第一个人
        if person_is_seller(person):  # 检查这个人是否是I
            print(person + " is a love tree'people!")  # 是I
            break
        else:
            search_people += graph[person]  # 如果不是,则把这个人的朋友都加入到队列张红
    

    3.4 检查代码

    ​ 回去看一下代码,我们会发现,如果B是C的朋友,C是D的朋友,D又是B的朋友,那么我们就会将整个循环进入一个无限的循环之中,我们可以添加一个列表,用来存储已经被查找过的用户

    def search(name):
        search_people = deque()  # 创建一个队列
        search_people += graph[name]  # 将name的朋友加入到队列中
        searched = []
        while search_people:  # 如果队列不为空
            person = search_people.popleft()  # 取出当前队列的第一个人
            if not person in searched:  # 如果这个人没有被查找过
                if person_is_seller(person):  # 检查这个人是否是I
                    print(person + " is a love tree'people!")  # 是I
                    break
                else:
                    search_people += graph[person]  # 如果不是,则把这个人的朋友都加入到队列张红
        return False
    

    4.完整代码

    # -*- coding: utf-8 -*-
    from collections import deque  # 从collections库中导入deque类
    
    graph = {}
    graph["A"] = ["B", "C", "F"]
    graph["B"] = []
    graph["C"] = ["E", "F", "D"]
    graph["D"] = ["H", "G"]
    graph["E"] = ["I"]
    graph["F"] = []
    graph["G"] = []
    graph["H"] = ["I"]
    graph["I"] = []
    
    
    def person_is_seller(person):  # 创建判断函数,查看该人是否是I
        return person == "I"
    
    
    def search(name):
        search_people = deque()  # 创建一个队列
        search_people += graph[name]  # 将name的朋友加入到队列中
        searched = []
        while search_people:  # 如果队列不为空
            person = search_people.popleft()  # 取出当前队列的第一个人
            if not person in searched:  # 如果这个人没有被查找过
                if person_is_seller(person):  # 检查这个人是否是I
                    print(person + " is a love tree'people!")  # 是I
                    break
                else:
                    search_people += graph[person]  # 如果不是,则把这个人的朋友都加入到队列张红
        return False
    
    search("A")
    
    展开全文
  • 散列函数“将输入映射到数字”散列函数总是将同样的输入映射到相同的索引散列函数将不同的输入映射到不同的索引散列函数知道数组有多大,只返回有效的索引而散列表也使用数组来存储数据,因此其获取元素的速度数组...

    第五章 散列表

    • 散列函数“将输入映射到数字”
    • 散列函数总是将同样的输入映射到相同的索引
    • 散列函数将不同的输入映射到不同的索引
    • 散列函数知道数组有多大,只返回有效的索引
    • 而散列表也使用数组来存储数据,因此其获取元素的速度与数组一样快。

    散列表适合用于

    • 模拟映射关系;
    • 防止重复;
    • 缓存/记住数据,以免服务器再通过处理来生成它们。

    • 如果两个键映射到了同一个位置,就在这个位置储存一个链表

    经验

    • 散列函数很重要。前面的散列函数将所有的键都映射到一个位置,而最理想的情况是,
      散列函数将键均匀地映射到散列表的不同位置。
    • 如果散列表存储的链表很长,散列表的速度将急剧下降。然而,如果使用的散列函数很
      好,这些链表就不会很长!

    • 在最糟情况下,散列表所有操作的运行时间都为O(n)——线性时间

    • 在平均情况下,散列表的查找(获取给定索引处的值)速度与数组一样快,而插入和删除速
      度与链表一样快,因此它兼具两者的优点!但在最糟情况下,散列表的各种操作的速度都很慢。

    • 因此,在使用散列表时,避开最糟情况至关重要。为此,需要避免冲突。而要避免冲突,需要有1.较低的填装因子2.良好的散列函数。

    • 填装因子大于1意味着商品数量超过了数组的位置数。一旦填装因子开始增大,你就需要在散列表中添加位置,这被称为调整长度(resizing)。

    • 一个不错的经验规则是:一旦填装因子大于0.7,就调整散列表的长度。

    • 什么样的散列函数是良好的呢?你根本不用操心——天塌下来有高个子顶着。如果你好奇,
      可研究一下SHA函数

    小结

    • 你几乎根本不用自己去实现散列表,因为你使用的编程语言提供了散列表实现。你可使用
      Python提供的散列表,并假定能够获得平均情况下的性能:常量时间。

    • 散列表是一种功能强大的数据结构,其操作速度快,还能让你以不同的方式建立数据模型。
      你可能很快会发现自己经常在使用它。

    • 你可以结合散列函数和数组来创建散列表。
    • 冲突很糟糕,你应使用可以最大限度减少冲突的散列函数。
    • 散列表的查找、插入和删除速度都非常快。
    • 散列表适合用于模拟映射关系。
    • 一旦填装因子超过0.7,就该调整散列表的长度。
    • 散列表可用于缓存数据(例如,在Web服务器上)。
    • 散列表非常适合用于防止重复。

    第六章 广度优先搜索

    • 广度优先搜索指出是否有从A到B的路径。
    • 如果有,广度优先搜索将找出最短路径。
    • 面临类似于寻找最短路径的问题时,可尝试使用图来建立模型,再使用广度优先搜索来
      解决问题。
    • 有向图中的边为箭头,箭头的方向指定了关系的方向,例如,rama→adit表示rama欠adit钱。
    • 无向图中的边不带箭头,其中的关系是双向的,例如,ross - rachel表示“ross与rachel约
      会,而rachel也与ross约会”。
    • 队列是先进先出(FIFO)的。
    • 栈是后进先出(LIFO)的。
    • 你需要按加入顺序检查搜索列表中的人,否则找到的就不是最短路径,因此搜索列表必
      须是队列。
    • 对于检查过的人,务必不要再去检查,否则可能导致无限循环。
    展开全文
  • SetMapperFlags Windows对字体进行映射时,可用该函数选择目标设备的纵横比相符的光栅字体 SetTextAlign 设置文本对齐方式,并指定在文本输出过程中使用设备场景的当前位置 SetTextCharacterExtra 描绘文本的...
  • 一判断题正确的在括号内画错的画每小题2分共10分 1算符优先关系表不一定存在对应的优先函数 2数组元素的地址计算数组的存储方式有关 3仅考虑一个基本块不能确定一个赋值是否真是无用的 4每个文法都能改写为LL(1)...
  • 1. 数据结构算法简介 数据结构: 计算机存储, 组织数据的方式, 就像锅碗瓢盆 算法: 一系列解决问题的清晰指令, 就像食谱 两者关系: 程序 = 数据结构 + 算法 将要学习的数据结构: 有序的: 栈 , 队列 , 链表 无序的:...

    1. 数据结构与算法简介

    数据结构: 计算机存储, 组织数据的方式, 就像锅碗瓢盆

    算法: 一系列解决问题的清晰指令, 就像食谱

    两者关系: 程序 = 数据结构 + 算法

    将要学习的数据结构:
    有序的: 栈 , 队列 , 链表
    无序的: 集合 , 字典
    树 , 堆 , 图

    将要学习的算法:
    链表: 遍历链表, 删除链表节点
    树, 图 : 深度 / 广度优先遍历
    数组: 冒泡 / 选择 / 插入 / 归并 / 快速排序 , 顺序 / 二分搜索

    2. 时间复杂度和空间复杂度

    时间复杂度:
    一个函数, 用大O表示, 比如O(1), O(n), O(logN)…
    定性(大概)描述该算法的运行时间
    时间复杂度

    O(1): 
    ------------
    let i = 0;
    i += 1
    // 每次执行该代码, 这两行代码永远只会被执行一次, 里面没有任何循环等等
    
    O(n): 
    ------------
    for(let i = 0; i < n; i += 1) {
    	console.log(i)
    }
    // for循环里的代码执行了n次
    
    O(1) + O(n) = O(n): 
    ------------
    let i = 0;
    i += 1
    for(let j = 0; j < n; j += 1) {
    	console.log(j)
    }
    // O(1)近似忽略不计
    
    O(n) * O(n) = O(n^2): 
    ------------
    for(let i = 0; i < n; i += 1) {
    	for(let j = 0; j < n; j += 1) {
    		console.log(i,j)
    	}
    }
    
    O(logN): 
    ------------
    let i = 1;
    while(i < n) {
    	console.log(i);
    	i *= 2;
    }
    

    空间复杂度:
    一个函数, 用大O表示, 比如O(1), O(n), O(n^2)…
    算法在运行过程中临时占用存储空间大小的量度

    O(1): 
    ------------
    let i = 0;
    i += 1
    // 只声明了单个变量, 单个变量占用的内存始终为1
    
    O(n): 
    ------------
    const list = [];
    for(let i = 0; i < n; i += 1) {
    	list.push(i)
    }
    // 声明了名为list的数组, 数组里添加了n个值,相当于占用了n个内存单元
    
    O(n^2): 
    ------------
    const matrix = [];
    for(let i = 0; i < n; i += 1) {
    	matrix.push([]);
    	for(let j = 0; j < n; j += 1) {
    	matrix[i].push(j);
    	}
    }
    // 实际上是个矩阵, 前端里做栅格布局的行列, 矩阵的本质是个二维数组, 
    // 嵌套了两层的数组, 存储了n^2的变量, 所以空间复杂度是O(n^2)
    
    展开全文
  • 更确切地说, 数据结构是数据值的集合, 它们之间的关系函数或操作可以应用于数据。 B - 初学者, A - 进阶 B 链表 B 双向链表 B 队列 B 栈 B 哈希 B 堆 B 优先队列 A 字典树 A 树 A 二叉查找树 ...

    数据结构

    数据结构是在计算机中 组织和存储数 据的一种特殊方式, 它可以高效地 访问和修改 数据。更确切地说, 数据结构是数据值的集合, 它们之间的关系、函数或操作可以应用于数据。

    B - 初学者, A - 进阶

    • B 链表

    • B 双向链表

    • B 队列

    • B 栈

    • B 哈希表

    • B 堆

    • B 优先队列

    • A 字典树

    • A 树

      A 二叉查找树
      
      A AVL 树
      
      A 红黑树
      
      A 线段树 - 使用 最小/最大/总和 范围查询示例
      
      A 树状数组 (二叉索引树)
      
    • A 图 (有向图与无向图)

    • A 并查集

    • A 布隆过滤器

    算法

    算法是如何解决一类问题的明确规范。 算法是一组精确定义操作序列的规则。

    算法主题

    数学

    • B Bit 操控 - set/get/update/clear 位, 乘以/除以 二进制位, 变负 等.

    • B 阶乘

    • B 斐波那契数

    • B 素数检测 (排除法)

    • B 欧几里得算法 - 计算最大公约数 (GCD)

    • B 最小公倍数 (LCM)

    • B 素数筛 - 查找所有素数达到任何给定限制

      -B 判断2次方数 - 检查数字是否为2的幂 (原生和按位算法)

    • B 杨辉三角形

    • A 整数拆分

    • A 割圆术 - 基于N-gons的近似π计算

    • 集合

       B 笛卡尔积 - 多集合结果
       
       A 幂集 - 该集合的所有子集
       
       A 排列 (有/无重复)
       
       A 组合 (有/无重复)
       
       A 洗牌算法 - 随机置换有限序列
       
       A 最长公共子序列 (LCS)
       
       A 最长递增子序列
       
       A 最短公共父序列 (SCS)
       
       A 背包问题 - "0/1" and "Unbound" ones
       
       A 最大子数列问题 - BF算法 与 动态规划
       
       A 组合求和 - 查找形成特定总和的所有组合
      
    • 字符串

       A 莱温斯坦距离 - 两个序列之间的最小编辑距离
       
       B 汉明距离 - 符号不同的位置数
       
       A 克努斯-莫里斯-普拉特算法 - 子串搜索
       
       A 字符串快速查找 - 子串搜索
       
       A 最长公共子串
       
       A 正则表达式匹配
      
    • 搜索

       B 线性搜索
       
       B 跳转搜索 (或块搜索) - 搜索排序数组
       
       B 二分查找
       
       B 插值搜索 - 搜索均匀分布的排序数组
      
    • 排序

       B 冒泡排序
       
       B 选择排序
       
       B 插入排序
       
       B 堆排序
       
       B 归并排序
       
       B 快速排序
       
       B 希尔排序
       
       B 计数排序
       
       B 基数排序
      
    •  B 深度优先搜索 (DFS)
       
       B 广度优先搜索 (BFS)
      
    •  B 深度优先搜索 (DFS)
       
       B 广度优先搜索 (BFS)
       
       A 戴克斯特拉算法 - 找到图中所有顶点的最短路径
       
       A 贝尔曼-福特算法 - 找到图中所有顶点的最短路径
       
       A 弗洛伊德算法 - 找到所有顶点对 之间的最短路径
       
       A 判圈算法 - 对于有向图和无向图 (基于DFS和不相交集的版本)
       
       A 普林演算法 - 寻找加权无向图的最小生成树 (MST)
       
       B 克鲁斯克尔演算法 - 寻找加权无向图的最小生成树 (MST)
       
       A 拓扑排序 - DFS 方法
       
       A 关节点 - Tarjan算法 (基于DFS)
       
       A 桥 - 基于DFS的算法
       
       A 欧拉回径与一笔画问题 - Fleury的算法 - 一次访问每个边
       
       A 哈密顿图 - 恰好访问每个顶点一次
       
       A 强连通分量 - Kosaraju算法
       
       A 旅行推销员问题 - 尽可能以最短的路线访问每个城市并返回原始城市
      
    • 未分类

       B 汉诺塔
       
       B 旋转矩阵 - 原地算法
       
       B 跳跃 游戏 - 回溯, 动态编程 (自上而下+自下而上) 和贪婪的例子
       
       B 独特(唯一) 路径 - 回溯, 动态编程和基于Pascal三角形的例子
       
       B 雨水收集 - 诱捕雨水问题 (动态编程和暴力版本)
       
       A 八皇后问题
       
       A 骑士巡逻
      

    算法范式

    算法范式是基于类的设计的通用方法或方法的算法。 这是一个比算法概念更高的抽象, 就像一个 算法是比计算机程序更高的抽象。

    • BF算法 - 查找/搜索 所有可能性并选择最佳解决方案

    • B 线性搜索

    • B 雨水收集 - 诱导雨水问题

    • A 最大子数列

    • A 旅行推销员问题 - 尽可能以最短的路线访问每个城市并返回原始城市

    • 贪心法 - 在当前选择最佳选项, 不考虑以后情况

      B 跳跃游戏
      
      A 背包问题
      
      A 戴克斯特拉算法 - 找到所有图顶点的最短路径
      
      A 普里姆算法 - 寻找加权无向图的最小生成树 (MST)
      
      A 克鲁斯卡尔算法 - 寻找加权无向图的最小生成树 (MST)
      
    • 分治法 - 将问题分成较小的部分, 然后解决这些部分

       B 二分查找
       
       B 汉诺塔
       
       B 杨辉三角形
       
       B 欧几里得算法 - 计算最大公约数 (GCD)
       
       B 跳跃游戏
       
       B 归并排序
       
       B 快速排序
       
       B 树深度优先搜索 (DFS)
       
       B 图深度优先搜索 (DFS)
       
       A 排列 (有/无重复)
       
       A 组合 (有/无重复)
      
    • 动态编程 - 使用以前找到的子解决方案构建解决方案

       B 斐波那契数
       
       B 跳跃游戏
       
       B 独特路径
       
       B 雨水收集 - 疏导雨水问题
       
       A 莱温斯坦距离 - 两个序列之间的最小编辑距离
       
       A 最长公共子序列 (LCS)
       
       A 最长公共子串
       
       A 最长递增子序列
       
       A 最短公共子序列
       
       A 0-1背包问题
       
       A 整数拆分
       
       A 最大子数列
       
       A 弗洛伊德算法 - 找到所有顶点对之间的最短路径
       
       A 贝尔曼-福特算法 - 找到所有图顶点的最短路径
      
    • 回溯法 - 类似于 BF算法 试图产生所有可能的解决方案, 但每次生成解决方案测试如果它满足所有条件, 那么只有继续生成后续解决方案。 否则回溯并继续寻找不同路径的解决方案。

       B 跳跃游戏
       
       B 独特路径
       
       A 哈密顿图 - 恰好访问每个顶点一次
       
       A 八皇后问题
       
       A 骑士巡逻
       
       A 组合求和 - 从规定的总和中找出所有的组合
      

    Branch & Bound

    如何使用本仓库

    安装依赖

    npm install
    

    执行测试

    npm test
    

    按照名称执行测试

    npm test -- 'LinkedList'
    

    Playground

    你可以在./src/playground/playground.js文件中操作数据结构与算法, 并在./src/playground/test/playground.test.js中编写测试。

    然后, 只需运行以下命令来测试你的 Playground 是否按无误:

    npm test -- 'playground'
    

    感谢大家的查阅,可以发送建议给我谢谢

    展开全文
  • 5.1.1 关系运算符及其优先次序 61 5.1.2 关系表达式 61 5.2 逻辑运算符和表达式 62 5.2.1 逻辑运算符极其优先次序 62 5.2.2 逻辑运算的值 63 5.2.3 逻辑表达式 63 5.3 if 语句 64 5.3.1 if语句的三种形式 64 5.3.2 ...
  • 数据结构算法分析

    2014-01-15 02:05:59
    1.4.2 特别的构造函数语法访问函数  1.4.3 接口实现的分离  1.4.4 vector和string  1.5 C++细节  1.5.1 指针  1.5.2 参数传递  1.5.3 返回值传递  1.5.4 引用变量  1.5.5 三大函数:析构函数、...
  • 5.1.1 关系运算符及其优先次序 61 5.1.2 关系表达式 61 5.2 逻辑运算符和表达式 62 5.2.1 逻辑运算符极其优先次序 62 5.2.2 逻辑运算的值 63 5.2.3 逻辑表达式 63 5.3 if 语句 64 5.3.1 if语句的三种形式 64 5.3.2 ...
  • 书的内容包括、栈、队列、树、散列表、优先队列、排序、不相交集算法、图论算法、算法分析、算法设计、摊还分析、查找树算法、k-d树和配对堆等。本书适合作为计算机相关专业本科生的数据结构课程和研究生算法分析...
  • 书的内容包括、栈、队列、树、散列表、优先队列、排序、不相交集算法、图论算法、算法分析、算法设计、摊还分析、查找树算法、k-d树和配对堆等。本书适合作为计算机相关专业本科生的数据结构课程和研究生算法分析...
  • 1.4 C++类 1.4.1 基本class语法 1.4.2 特别的构造函数语法访问函数 1.4.3 接口实现的分离 1.4.4 vector和string 1.5 C++细节 1.5.1 指针 1.5.2 参数传递 1.5.3 返回值传递 1.5.4 引用变量 1.5.5 三大...
  •  1.4.2 特别的构造函数语法访问函数   1.4.3 接口实现的分离   1.4.4 vector和string   1.5 C++细节   1.5.1 指针   1.5.2 参数传递   1.5.3 返回值传递   1.5.4 引用变量   1.5.5 三...
  • 书的内容包括、栈、队列、树、散列表、优先队列、排序、不 相交集算法、图论算法、算法分析、算法设计、摊还分析、查找树算法、k-d树和配对堆等。本书适合作为计算机相关专业本科生的数据结构课程和研究生算法分 ...
  • 数据结构算法分析 Java语言描述第2版

    千次下载 热门讨论 2013-04-11 17:38:12
    8.1 等价关系 8.2 动态等价性问题 8.3 基本数据结构 8.4 灵巧求并算法 8.5 路径压缩 8.6 路径压缩和按秩求并的最坏情形 8.7 一个应用 小结 练习题 参考文献 第9章 图论算法 9.1 若干定义 9.2 拓扑排序 ...
  • 8.1 等价关系 8.2 动态等价性问题 8.3 基本数据结构 8.4 灵巧求并算法 8.5 路径压缩 8.6 路径压缩和按秩求并的最坏情形 8.7 一个应用 小结 练习题 参考文献 第9章 图论算法 9.1 若干定义 9.2 拓扑排序 ...
  • 5.2 散列函数 5.3 分离链接法 5.4 开放定址法 5.4.1 线性探测法 5.4.2 平方探测法 5.4.3 双散列 5.5 再散列 5.6 可扩散列 总结 练习 参考文献 第6章 优先队列(堆) 6.1 模型 6.2 一些简单...
  • 8.1 等价关系 8.2 动态等价性问题 8.3 基本数据结构 8.4 灵巧求并算法 8.5 路径压缩 8.6 路径压缩和按秩求并的最坏情形 8.7 一个应用 小结 练习题 参考文献 第9章 图论算法 9.1 若干定义 9.2 拓扑排序 9.3 最短...
  • [算法分析设计].(美国)Michael.T.Goodrich.清晰版 目录: 第一部分 基础工具 第1章 算法分析 1.1 算法的分析方法学 1.1.1 伪代码 ...A.2 整型函数关系 A.3 求和 A.4 有用的数学技术 参考书目 索引
  • 8.1 等价关系 8.2 动态等价性问题 8.3 基本数据结构 8.4 灵巧求并算法 8.5 路径压缩 8.6 路径压缩和按秩求并的最坏情形 8.7 一个应用 小结 练习题 参考文献 第9章 图论算法 9.1 若干定义 9.2 拓扑排序 ...
  • 8.1 等价关系 8.2 动态等价性问题 8.3 基本数据结构 8.4 灵巧求并算法 8.5 路径压缩 8.6 路径压缩和按秩求并的最坏情形 8.7 一个应用 小结 练习题 参考文献 第9章 图论算法 9.1 若干定义 9.2 拓扑排序 9.3 最短路径...
  • 8.1 等价关系 8.2 动态等价性问题 8.3 基本数据结构 8.4 灵巧求并算法 8.5 路径压缩 8.6 路径压缩和按秩求并的最坏情形 8.7 一个应用 小结 练习题 参考文献 第9章 图论算法 9.1 若干定义 9.2 拓扑排序 ...
  • 5.2 散列函数 5.3 分离链接法 5.4 开放定址法 5.4.1 线性探测法 5.4.2 平方探测法 5.4.3 双散列法 5.5 再散列 5.6 可扩散列 小结 练习 参考文献 第6章 优先队列(堆) 6.1 模型 6.2 一些...
  • 数据结构算法分析—C语言描述 高清版

    千次下载 热门讨论 2008-04-05 21:01:56
    5.2 散列函数 5.3 分离链接法 5.4 开放定址法 5.4.1 线性探测法 5.4.2 平方探测法 5.4.3 双散列 5.5 再散列 5.6 可扩散列 总结 练习 参考文献 第6章 优先队列(堆) 6.1 模型 6.2 一些简单的实现 6.3 二叉堆 6.3.1...
  • 8.1等价关系227 8.2动态等价性问题227 8.3基本数据结构229 8.4灵巧求并算法231 8.5路径压缩233 8.6路径压缩和按秩求并的最坏情形234 8.6.1缓慢增长的函数235 8.6.2利用递归分解的分析235 8.6.3O(Mlog*N)界...
  • 全书内容分为11章,包括程序设计入门、循环结构程序设计、数组和字符串、函数和递归、基础题目选解、数据结构基础、暴力求解法、高效算法设计、动态规划初步、数学概念方法、图论模型算法,覆盖了算法竞赛入门所...
  •  8.1 等价关系  8.2 动态等价性问题  8.3 基本数据结构  8.4 灵巧求并算法  8.5 路径压缩  8.6 路径压缩和按秩求并的最坏情形  8.7 一个应用  小结  练习题  参考文献 第9章 图论算法  9.1 若干...

空空如也

空空如也

1 2 3 4 5 ... 12
收藏数 223
精华内容 89
关键字:

优先关系表与优先函数