《数据结构教程(第2版)》课后答案

  • 更新时间:
  • 2270人关注
  • 点击下载

给大家带来的是关于数据结构相关的课后习题答案下载,介绍了关于数据结构教程、数据结构方面的内容,由从凝云 网友提供,本资源目前已被276人关注,高等院校数据结构类教材综合评分为:8.2分

资源详情相关推荐
《数据结构教程(第2版)》封面
  • 出版社:清华大学出版社
  • 作者:李春葆
  • 大小:13.7 KB
  • 类别:数据结构
  • 热度:354
  • 图解数据结构:使用C++
  • 数据结构与算法经典问题解析:Java语言描述
  • 数据结构:C语言描述
  • 数据结构与算法分析:C语言描述
  • C++数据结构与算法(第4版)
  • 《数据结构教程(第二版)》是2008年清华大学出版社出版的图书。

    数据结构是计算机学科的必修课程。本教程是作者针对数据结构课程概念多、算法灵活和抽象性强的特点,在总结长期教学经验的基础上编写而成的。全书分为14章,内容涵盖数据结构基本概念、线性表、栈和队列、串、数组和稀疏矩阵、递归、树和二叉树、广义表、图、查找、内排序、文件和采用面向对象方法描述算法。每章后均附有练习题和上机实验题。 

    本书在第1版的基础上增加了线段树、并查集等相关数据结构,全书内容丰富、层次清晰,讲解深入浅出,可作为高等院校计算机及相关专业本科及研究生数据结构课程教材,也可供从事计算机软件开发和应用的工程技术人员参考。

    目录

    • 第1章 绪论 1
    • 1.1 什么是数据结构 1
    • 1.1.1 数据结构的定义 1
    • 1.1.2 逻辑结构类型 4
    • 1.1.3 存储结构类型 6
    • 1.1.4 数据结构和数据类型 7
    • 1.2 算法及其描述 11
    • 1.2.1 什么是算法 11
    • 1.2.2 算法描述 12
    • 1.3 算法分析 13
    • 1.3.1 算法设计的目标 13
    • 1.3.2 算法效率分析 14
    • 1.3.3 算法存储空间分析 17
    • 1.4 数据结构+算法=程序 18
    • 本章小结 24
    • 练习题1 25
    • 上机实验题1 26
    • 第2章 线性表 27
    • 2.1 线性表及其逻辑结构 27
    • 2.1.1 线性表的定义 27
    • 2.1.2 线性表的抽象数据类型描述 28
    • 2.2 线性表的顺序存储结构 29
    • 2.2.1 线性表的顺序存储结构——顺序表 29
    • 2.2.2 顺序表基本运算的实现 30
    • 2.3 线性表的链式存储结构 36
    • 2.3.1 线性表的链式存储结构——链表 37
    • 2.3.2 单链表基本运算的实现 38
    • 2.3.3 双链表 45
    • 2.3.4 循环链表 49
    • 2.3.5 静态链表 51
    • 2.4 线性表的应用 56
    • 2.4.1 问题描述 56
    • 2.4.2 数据组织 57
    • 2.4.3 设计运算算法 57
    • 2.4.4 设计求解程序 59
    • 2.4.5 运行结果 59
    • 2.5 有序表 60
    • 本章小结 64
    • 练习题2 64
    • 上机实验题2 64
    • 第3章 栈和队列 67
    • 3.1 栈 67 [1]
    • 3.1.1栈的定义 67
    • 3.1.2栈的顺序存储结构及其基本运算实现 69
    • 3.1.3栈的链式存储结构及其基本运算的实现 72
    • 3.1.4栈的应用举例 75
    • 3.2队列 84
    • 3.2.1队列的定义 84
    • 3.2.2队列的顺序存储结构及其基本运算的实现 85
    • 3.2.3队列的链式存储结构及其基本运算的实现 89
    • 3.2.4队列的应用举例 92
    • 本章小结 97
    • 练习题3 97
    • 上机实验题3 98
    • 第4章串 101
    • 4.1串的基本概念 101
    • 4.2串的存储结构 102
    • 4.2.1串的顺序存储结构——顺序串 102
    • 4.2.2串的链式存储结构——链串 108
    • 4.3串的模式匹配 114
    • 4.3.1Brute-Force算法 115
    • 4.3.2KMP算法 117
    • 本章小结 123
    • 练习题4 123
    • 上机实验题4 124
    • 第5章数组和稀疏矩阵 126
    • 5.1数组 126
    • 5.1.1数组的基本概念 126
    • 5.1.2数组的存储结构 127
    • 5.1.3特殊矩阵的压缩存储 129
    • 5.2稀疏矩阵 131
    • 5.2.1稀疏矩阵的三元组表示 131
    • 5.2.2稀疏矩阵的十字链表表示 136
    • 本章小结 140
    • 练习题5 140
    • 上机实验题5 140
    • 第6章递归 142
    • 6.1什么是递归 142
    • 6.1.1递归的定义 142
    • 6.1.2何时使用递归 143
    • 6.1.3递归模型 144
    • 6.1.4递归与数学归纳法 145
    • 6.2递归调用的实现原理 146
    • 6.3递归算法的设计 148
    • 6.3.1递归算法设计的步骤 148
    • 6.3.2递归数据结构的递归算法设计 150
    • 6.3.3递归求解方法的递归算法设计 151
    • 6.4递归算法到非递归算法的转换 153
    • 6.4.1尾递归和单向递归的消除 153
    • 6.4.2模拟系统运行时的栈消除递归 154
    • 本章小结 163
    • 练习题6 163
    • 上机实验题6 164
    • 第7章树和二叉树 165
    • 7.1树的基本概念 165
    • 7.1.1树的定义 165
    • 7.1.2树的逻辑表示方法 166
    • 7.1.3树的基本术语 166
    • 7.1.4树的性质 168
    • 7.1.5树的基本运算 170
    • 7.1.6树的存储结构 170
    • 7.2二叉树概念和性质 173
    • 7.2.1二叉树概念 173
    • 7.2.2二叉树性质 174
    • 7.2.3二叉树与树、森林之间的转换 175
    • 7.3二叉树存储结构 177
    • 7.3.1二叉树的顺序存储结构 177
    • 7.3.2二叉树的链式存储结构 179
    • 7.4二叉树的基本运算及其实现 180
    • 7.4.1二叉树的基本运算概述 180
    • 7.4.2二叉树的基本运算算法实现 180 [2]
    • 7.5二叉树的遍历 183
    • 7.5.1二叉树遍历的概念 183
    • 7.5.2二叉树遍历递归算法 184
    • 7.5.3二叉树遍历非递归算法 188
    • 7.5.4层次遍历算法 197
    • 7.6二叉树的构造 199
    • 7.7线索二叉树 205
    • 7.7.1线索二叉树的概念 205
    • 7.7.2线索化二叉树 206
    • 7.7.3遍历线索化二叉树 208
    • 7.8哈夫曼树 209
    • 7.8.1哈夫曼树概述 209
    • 7.8.2哈夫曼树的构造算法 210
    • 7.8.3哈夫曼编码 212
    • 7.9线段树 214
    • 7.9.1线段树的定义 214
    • 7.9.2线段树的存储结构 215
    • 7.9.3线段树基本运算的实现算法 215
    • 7.10并查集 220
    • 7.10.1什么叫并查集 221
    • 7.10.2并查集的算法实现 222
    • 本章小结 225
    • 练习题7 225
    • 上机实验题7 226
    • 第8章广义表 228
    • 8.1广义表的定义 228
    • 8.2广义表的存储结构 230
    • 8.3广义表的运算 232
    • 8.3.1求广义表的长度 232
    • 8.3.2求广义表的深度 232
    • 8.3.3建立广义表的链式存储结构 233
    • 8.3.4输出广义表 234
    • 8.3.5广义表的复制 235
    • 本章小结 240
    • 练习题8 240
    • 上机实验题8 240
    • 第9章图 242
    • 9.1图的基本概念 242
    • 9.1.1图的定义 242
    • 9.1.2图的基本术语 243
    • 9.2图的存储结构 245
    • 9.2.1邻接矩阵存储方法 245
    • 9.2.2邻接表存储方法 247
    • 9.2.3十字邻接表存储方法 250
    • 9.2.4邻接多重表存储方法 251
    • 9.3图的遍历 252
    • 9.3.1图的遍历的概念 252
    • 9.3.2深度优先搜索遍历 252
    • 9.3.3广度优先搜索遍历 253
    • 9.3.4非连通图的遍历 254
    • 9.3.5图遍历算法的应用 255
    • 9.4生成树和最小生成树 259
    • 9.4.1生成树的概念 259
    • 9.4.2无向图的连通分量和生成树 260
    • 9.4.3有向图的强连通分量 261
    • 9.4.4普里姆算法 262
    • 9.4.5克鲁斯卡尔算法 264
    • 9.5最短路径 268
    • 9.5.1路径的概念 268
    • 9.5.2从一个顶点到其余各顶点的最短路径 268
    • 9.5.3每对顶点之间的最短路径 274
    • 9.6拓扑排序 278
    • 9.7AOE网与关键路径 280
    • 本章小结 285
    • 练习题9 285
    • 上机实验题9 285
    • 第10章查找 288
    • 10.1查找的基本概念 288
    • 10.2线性表的查找 289
    • 10.2.1顺序查找 289
    • 10.2.2二分查找 290
    • 10.2.3分块查找 292
    • 10.3树表的查找 295
    • 10.3.1二叉排序树 295 [2]
    • 10.3.2平衡二叉树 303
    • 10.3.3B-树 320
    • 10.3.4B+树 331
    • 10.3.52-3-4树 333
    • 10.3.6红黑树 335
    • 10.4哈希表查找 338
    • 10.4.1哈希表的基本概念 338
    • 10.4.2哈希函数构造方法 339
    • 10.4.3哈希冲突解决方法 340
    • 10.4.4哈希表上的运算 343
    • 本章小结 347
    • 练习题10 347
    • 上机实验题10 347
    • 第11章内排序 349
    • 11.1排序的基本概念 349
    • 11.2插入排序 350
    • 11.2.1直接插入排序 350
    • 11.2.2希尔排序 352
    • 11.3交换排序 354
    • 11.3.1冒泡排序 354
    • 11.3.2快速排序 356
    • 11.4选择排序 360
    • 11.4.1直接选择排序 360
    • 11.4.2堆排序 362
    • 11.5归并排序 365
    • 11.6基数排序 369
    • 11.7各种内排序方法的比较和选择 371
    • 本章小结 373
    • 练习题11 373
    • 上机实验题11 374
    • 第12章外排序 375
    • 12.1外排序概述 375
    • 12.2磁盘排序 376
    • 12.2.1磁盘排序过程 376
    • 12.2.2多路平衡归并 377
    • 12.2.3初始归并段的生成 379
    • 12.2.4最佳归并树 381
    • 12.3磁带排序 384
    • 12.3.1多路平衡归并排序 384
    • 12.3.2多阶段归并排序 385
    • 本章小结 386
    • 练习题12 387
    • 上机实验题12 387
    • 第13章文件 388
    • 13.1文件的基本概念 388
    • 13.1.1什么是文件 388
    • 13.1.2文件的逻辑结构及操作 389
    • 13.1.3文件的存储结构 389
    • 13.2顺序文件 390
    • 13.3索引文件 390
    • 13.3.1ISAM文件 391
    • 13.3.2VSAM文件 394
    • 13.4哈希文件 396
    • 13.5多关键字文件 397
    • 13.5.1多重表文件 397
    • 13.5.2倒排文件 398
    • 本章小结 399
    • 练习题13 399
    • 上机实验题13 400
    • 第14章采用面向对象的方法描述算法 401
    • 14.1面向对象的概念 401
    • 14.1.1重要概念 401
    • 14.1.2主要优点 402
    • 14.2用C++描述面向对象的程序 403
    • 14.2.1类 403
    • 14.2.2类对象 405
    • 14.2.3构造函数和析构函数 407
    • 14.2.4派生类 410
    • 14.3用C++描述数据结构算法 413
    • 14.3.1顺序表类 413
    • 14.3.2链栈类 416
    • 14.3.3二叉树类 418
    • 附录A综合实验题 424
    • 附录B实验报告格式 426
    • 附录C书中部分算法清单 427
    • 参考文献 430
    展开阅读
    精选笔记1:ES6学习笔记之Set和Map数据结构详解

    19小时43分钟前回答

    本文实例讲述了ES6学习笔记之Set和Map数据结构。分享给大家供大家参考,具体如下:

    一.Set

    ES6提供了新的数据结构Set。类似于数组,只不过其成员值都是唯一的,没有重复的值。

    Set本身是一个构造函数,用来生成Set数据结构。

    1 . Set函数可以接受一个数组(或类似数组的对象)作为参数,用来初始化。

    var s = new Set();
    var set = new Set([1, 2, 3, 4, 4]);
    [...set]  // [1, 2, 3, 4]
    var items = new Set([1, 2, 3, 4, 5, 5, 5, 5]);
    items.size // 5
    
    

    2.Set 支持 add(item) 方法,用来向 Set 添加任意类型的元素,如果已经添加过则自动忽略;has(item) 方法用来检测 Set 中是否存在指定元素;delete(item) 方法用来从 Set 中删除指定元素;clear() 用来清空 Set;获取 Set 集合长度用 size 属性。如下:

    JS

    var set = new Set();
    set.add(window);
    set.has(window); // true
    set.size; // 1
    set.add(window);
    set.add(1);
    set.size; // 2
    set.delete(window);
    set.has(window); // false
    set.clear();
    set.size; // 0
    
    

    Set 调用 add、has、delete 等方法时对 key 进行的比较,不做类型转换。向Set加入值的时候,不会发生类型转换,所以5和”5”是两个不同的值。

    Set 中,NaN 只能添加一次;

    Set 中,「-0」和「0 或 +0」可以同时存在,因为符号不一样;
    另外,两个对象总是不相等的。

    let set = new Set();
    set.add({});
    set.size // 1
    set.add({});
    set.size // 2
    
    

    上面代码表示,由于两个空对象不相等,所以它们被视为两个值。

    3.除数组重复成员的方法。

    var set = new Set([1, 2, 3, 4, 4]);
    [...set]  // [1, 2, 3, 4]
    
    

    4.Set实例属性和方法

    属性:

    Set.prototype.constructor:构造函数,默认就是Set函数。
    Set.prototype.size:返回Set实例的成员总数。

    Set实例的方法分为两大类:操作方法(用于操作数据)和遍历方法(用于遍历成员)。

    方法:

    add(value):添加某个值,返回Set结构本身。
    delete(value):删除某个值,返回一个布尔值,表示删除是否成功。
    has(value):返回一个布尔值,表示该值是否为Set的成员。
    clear():清除所有成员,没有返回值。

    上面这些属性和方法的实例如下。

    s.add(1).add(2).add(2);
    // 注意2被加入了两次
    s.size // 2
    s.has(1) // true
    s.has(2) // true
    s.has(3) // false
    s.delete(2);
    s.has(2) // false
    
    

    Array.from方法可以将Set结构转为数组。

    var items = new Set([1, 2, 3, 4, 5]);
    var array = Array.from(items);
    
    

    5.Set的遍历

    Set结构的实例有四个遍历方法,可以用于遍历成员。

    keys():返回键名的遍历器
    values():返回键值的遍历器
    entries():返回键值对的遍历器

    key方法、value方法、entries方法返回的都是遍历器对象

    由于Set结构没有键名,只有键值(或者说键名和键值是同一个值),所以key方法和value方法的行为完全一致。

    entries方法返回的遍历器,同时包括键名和键值,所以每次输出一个数组,它的两个成员完全相等。

    forEach():使用回调函数遍历每个成员

    let set = new Set(['red', 'green', 'blue']);
    for (let item of set.keys()) {
     console.log(item);
    }
    // red
    // green
    // blue
    for (let item of set.values()) {
     console.log(item);
    }
    // red
    // green
    // blue
    for (let item of set.entries()) {
     console.log(item);
    }
    // ["red", "red"]
    // ["green", "green"]
    // ["blue", "blue"]
    //可以省略values方法,直接用for...of循环遍历Set。
    for (let x of set) {
     console.log(x);
    }
    // red
    // green
    // blue

    Set结构的实例的forEach方法,用于对每个成员执行某种操作,没有返回值。该函数的参数依次为键值、键名、集合本身(下例省略了该参数)。另外,forEach方法还可以有第二个参数,表示绑定的this对象。

    let set = new Set([1, 2, 3]);
    set.forEach((value, key) => console.log(value * 2) )
    // 2
    // 4
    // 6
    
    

    6.应用

    使用Set可以很容易地实现并集(Union)、交集(Intersect)和差集

    let a = new Set([1, 2, 3]);
    let b = new Set([4, 3, 2]);
    // 并集
    let union = new Set([...a, ...b]);// Set {1, 2, 3, 4}
    // 交集
    let intersect = new Set([...a].filter(x => b.has(x)));// set {2, 3}
    // 差集
    let difference = new Set([...a].filter(x => !b.has(x)));// Set {1}

    如果想在遍历操作中,同步改变原来的Set结构,目前没有直接的方法,但有两种变通方法。一种是利用原Set结构映射出一个新的结构,然后赋值给原来的Set结构;另一种是利用Array.from方法。

    // 方法一
    let set = new Set([1, 2, 3]);
    set = new Set([...set].map(val => val * 2));
    // set的值是2, 4, 6
    // 方法二
    let set = new Set([1, 2, 3]);
    set = new Set(Array.from(set, val => val * 2));
    // set的值是2, 4, 6
    
    

    二、WeakSet

    WeakSet结构与Set类似,也是不重复的值的集合。但是,它与Set有两个区别。

    首先,WeakSet的成员只能是对象,而不能是其他类型的值。

    其次,WeakSet中的对象都是弱引用,即垃圾回收机制不考虑WeakSet对该对象的引用

    三、Map

    1、Map结构的目的和基本用法:

    JavaScript的对象(Object),本质上是键值对的集合(Hash结构),但是传统上只能用字符串当作键。这给它的使用带来了很大的限制。

    为了解决这个问题,ES6提供了Map数据结构。它类似于对象,也是键值对的集合,但是“键”的范围不限于字符串,各种类型的值(包括对象)都可以当作键。也就是说,Object结构提供了“字符串—值”的对应,Map结构提供了“值—值”的对应,是一种更完善的Hash结构实现。如果你需要“键值对”的数据结构,Map比Object更合适。

    对象作为参数:

    var m = new Map();
    var o = {p: 'Hello World'};
    m.set(o, 'content')
    m.get(o) // "content" 使用set方法,将对象o当作m的一个键,然后又使用get方法读取这个键,
    
    

    作为构造函数,Map也可以接受一个数组作为参数。该数组的成员是一个个表示键值对的数组。

    var map = new Map([
     ['name', '张三'],
     ['title', 'Author']
    ]);
    map.size // 2
    map.has('name') // true
    map.get('name') // "张三"
    map.has('title') // true
    map.get('title') // "Author"
    
    

    注意:

    a. 字符串true和布尔值true是两个不同的键。

    b. 如果对同一个键多次赋值,后面的值将覆盖前面的值。

    let map = new Map();
    map.set(1, 'aaa')
    map.set(1, 'bbb');
    map.get(1) // "bbb"
    
    

    c. 如果读取一个未知的键,则返回undefined。

    d.只有对同一个对象的引用,Map结构才将其视为同一个键。这一点要非常小心。同理,同样的值的两个实例,在Map结构中被视为两个键。
    好处:

    由上可知,Map的键实际上是跟内存地址绑定的,只要内存地址不一样,就视为两个键。这就解决了同名属性碰撞(clash)的问题,我们扩展别人的库的时候,如果使用对象作为键名,就不用担心自己的属性与原作者的属性同名。

    e. 如果Map的键是一个简单类型的值(数字、字符串、布尔值),则只要两个值严格相等,Map将其视为一个键,包括0和-0。另外,虽然NaN不严格相等于自身,但Map将其视为同一个键。

    let map = new Map();
    map.set(NaN, 123);
    map.get(NaN) // 123
    map.set(-0, 123);
    map.get(+0) // 123
    
    

    2.Map实例属性和操作方法

    (1)size属性:返回Map结构的成员总数。

    let map = new Map();
    map.set('foo', true);
    map.set('bar', false);
    map.size // 2
    
    

    (2)set(key, value) 方法设置key所对应的键值,然后返回整个Map结构。如果key已经有值,则键值会被更新,否则就新生成该键。

    var m = new Map();
    m.set("edition", 6)    // 键是字符串
    m.set(262, "standard")   // 键是数值
    m.set(undefined, "nah")  // 键是undefined
    
    

    set方法返回的是Map本身,因此可以采用链式写法。

    let map = new Map()
    .set(1, 'a')
    .set(2, 'b')
    .set(3, 'c');
    
    

    (3)get(key)方法读取key对应的键值,如果找不到key,返回undefined。

    var m = new Map();
    var hello = function() {console.log("hello");}
    m.set(hello, "Hello ES6!") // 键是函数
    m.get(hello) // Hello ES6!
    
    

    (4)has(key)方法返回一个布尔值,表示某个键是否在Map数据结构中。

    var m = new Map();
    m.set("edition", 6);
    m.set(262, "standard");
    m.set(undefined, "nah");
    m.has("edition")   // true
    m.has("years")    // false
    m.has(262)      // true
    m.has(undefined)   // true
    
    

    (5)delete(key)方法删除某个键,返回true。如果删除失败,返回false。

    var m = new Map();
    m.set(undefined, "nah");
    m.has(undefined)   // true
    m.delete(undefined)
    m.has(undefined)    // false
    
    

    (6)clear() 方法清除所有成员,没有返回值。

    let map = new Map();
    map.set('foo', true);
    map.set('bar', false);
    map.size // 2
    map.clear()
    map.size // 0
    
    

    3.遍历方法

    Map原生提供三个遍历器生成函数和一个遍历方法。

    keys():返回键名的遍历器。
    values():返回键值的遍历器。
    entries():返回所有成员的遍历器。
    forEach():遍历Map的所有成员。

    需要特别注意的是,Map的遍历顺序就是插入顺序。

    let map = new Map([
     ['F', 'no'],
     ['T', 'yes'],
    ]);
    for (let key of map.keys()) {
     console.log(key);
    }
    // "F"
    // "T"
    for (let value of map.values()) {
     console.log(value);
    }
    // "no"
    // "yes"
    for (let item of map.entries()) {
     console.log(item[0], item[1]);
    }
    // "F" "no"
    // "T" "yes"
    // 或者
    for (let [key, value] of map.entries()) {
     console.log(key, value);
    }
    // 等同于使用map.entries()
    for (let [key, value] of map) {
     console.log(key, value);
    }
    
    

    Map结构转为数组结构,比较快速的方法是结合使用扩展运算符(…)。

    let map = new Map([
     [1, 'one'],
     [2, 'two'],
     [3, 'three'],
    ]);
    [...map.keys()]
    // [1, 2, 3]
    [...map.values()]
    // ['one', 'two', 'three']
    [...map.entries()]
    // [[1,'one'], [2, 'two'], [3, 'three']]
    [...map]
    // [[1,'one'], [2, 'two'], [3, 'three']]
    
    

    结合数组的map方法、filter方法,可以实现Map的遍历和过滤(Map本身没有map和filter方法)。

    let map0 = new Map()
     .set(1, 'a')
     .set(2, 'b')
     .set(3, 'c');
    let map1 = new Map(
     [...map0].filter(([k, v]) => k < 3)
    );
    // 产生Map结构 {1 => 'a', 2 => 'b'}
    let map2 = new Map(
     [...map0].map(([k, v]) => [k * 2, '_' + v])
      );
    // 产生Map结构 {2 => '_a', 4 => '_b', 6 => '_c'}
    
    

    Map还有一个forEach方法,与数组的forEach方法类似,也可以实现遍历。

    map.forEach(function(value, key, map) {
     console.log("Key: %s, Value: %s", key, value);
    });
    
    

    4、与其他数据结构的转换

    (1)Map转为数组:扩展运算符(…)

    let myMap = new Map().set(true, 7).set({foo: 3}, ['abc']);
    [...myMap]
    // [ [ true, 7 ], [ { foo: 3 }, [ 'abc' ] ] ]
    
    

    (2)数组转为Map:将数组转入Map构造函数

    new Map([[true, 7], [{foo: 3}, ['abc']]])
    // Map {true => 7, Object {foo: 3} => ['abc']}
    
    

    (3)Map转为对象:前提是 所有Map的键都是字符串,它可以转为对象。

    function strMapToObj(strMap) {
     let obj = Object.create(null);
     for (let [k,v] of strMap) {
      obj[k] = v;
     }
     return obj;
    }
    let myMap = new Map().set('yes', true).set('no', false);
    strMapToObj(myMap)
    // { yes: true, no: false }
    
    

    (4)对象转为Map

    function objToStrMap(obj) {
     let strMap = new Map();
     for (let k of Object.keys(obj)) {
      strMap.set(k, obj[k]);
     }
     return strMap;
    }
    objToStrMap({yes: true, no: false})
    // [ [ 'yes', true ], [ 'no', false ] ]
    
    

    (5)Map转为JSON

    Map转为JSON要区分两种情况。一种情况是,Map的键名都是字符串,这时可以选择转为对象JSON。

    function strMapToJson(strMap) {
     return JSON.stringify(strMapToObj(strMap));
    }
    let myMap = new Map().set('yes', true).set('no', false);
    strMapToJson(myMap)
    // '{"yes":true,"no":false}'
    
    

    另一种情况是,Map的键名有非字符串,这时可以选择转为数组JSON。

    function mapToArrayJson(map) {
     return JSON.stringify([...map]);
    }
    let myMap = new Map().set(true, 7).set({foo: 3}, ['abc']);
    mapToArrayJson(myMap)
    // '[[true,7],[{"foo":3},["abc"]]]'
    
    

    (6)JSON转为Map

    JSON转为Map,正常情况下,所有键名都是字符串。

    function jsonToStrMap(jsonStr) {
     return objToStrMap(JSON.parse(jsonStr));
    }
    jsonToStrMap('{"yes":true,"no":false}')
    // Map {'yes' => true, 'no' => false}
    
    

    但是,有一种特殊情况,整个JSON就是一个数组,且每个数组成员本身,又是一个有两个成员的数组。这时,它可以一一对应地转为Map。这往往是数组转为JSON的逆操作。

    function jsonToMap(jsonStr) {
     return new Map(JSON.parse(jsonStr));
    }
    jsonToMap('[[true,7],[{"foo":3},["abc"]]]')
    // Map {true => 7, Object {foo: 3} => ['abc']}
    
    

    四、WeakMap

    结构与Map结构基本类似,唯一的区别是它只接受对象作为键名(null除外),不接受其他类型的值作为键名,而且键名所指向的对象,不计入垃圾回收机制。

    希望本文所述对大家ECMAScript程序设计有所帮助。

    展开阅读

    数据结构相关资源

    • Java软件结构与数据结构

      Java软件结构与数据结构

      Java软件结构与数据结构(第4版) 由著名作者JohnLewis(刘易斯)编写,本书始终以良好软件工程实践为准则,以Java为语言,介绍数据结构与算法的相关知识和具体实现,强调完美软件设计技巧的重要

      大小:129 MBJava

      立即下载
    • 数据结构(C++语言版)

      数据结构(C++语言版)

      大小:24 MB数据结构

      立即下载
    • 数据结构教程(学习指导/上机实验)

      数据结构教程(学习指导/上机实验)

      这书配套设施20钟头的视频教学,本实例教程突显上机操作实习内容,书中得出很多的上机操作试验题(分成认证、布置和综合性试验),供老师和大学生采用。为了更好地老师课堂教学和孩子

      大小:61.7 MB数据结构

      立即下载
    • 数据结构与抽象:Java语言描述

      数据结构与抽象:Java语言描述

      本书是一本数据结构的教材,Java语言与数据结构两条知识主线贯穿始终,这两条主线既相互独立又相互支撑。本书介绍了计算机编程中使用的数据结构和算法,包括29章,每章涉及一个ADT或其

      大小:131 MB数据结构

      立即下载
    • 数据结构、算法与应用:C++语言描述

      数据结构、算法与应用:C++语言描述

      数据结构、算法与应用:C++语言描述(原书第2版) 共分三个部分。第一部分从第1章到第4章,旨在复习C++程序设计的概念以及程序性能的分析和测量方法。第二部分从第5章到第16章,研究数据结构

      大小:109.2 MB数据结构

      立即下载
    • 数据结构与算法分析:Java语言描述

      数据结构与算法分析:Java语言描述

      数据结构:Java语言描述(原书第3版) 是国外数据结构与算法分析方面的经典教材,使用卓越的Java编程语言作为实现工具讨论了数据结构(组织大量数据的方法)和算法分析(对算法运行时间的估

      大小:47.3 MB数据结构

      立即下载

    学习笔记

    18小时53分钟前回答

    Python 实现数据结构-循环队列的操作方法

    今天我们来到了循环队列这一节,之前的文章中,我介绍过了用python自带的列表来实现队列,这是最简单的实现方法。 但是,我们都知道,在列表中删除第一个元素和删除最后一个元素花费的时间代价是不一样的,删除列表的第一个元素,那么在它之后的所有元素都要进行移动。所以当列表特别长的时候,这个代价就比较明显了。我们本文介绍的循环队列可以避免这个问题,同样我们上篇文章提到的用链表实现的方法也可以避免。 下面,我们来介绍循环队列。 循坏队列 循环队列,就是将普通的队列首尾连接起来, 形成一个环状,并分别设置首尾指针,用来指明队列的头和尾。每当我们插入一个元素……

    17小时48分钟前回答

    Python有什么数据结构

    Python中的内置数据结构(Built-in Data Structure):列表list、元组tuple、字典dict、集合set ,涵盖的仅有部分重点。 list的显著特征: (推荐学习:Python视频教程) 列表中的每个元素都可变的,意味着可以对每个元素进行修改和删除; 列表是有序的,每个元素的位置是确定的,可以用索引去访问每个元素; 列表中的元素可以是Python中的任何对象; 可以为任意对象就意味着元素可以是字符串、整数、元组、也可以是list等Python中的对象。 元组tuple 重点:元组Tuple,用法与List类似,但Tuple一经初始化,就不能修改,没有List中的append(), insert(), pop()等修改的方法,只能对元素进行查询 字典dict(dictionary) 字典dict……