请选择 进入手机版 | 继续访问电脑版
返回顶部
热门问答 更多热门问答
技术文章 更多技术文章

[java/javascript教程] 通过代码示例学习 JavaScript 中的数据结构

[复制链接]
北极孤星的泪 显示全部楼层 发表于 2022-7-21 14:19:35 |阅读模式 打印 上一主题 下一主题

登录网站,浏览更多精彩内容

您需要 登录 才可以下载或查看,没有账号?加入我们

x
            
1 P) [8 J9 D' l( l 790c6dc7366ed0700876e9e611730680.jpg
9 y0 l; x: K/ ]4 c7 ^1 l, P: c' A世界各地的贡献者们正在协作将 freeCodeCamp 的学习资源翻译成自己的母语,让更多人可以访问这些免费的学习资源,中文社区的翻译协作需要你的帮助  参与 freeCodeCamp 开源社区翻译协作,帮助全世界人们用母语免费学习编程  h  e% a" p8 {' t0 b9 i
大家好,在这篇文章中,我们将看一看计算机科学和软件开发中的一个重要话题:数据结构。数据结构是任何一个软件开发从业人员必须知道的内容,但当你刚开始学习的时候,可能觉得这个话题难以理解,甚至有些吓人。在这篇文章中,我会简单介绍什么是数据结构,它们在什么时候有用,以及如何用 JavaScript 来实现这些数据结构。让我们开始吧!目录什么是数据结构数组对象(哈希表)栈队列链表单链表双链表树二叉树堆图无向图和有向图加权图和非加权图如何表达图总结什么是数据结构在计算机科学中,数据结构是一种组织、管理和存储数据的形式,这种形式方便数据访问和修改。准确来讲,数据结构是数据值的合集、数据间的关系,以及可以应用到数据的函数和操作。这些概念乍一听有些抽象费解,但值得你去思考。如果你已经编写过一段时间代码,你肯定使用过数据结构。你使用过数组或者对象吗?它们就是数据结构。它们都是相互关联值的合集,并且可供你操作。😉// 值 1、2、3 的合集
- U  x; i! h9 p+ I8 f, Pconst arr = [1, 2, 3]% ~. {. h$ i+ D! U7 ~! q
1 S' W1 h( e+ D2 y3 L0 k
// 每一个值都是彼此相关联的,因为每一个值都在数组中具备自己的索引序号
: a2 A7 [7 E' Y; Sconst indexOfTwo = arr.indexOf(2)7 K# a" g, g/ J: ^/ h8 e% i% x
console.log(arr[indexOfTwo-1]) // 1
1 [" U& N, a) c/ H' i0 h6 econsole.log(arr[indexOfTwo+1]) // 3
' s  |9 r! k9 T$ }) _. ^5 \4 K; C7 ^- R! E* k+ R
// 我们可以对数组进行很多操作,例如给数组添加一个新的值
+ m. `% K: g1 g7 r$ u( h& Garr.push(4)
% W/ c) U4 ?* Z9 T) ]console.log(arr) // [1,2,3,4]9 {- M8 m* H- K
JavaScript 包含原始(内置) 和 非原始(非内置) 两种数据结构。原始数据结构是编程语言默认的、可以拿来就用(如数组和对象)的;而非原始数据结构不是默认的、如果需要使用的话,你必须先编写出来。不同的数据结构对应不同的操作场景。你或许可以使用内置数据结构处理大部分编程任务,但当遇到特殊任务的时候,非原始数据机构可以派上用场。让我们一起来看一看最流行的数据结构,它们是怎么运行的,在哪些场合适用,以及如何使用 JavaScript 编写这些数据结构。数组数组是存储在连续内存位置的项目合集。数组内的每一个元素都可以通过其索引(位置)访问。数组的索引通常从 0 开始,所以在一个包含 4 个元素的数组中,第三个元素的索引为 2。const arr = ['a', 'b', 'c', 'd']
/ }* o% ^. S2 ?* L  Tconsole.log(arr[2]) // c
& Z; o+ O& N/ {7 w+ V9 g+ I数组的长度属性定义了数组包含的元素数量。如果一个数组包含 4 个元素,我们就可以说这个数组的长度为 4。const arr = ['a', 'b', 'c', 'd']& z3 [- V9 n+ E  y
console.log(arr.length) // 4
) d" ~9 Z" l( o* M/ O4 h在一些编程语言中,一个数组中只能存储同一种数据类型的元素,在数组被创建的时候就必须定义数组的长度,并且不可以修改。但 JavaScript 的数组并不是这样,在 JavaScript 中,同一数组可以存储任何数据类型的元素,数组长度是动态的(也就是说可以按需更改数组长度)。const arr = ['store', 1, 'whatever', 2, 'you want', 3]5 ~& h! k% h3 W3 a+ |- Y& ]
JavaScript 数组可以存储任何数据类型的值,也就意味着可以存储数组。一个包含其他数组的数组被称为多维数组。const arr = [
2 m* U0 m- d# F7 |/ D+ J3 W* t    [1,2,3],
2 \) O" G, M2 y  ?3 N) J    [4,5,6],
7 e. r8 Y3 g/ H  k9 a, X$ W0 m    [7,8,9],3 c% @+ M- x  e: b/ [5 N
]  |0 d! M4 n$ A- c% A) V
JavaScript 数组有许多内置的属性和方法,可以针对不同目的来使用,如从数组添加或者删除元素、给数组排序、过滤数组,以及我们知道的数组长度等,数组的完全属性和方法列表可以在这里找到。😉在数组中每一个元素都对应一个索引,索引跟元素位于数组位置相关。如果我们在数组末尾添加一个新的元素,则这个元素的索引为之前数组最后一位索引加一。但当我们想要在数组的开头或者中间添加或者删除元素的话,添加或删除的这个元素之后的所有元素的索引都会变化。这样会增加计算成本,也是这种数据结构的缺点之一。当需要存储独立值以及在数据结构末尾添加和删除值的时候,数组十分有效。但当需要在结构中添加删除元素,其他数据结构会更有效。(我们会在后文提到)对象(哈希表)在 JavaScript 中,对象是键值对的集合。在其他编程语言中,这种数据结构也被称作映射、字典和哈希表。一个典型的 JS 对象如下:const obj = {
3 z5 g5 y* f& a7 M( ^    prop1: "I'm",
9 X1 M, O! a3 b' b    prop2: "an",4 _/ |6 \* D1 _. Q, U  m
    prop3: "object"
7 L+ t; `+ v" C  ?. U}
- Y4 |! W. [% C$ h0 A/ O我们使用花括号声明对象,在每一个键之后紧跟一个冒号和对应的值。需要注意的是,在同一个对象中所有的键都是独一无二的,不可以出现两个命名相同的键。对象可以存储值和函数。在对象的语境中,我们将值叫作属性,将函数叫作方法。const obj = {
1 @5 o1 l* @) i5 R    prop1: "Hello!",# M. q' b/ ~8 K9 l# h
    prop3: function() {console.log("I'm a property dude!")
, |: V; [& I6 v. M; g}}! j- D* O& B0 X6 o
访问属性有两种语法,object.property和object["property"]。访问方法可以调用object.method()。console.log(obj.prop1) // "Hello!"
. @; I, v2 \: S1 mconsole.log(obj["prop1"]) // "Hello!"4 x6 f' [; y2 \* N) d
obj.prop3() // "I'm a property dude!", U+ j% N+ q) L1 T1 o
赋值的语法也类似:obj.prop4 = 125
' }+ e. ^, \6 J) ^obj["prop5"] = "The new prop on the block"' D+ z+ q% e: {6 Q4 \7 u  q$ k3 U
obj.prop6 = () => console.log("yet another example")
- t  t% N; B% }( N& t; k, @% I
; x1 [- N+ V) h( I" u- N) k, X) Rconsole.log(obj.prop4) // 125
+ m: E% o9 T4 ?+ Y5 p4 V7 Cconsole.log(obj["prop5"]) // "The new prop on the block"
2 o. T  \2 h4 ~: Q0 c1 b5 r# ?; {, ]obj.prop6() // "yet another example"5 |# U, V, d6 N& f0 y
和数组一样,JavaScript 对象也有内置的方法供我们进行不同的操作,或者获取特定对象的信息,完整内容可以查看这里。对象是将有相同之处或者相互关联的数据放在一起的好办法。同时,因为对象的属性是独一无二的,当想要根据特定条件来区分数据的时候,对象可以派上用场。可以使用对象来记录有多少人喜欢不同的食物:const obj = {
+ ]& u$ J- n1 s+ {    pizzaLovers: 1000,
) f3 w1 c. n: z, C- z7 B8 ~3 W    pastaLovers: 750,
. O3 i1 F& e- E    argentinianAsadoLovers: 123123123123131239 E2 \$ j  Z6 B+ |7 G
}
* v: m% _; Q9 d3 i栈栈是一种以列表的方式来存储信息的数据结构,添加和删除栈的元素遵循 LIFO 模式(后进先出)。在栈中,不允许按照元素顺序来添加或删除元素,只能遵循 LIFO 模式。你可以想象桌面有一叠纸,来思考栈是如何运作的。你只能在这叠纸上方添加更多纸张,也只能在最上方取出纸张。这就是 LIFO,后进先出。😉3 l% l# z* U3 x3 u
683be5f971ed27142f8a4be0eee9bc5c.jpg ! P+ z3 G2 [7 W; ~' o: u+ z1 E6 O
   一叠纸只要确认元素遵循 LIFO 模式,那么栈结构就可以派上用场。下面是栈的使用场景:JavaScript 的调用栈在各种编程语言中管理函数调用许多程序提供的撤销/重做功能有不止一种实现栈的方法,但是最简单的或许是在数组中使用 push 和 pop 方法。如果你仅通过 pop 和 push 的方法来添加和删除元素,你就遵循了 LIFO 模式,用栈的方法操作了数组。另一个方法是列表,实现如下:// 为栈的每一个节点创建一个类
7 D( p- Y1 g! N3 {6 O3 M5 s& }class Node {) z$ T. a+ h' Q, R7 v5 m
    // 每一个节点包含两个属性,其值以及一个指向下一个节点的指针* f; a% r- Z0 L- n' {- D& M! i
    constructor(value){
6 v: _" _  {0 J# @        this.value = value  d+ y( P/ g. y) ~, k" l2 N
        this.next = null& R7 N( B8 s& i' q& g7 i  Z
    }; n5 e0 p! t0 U4 X# p
}
: \3 _2 P' ?1 @0 c- [6 H2 m! Z3 Y3 U) x- g& ^+ c
// 为栈创建一个类; X' [5 x- ]3 ?6 S* p- h6 X
class Stack {0 R: Z) \/ J) ]: X' I) m
    // 栈有三个属性,第一个节点,最后一个节点,以及栈的大小
9 [* p! K/ }. }- a! S    constructor(){
. h8 F0 H9 R7 K  m. i8 x        this.first = null2 d; `6 L6 C/ f' n; v: D
        this.last = null% k! t8 P% M7 v) z9 `4 G4 w
        this.size = 0
. S& @: B, B0 ]6 a, d    }" V: J/ w2 D& r! |1 Q% V: R6 M3 w; d
    // push 方法接受一个值,并将其添加到栈的“顶端”
1 i( n+ k- Y$ R7 ~    push(val){
. Y. K; a  u4 D- O' g        var newNode = new Node(val)
$ A  c2 }  A: @* d" P, n$ J6 v4 J        if(!this.first){4 z- t, N0 B3 L, Y
            this.first = newNode
+ k* f2 g, [! v$ s& E            this.last = newNode
+ J$ }, B  Q, I+ i! i/ E# ^3 s        } else {
7 j, Q: }- U) ?, F9 h            var temp = this.first- g8 N1 c1 X# O3 t0 M! a
            this.first = newNode
  i! H; k- k0 W            this.first.next = temp
0 Q% V& U- K/ p/ j$ d& @  g/ D        }
! [, x9 M. x; o2 ]2 E        return ++this.size
* S' X# o7 @1 E3 P4 @: n    }
5 [2 \# M! c+ z4 w# x7 J    // pop 方法删除栈“顶端”的值,并返回这个值0 ], h; j% H# _% H
    pop(){$ m- W* N/ i8 \9 z
        if(!this.first) return null
6 L, [' P/ w  Q6 c        var temp = this.first' L4 _, }: c4 T9 W7 h& i, o% R$ I
        if(this.first === this.last){& s( Q4 s. T1 g- G- ~, U2 w2 c
            this.last = null# K5 G" {3 o+ M& y( L
        }0 {6 i# [- r! y5 Y3 c; C. R% y; x
        this.first = this.first.next
, M/ J2 b% l7 l( a7 m: H        this.size--4 m4 C1 E4 Q# B
        return temp.value
( }+ g: u6 {2 M) W) x; I4 g    }) G. K/ _3 k) _" `' H8 M
}
5 o& g1 }0 m) o" S+ q; G$ u8 v* m5 O8 X; j8 H
const stck = new Stack
$ T4 {/ I) T/ }8 ?8 |
3 s6 E/ H+ {+ p4 Y, i' Qstck.push("value1")
% \5 ~5 e7 K  K1 X# Lstck.push("value2"), m7 }; d( K( |7 D4 ~/ b3 g
stck.push("value3")
* C+ e& C5 f! M
5 B5 f5 r3 j. T8 {  l( ^6 \" l4 fconsole.log(stck.first) /*
/ S! I8 P( j" D3 O% E# ]/ @  E        Node {- W$ m! H5 T$ ~* E& {; O7 N* x
        value: 'value3',
4 d$ O. r- A6 z        next: Node { value: 'value2', next: Node { value: 'value1', next: null } }
7 r; M: P( `0 y) C, O$ P1 n        }
4 |/ ?1 K7 @* s3 |    */5 O* z) U* s" ]5 E- F7 G9 Z( ?
console.log(stck.last) // Node { value: 'value1', next: null }" L, d# `4 p4 j  H9 w7 M8 g% Y8 s
console.log(stck.size) // 3
7 V* i( w: Q! |0 v$ M: H; {5 T0 U2 C4 e+ o9 w" j/ A: s9 @/ k
stck.push("value4")3 l6 c+ U/ m  v) p* J
console.log(stck.pop()) // value4, m' H# _5 M; l7 R0 P- E9 |) M6 k
栈方法的大 O 表示法为:插入 - O(1)删除 - O(1)查找 - O(n)访问 - O(n)队列队列和栈的运作方式类似,但是元素遵循另一个添加和删除的模式。队列值遵循 FIFO 先进先出模式。在队列中,元素不按照顺序添加或删除,仅遵循 FIFO 模式。下面这张排队购买食物的图可以帮助你思考这个概念。这里的逻辑是如果你先加入到队伍中,你就会先被服务。如果你是队伍的第一个,你就第一个离开队伍。FIFO。😉
; t  l8 H% {$ i7 K3 i e2ff47e39e953713455ceb1d62bfdaf1.jpg
$ e; F: l/ l, M7 g, G2 \   一队列的顾客队列的使用场景:后台任务打印/任务处理和栈一样,有不止一种实现队列的方式。但是最简单的是在数组中使用 push 和 shift 方法。如果我们仅使用 push 和 shift 方法来添加和删除元素,我们就在数组中遵循了 FIFO 模式,将数组按照队列来操作。另一个实现办法是列表,如下:// 为队列每一个节点的类  ?! K4 n5 c3 R6 _$ ~# j
class Node {; c0 v( u$ w) q. n, Z  r
    //每一个节点包含两个属性,其值以及一个指向下一个节点的指针% w( S1 ^) E5 i
    constructor(value){
( J; _: ]( S! k. ~! g1 u        this.value = value
. T3 g3 h" ^- O$ n3 l" p# A        this.next = null" G- i' M5 a0 M1 C3 L% L' y
    }% j7 f; F& Y7 z* X; C
}
6 f. `4 i% c% p! L; {8 M. O' S
! u' ~& G( t$ Q; D" s// 为队列创建类- o' S! W# v( {
class Queue {; A  e2 s8 H" J- E% d3 o) P3 F
    // 队列包含三个属性:第一个节点、最后一个节点、队列的大小
  d' q: [  g( \5 I    constructor(){  d  u) ]1 L1 Q" A, G* K2 p
        this.first = null4 Z( _2 E0 @( i% @  D3 e4 V, b
        this.last = null
& K( ~8 k: E1 z, k% R        this.size = 0# l( h7 o2 n$ h" \) s
    }$ \7 f9 y2 d( h
    // enqueue 方法接受一个值并将其添加到队列的末端
' W! a& Y9 A  j0 |  U, L    enqueue(val){
& Z* B$ h/ V; d$ Z4 K+ [: Z( I6 C: R        var newNode = new Node(val)% H& S& Y2 W5 t* c" m
        if(!this.first){+ Y2 K$ Z5 s2 c* W
            this.first = newNode
5 q5 S8 _4 Z3 K' ~            this.last = newNode& z& H7 @, S+ f
        } else {
! ]. w8 G0 s7 Q2 h% Z& T2 f) F            this.last.next = newNode
; e: ?5 n6 j& E! k; ?, y            this.last = newNode9 f+ M" x: ^! C% |. g2 b8 Y5 e. E$ d
        }
  |5 ?9 P; B9 {5 W( _% |" {1 V8 m        return ++this.size5 N7 r; D' N. h: d" W/ }! x
    }+ f; P( t5 ]$ l3 f
    // dequeue 方法删除队列“最前端”的元素,并返回
; O) {, w) W& P" L, ]! k    dequeue(){
6 N  g% s) a% Q. J        if(!this.first) return null+ h  k' g; W2 m0 c' M0 b( _9 X
& M# o3 ?2 O% B. R5 I" N1 L/ W
        var temp = this.first6 n" J" A! S  v2 M5 Z2 |: L
        if(this.first === this.last) {
) b5 R7 A, \- ^) \3 l! i4 W            this.last = null
6 l$ _% |6 J  ~        }
! ?- X1 \1 P1 T% s        this.first = this.first.next
4 s5 C5 Z9 e, o) U2 e        this.size--
+ a& v% G$ J, Y5 f        return temp.value
* b$ H: E) K/ x$ X7 o( H) l1 a    }
. o: o8 m5 j/ r2 T1 A}0 l* X6 o2 W* F- ^0 N1 w$ J

5 N: B+ o: q: c; i4 v% X/ Lconst quickQueue = new Queue
' C: h  k5 R  K) y, U$ ?
; [6 |, [, z$ W( t3 A4 oquickQueue.enqueue("value1")) k  A9 m) U1 n7 |5 X
quickQueue.enqueue("value2")6 S" |" x. E# r1 @! q- i
quickQueue.enqueue("value3"), c& m: M# y. O2 z; {0 w
. C, y! m2 I. q  ?$ \) {
console.log(quickQueue.first) /* & S+ O5 x: [' a2 I! \! X7 f
        Node {
: i+ S# E  M- r            value: 'value1',: B1 R4 O0 H9 j8 E" D$ x. K
            next: Node { value: 'value2', next: Node { value: 'value3', next: null } }
  O6 T3 q% K. a( {/ y5 |2 I. s* L        }
& S2 ~5 j. y$ d0 |    *// s! `  Z% d; P6 d
console.log(quickQueue.last) // Node { value: 'value3, next: null }! i/ v; Z% ~' c, `* I6 L$ d. l
console.log(quickQueue.size) // 3
& m. X9 w' ^& ?1 V0 X% W0 |: w
quickQueue.enqueue("value4")
! A2 \( c5 R& t  t7 n" x! Kconsole.log(quickQueue.dequeue()) // value1
$ j& `  ]% h, s* y+ a队列方法的大 O 表示法:插入 - O(1)删除 - O(1)查询 - O(n)访问 - O(n)链表链表是一种以列表存储值的数据结构,在列表中每一个值都被当作为一个节点,每一个节点都通过指针与列表的下一个值关联(若该节点是列表最后一个元素则下一个值为 null)。有两种链表:单链表和双链表。两种链表的运作方式类似,但是在单链表中每一个节点有单指针指向下一个节点,在双链表中,每一个节点有双指针,一个指向下一个节点,一个指向上一个节点。: A! b3 ?* y6 T; j) [, Q
928a1e02c8a5d2eabe79b78973e9cadc.png 8 I' E% W: [- {( N+ U
   在单链表中每一个节点有单指针' N2 |0 `( V5 {) M0 u6 y7 C
0f18b790d0b99a4b0aee41448966ea04.png
/ m0 w- s: u* [3 `+ s   在双链表中每一个节点有双指针列表的第一个元素被当作头,列表的最后一个元素被当作尾。和数组一样,列表的长度由列表中的元素个数决定。列表和数组主要不同包括:列表没有索引,列表中的每一个值仅“知道”其通过指针连接到的值。因为列表没有索引,所以我们不能随机访问列表中的元素。当我们想要访问一个值,必须通过从头到尾遍历整个列表的方法。没有索引的好处是添加或删除列表中任意部分比在数组中更高效。我们只需要重新分配指针指向的“相邻”值,但是在数组中,我们需要重新分配余下所有值的索引。和其他所有数据结构一样,可以采用不同的方法来操作以链表存储的数据。通常会使用:push(在尾部添加)、pop(在尾部删除)、unshift(在头部添加)、shift(在头部删除)、get(获取)、set(设置)、remove(删除)和 reverse(反转)。我们先来看看如何实现单链表,再来看看如何实现双链表。单链表完全实现单链表的代码如下:// 为列表中的每一个节点创建一个类
) z6 k' @; v: yclass Node{2 t! C# @  D! S9 v
    // 每一个节点有两个属性:其值和指向下一个值的指针
- E+ H& a0 \7 @9 L* G    constructor(val){
$ O2 F8 D, s5 k3 Z: n        this.val = val9 i0 l) N0 F( [+ E* d4 }
        this.next = null
7 n' r# V2 Z, x" a5 f. Z3 |* N    }
! a( T- @" D! p6 y}
  |; [2 ?7 L0 P9 T
! o: A, f% d6 d' f/ ^//为列表创建一个类1 _7 R$ Z4 m  d  ^
class SinglyLinkedList{
( V3 e/ M3 @" }* B. {3 N/ |    // 列表有三个属性,头、尾和列表大小! y4 K( [" ?* i5 D) q
    constructor(){8 o0 T; {7 C9 V0 k
        this.head = null$ c" G( [; D4 Y* ]2 i4 U
        this.tail = null0 s( P1 N3 D/ r* [. R1 h
        this.length = 0
  s& e' e! _4 n; N' f' }    }
0 P* u! W9 U2 m5 n6 o, P; q    // 向 push 方法传入一个值作为参数,并将其赋值给队列的尾
5 ?) H1 X$ O! s4 ]7 Z$ V, U4 \    push(val) {
. \4 D/ o' n" ]8 p0 ?5 ]2 b        const newNode = new Node(val)3 x$ D5 H  G: V0 e/ H# T  d4 t
        if (!this.head){5 c5 k+ i# U' D6 u: `8 ^
            this.head = newNode
" B9 e/ ~3 t, _, v7 u/ h# C            this.tail = this.head  m" [8 j( j2 e! Z( U0 d/ u( z4 Z
        } else {3 z' U0 ^; M* _5 k! M' |4 L
            this.tail.next = newNode
' L8 l- D4 M; z8 t            this.tail = newNode
" d& y+ Y7 f0 k2 J4 e/ C        }/ H' |8 Y+ ]1 a# C! r( C3 g
        this.length++2 S. N7 J" H+ n# Q7 h
        return this
/ G1 [" q# s; j0 d% i4 B    }9 F% b$ `. f  b0 S+ Q- w
    // pop 方法删除队列尾0 G, r4 j- W. m7 r* R( T
    pop() {
$ u% A* o  n" Y) I0 r7 M% w% I        if (!this.head) return undefined
7 F" {' d8 d& H- ?8 K7 O' i7 d" @        const current = this.head& T; R0 M. I/ ]! s9 m
        const newTail = current* O1 n9 d0 `. ]( p, {& ^
        while (current.next) {2 ]1 e1 m/ u3 l: ~& S5 ~7 l' I
            newTail = current2 O9 f6 m% V3 Q( w
            current = current.next! x0 d- h3 C' C, k
        }
! V! W5 _! A4 z6 u        this.tail = newTail
* A% C0 N2 E- H  t        this.tail.next = null
) B) v/ Y. R! Y% p. I$ W        this.length--
; k% f% t5 u, O* R; b* r        if (this.length === 0) {0 g: ^# h2 g, O; i, a/ ]! E
            this.head = null
+ r& Y: C. Q2 E" _8 w            this.tail = null
( p& x  v  v+ }; }        }0 l1 f' W% o" o" b. h0 q
        return current6 C+ A. v( b9 B8 h" h
    }8 a$ m8 a0 `# U" O
    // shift 方法删除队列头* d. d' `. f! D, y$ {6 B
    shift() {
: T2 a" D3 F: c! ^& u        if (!this.head) return undefined/ B* y  d0 e6 O5 w! Y( X
        var currentHead = this.head$ r9 L  _/ h( r: a5 m- R6 ^. L8 I3 y
        this.head = currentHead.next2 P, X. w  N! _% r5 j1 J; l
        this.length--3 `' y( l: D0 r- E& @9 V9 }2 P: U
        if (this.length === 0) {
- v5 u8 C$ n8 M- k            this.tail = null
# i" F& Y$ I+ k* I  e        }1 [# O3 Q4 Z. [# \
        return currentHead
, x; t0 z) h# \/ P. Z. O  Z+ A    }
  a2 r, K9 ?, e$ l/ T* s. G    // unshift 方法将一个值作为参数并赋值给队列的头- {% _  i/ ~. Z+ r1 E- Q0 o
    unshift(val) {
+ ]2 i6 y  J4 `; L3 ^5 S        const newNode = new Node(val)( L9 K3 G4 N8 }7 h( o+ n. v( J2 k9 K. j
        if (!this.head) {
4 ]! Q" U8 @# ^0 k( A            this.head = newNode1 N# h# F, t& |& ^+ H8 M) H  a) m
            this.tail = this.head0 X0 r) c) K) u3 W
        }
" }3 j$ s/ ]( t* i) e+ H& ~        newNode.next = this.head* E* m0 K! I$ v# W
        this.head = newNode
$ q: D  {$ ]1 n/ [4 e* b        this.length++
$ b7 z2 H) J. m) h4 B, Y        return this# t" w' f4 p: r) ~$ z  s
    }
% B& l, V9 H. A3 M    // get 方法将一个索引作为参数,并返回此索引所在节点的值
; y; m; ~8 E( K    get(index) {5 l8 K. _/ [+ v) i2 M
        if(index < 0 || index >= this.length) return null
# j( a& r1 V- \% o        const counter = 0
- G. I4 L, ~/ u* y6 E        const current = this.head
# W: C7 H. O$ T( I/ m        while(counter !== index) {
* i1 m9 p% c* e. a            current = current.next
2 n/ D. V" i6 U( X            counter++7 Z" b2 n8 l+ W- _* j: O
        }- [# Q( u. ~3 O  n1 ^) e
        return current
9 m/ j* s' H5 _) A    }( p6 `( l  |/ K. {9 i  b
    // set 方法将索引和值作为参数,修改队列中索引所在的节点值为传入的参数值
3 |$ b3 F6 ?6 b2 ^    set(index, val) {
# V5 j( V1 V; ?  Y4 Q        const foundNode = this.get(index)5 J; d' M2 W6 a
        if (foundNode) {7 {8 F4 p4 j' M- [  e0 w
            foundNode.val = val* X- J% d: y1 {) o; B( I
            return true
  }9 M: Y* U+ `  J; C$ I        }
. ~8 ~: {; ]# K6 n        return false$ G6 X7 Z/ w2 B# _# b% H9 Q
    }2 U; g# }/ M* }' h0 P
    // insert 方法将索引和值作为参数,在队列索引位置插入传入的值& [4 @  f! r2 G0 d4 }* w
    insert(index, val) {
/ N+ ~+ \' B9 \        if (index < 0 || index > this.length) return false& J: e$ l. _, D3 U
        if (index === this.length) return !!this.push(val)
( x( P6 t" N2 r        if (index === 0) return !!this.unshift(val)
% ^. ~1 c) C: E
0 G  Z, q+ u0 D* P" m        const newNode = new Node(val)
+ U; i1 G" K6 E' C- g& h        const prev = this.get(index - 1)% j: P2 {3 `  r* U  x
        const temp = prev.next& \0 }% Y, U+ L7 E
        prev.next = newNode
5 F! A0 Q: f+ `( u6 O$ w        newNode.next = temp
6 @# G' y) |8 U* }- l        this.length++2 W- e( d' l7 t9 D+ ^/ `
        return true
4 E0 Q( y5 d5 K0 v* e& l5 A# l    }
& w; e1 z# a0 k    // remove 方法将索引作为参数,在队列中删除索引所在的值
; E: Y+ j, D2 e0 l0 E$ L: I    remove(index) {
) a4 M' g+ v5 k( T0 ^( {        if(index < 0 || index >= this.length) return undefined
. c" G- l% h  K2 p  D        if(index === 0) return this.shift()7 z( ~- x, {. A: a+ M3 q5 X2 P
        if(index === this.length - 1) return this.pop()4 `4 B, Y1 z" {
        const previousNode = this.get(index - 1)2 A5 J9 f( [- o- Q8 r
        const removed = previousNode.next
- `: W, o1 s- i0 J/ V        previousNode.next = removed.next
: J& i  z" ~8 m: |( T" w: E/ n        this.length--2 H3 J# h7 o) R; C6 t
        return removed
+ U8 H  S# V  c0 P# N4 V    }
( d, ?% ^# M8 y: g6 u  [    // reverse 方法反转队列和所有指针,让队列的头尾对调
# H9 j9 q0 n* q  H    reverse(){
  k- C. J2 G! Z: ?      const node = this.head
) T$ u" p# x) ]* y9 K8 [# ]      this.head = this.tail
  @! r5 O4 L- T9 \      this.tail = node
" H/ ?7 g9 J. H! `" E2 T% x* w      let next
4 B, P4 l6 Y& y: M% C5 }      const prev = null
. q8 K/ b* o3 @/ O) m, L      for(let i = 0; i < this.length; i++) {
, I% C# y: Z& a$ ^6 G7 o        next = node.next: P& _5 ^' I' L  u' S
        node.next = prev5 D! W/ g1 @* W" |5 ^
        prev = node
8 _* z8 t% \! I. N0 v- \        node = next
6 v5 d4 Q& {) E9 ^      }9 {9 t2 x1 {+ C
      return this
3 T8 J# q! p2 n" o% X2 E+ y. `, T    }
! w8 X2 G3 p- t$ ~, X0 {* v}
% A1 C+ e! L; f  s4 L单链表的复杂度为:插入 - O(1)删除 - O(n)查找 - O(n)访问 - O(n)双链表如上文所述,双链表和单链表的区别在于双链表的前后两个节点之间由双指针相互连接,而单链表只有一个指向下一个值的指针。双指针使得在特定场景下双链表比单链表的表现更好,但是也增加了存储空间的成本(存储双指针比单指针更占位置)。完全实现双链表的代码类似于:// 创建列表节点的类
$ N! I( {: {6 q6 C$ ]: Y" kclass Node{
* f# ~5 F/ i+ p, Z) z1 J" t7 n    // 每一个节点包含三个属性,其值,一个指向上一个节点的指针,一个指向下一个节点的指针
5 f3 d% u+ E% _# w! _2 k6 [    constructor(val){; i6 T* ?- E( T# D- n( P1 j2 a
        this.val = val;
7 N) u& e- t( C, ~, M/ e- l        this.next = null;
3 J( x! D% X- i9 b        this.prev = null;
8 Q7 L" w2 m9 R' z6 ^' `& p; Y    }  v5 l. h3 ?: E4 z
}3 w4 p* D7 T7 I  p) h% \, s

9 ?$ c/ D9 m0 K/ c+ f// 创建一个列表的类
6 R) x+ N; _" }4 Oclass DoublyLinkedList {
. ]& F  G* f6 r! u% J) J    // 列表有三个属性,头,尾和列表的大小5 Y% n7 m% b" ^  |% E
    constructor(){
$ ^) \1 o2 S3 ]6 y        this.head = null& B! s8 e$ s3 c* X2 Y' `
        this.tail = null
3 v( @& I/ Q7 `) R        this.length = 0
7 R! W# A0 d- B8 h5 M' c) j& x    }
+ a/ a7 ~( J& x9 l% Q    // push 方法将值作为参数并赋值给队列尾
% ~! X7 G- F0 Q( h0 `    push(val){& b. Z) \: C3 F9 Q/ G* T
        const newNode = new Node(val)7 b5 F& p4 ]5 T0 [: P4 t
        if(this.length === 0){0 s* r! A/ M& ~6 O
            this.head = newNode
+ Y  S8 D4 ~: E            this.tail = newNode3 |9 Q. m3 Q0 ^! z% E% L
        } else {) o8 Q. l& \  n9 r0 i- k
            this.tail.next = newNode
. r" U( u7 m" U1 v/ s9 g/ k            newNode.prev = this.tail  h  ?8 B6 V, @/ D+ z/ L
            this.tail = newNode
# o1 P& S  n. U  O, L/ t8 M* C# V        }
# q; b7 N1 C4 `  F- a* o. x        this.length++* @; z; e5 z% T. z) [: Y! t- Z
        return this+ A* V* K- b' j1 B' F
    }6 p, b3 X+ C5 b; _8 u8 K
    // pop 方法删除队列尾
7 f* _* e' {& S8 W. u* f% V- S0 b    pop(){
+ ?, t; @. Y, _+ H/ i8 j        if(!this.head) return undefined3 Z- y* \9 M3 o* H1 M- s& A
        const poppedNode = this.tail
8 {8 h# w$ E( \        if(this.length === 1){
% {4 U4 U; {9 r4 q% k            this.head = null3 V6 v; c) c* b" S. I) |
            this.tail = null
" k, z) q. w/ q' G  Z! L        } else {" ~- G: n9 M" L1 I$ u
            this.tail = poppedNode.prev4 {5 ?! C: h9 Q1 J+ A( Z7 z( X
            this.tail.next = null
) a; S* k$ ?& q% [  Q+ F) }1 a            poppedNode.prev = null- H: U5 V7 j& V& ^
        }
) q+ g  j1 [9 \, c, h        this.length--
2 E. |* E: _; V  s        return poppedNode
+ A8 X! T( ?; T: g1 f    }
  u: k( s! D7 r$ m8 m, l, m    // shift 方法删除队列头7 ?, c$ t( f& ~& O/ t/ T
    shift(){
5 }7 U+ Q# \% [# o/ ?0 O        if(this.length === 0) return undefined9 D3 u. q4 A4 o6 q5 T
        const oldHead = this.head6 t" O& F" C* B4 L
        if(this.length === 1){
# \/ B& \8 {! p6 N$ C" g" U: [* P" W3 r: }1 X            this.head = null! H$ L, L; a  Q' k; [
            this.tail = null
6 D1 z$ R3 r8 ^% ]& P! i' Q, h        } else{/ ]/ o2 u3 l" w) e: Y( H2 |
            this.head = oldHead.next
( j* w' z' _" q( d$ b  M            this.head.prev = null
/ K& H# Z: e0 Q7 q2 ~            oldHead.next = null7 l' @' X  [' m  {$ w7 O* i
        }
$ z( _) I9 z/ w1 Q1 Z+ |# m        this.length--! c" X2 }6 h0 `" v
        return oldHead2 o  x% L* R6 U' K9 g- @
    }3 L& P: A, O( m, Z2 [3 t4 W, g
    // unshift 方法将值作为参数并赋值给队列头8 O( Q) W" o' E. a: O* q& ?1 |% r
    unshift(val){
9 Y% c( K0 b" R) Y2 l( M        const newNode = new Node(val)  s/ c7 K! w  m8 d  U' c9 n2 {8 v
        if(this.length === 0) {$ H5 T. ]3 _1 L6 j; R" J
            this.head = newNode- i% z7 Q: |! R3 m
            this.tail = newNode
6 J# ~' m, o0 `0 {0 X        } else {
* I0 R" y, |& q7 {/ `8 B3 l, d            this.head.prev = newNode
0 o4 O9 ~9 s( N% ~! L* @7 z) m5 n            newNode.next = this.head
, M( y" h, H0 ]            this.head = newNode
6 A$ [1 n! a$ \        }
* f! ^9 d+ L; w( f- b+ R* X        this.length++
# o  K) a9 p: S1 X3 W        return this4 y2 z; ~3 L. d4 R% U- `7 A  q) K
    }
/ P- I; G; W, c2 {1 q" k! D, Z: O# r    // get 方法将索引作为参数并返回队列对应索引的值' w9 L( [$ U; E% q9 _. u: j9 T
    get(index){
; c) u9 u  v3 W* d        if(index < 0 || index >= this.length) return null! O: T4 C% C7 I$ L' `; {1 r, H
        let count, current
2 R5 x) ?3 j7 l5 u: i* {        if(index <= this.length/2){
$ a) c  f1 M! }( ]            count = 0% n2 b; v, T) R8 s5 f4 W
            current = this.head9 X& f, d) L2 s+ C6 h) n
            while(count !== index){# T1 T4 r/ |' A2 ]. Z' C
                current = current.next
* g  R# i! V; `/ Q                count++! i( o# z: w1 R5 C5 u* I( d3 C% e
            }
* A! L1 B* P& ]" }2 X  Q$ L3 d        } else {0 ]5 q* ~) B2 b: c
            count = this.length - 1
. o* M# v. B# N" M$ F8 Q1 G, Q7 @            current = this.tail8 [& ~) M0 m& D9 i
            while(count !== index){0 Y. c$ d, ]; {  |+ E/ c
                current = current.prev
: Z4 H, q+ \' O                count--; o/ k! u  u/ M" p" _  |8 U
            }
/ @  ?- N* e4 b* d        }6 b0 {) L# g4 \/ x
        return current
8 G0 p7 N/ U4 h0 o0 t. t    }" J. ]$ V  _* g2 D' Q
    // set 方法将索引和值作为参数,修改队列中索引所在的节点值为传入的参数值
3 @- z7 I  {1 \# b3 z* G' W    set(index, val){- i) D% u8 s; n. @
        var foundNode = this.get(index)9 I, U) V4 E; h
        if(foundNode != null){
) p. u! {9 j6 B/ Z1 r            foundNode.val = val6 r4 F* B$ b# D  z. p4 N
            return true  w6 s1 l) D  T* |) b
        }
3 \" f  N, c6 s7 @+ S6 J3 P. X        return false
5 a! m8 U) o) w5 H2 Y* `9 p* F# c    }
9 l! T) B8 O: ~, i    // insert 方法将索引和值作为参数,将值插入队列响应索引位置
% \9 l$ N0 a6 I* c+ }* k    insert(index, val){
7 w; f: Z" C3 R        if(index < 0 || index > this.length) return false
+ `2 d5 o, E! k; G% W8 T9 D8 Y4 W        if(index === 0) return !!this.unshift(val)
  q1 J, U( {1 }$ ~6 u) _3 j" u        if(index === this.length) return !!this.push(val)+ t  y" [: G; n" t; J  M

: \$ l! M, m1 i7 \1 E- B- B        var newNode = new Node(val)
2 G+ N: c6 n! w* w; n        var beforeNode = this.get(index-1)
. z" h  I: A6 ?" ^8 M# Z- I/ t. p; @        var afterNode = beforeNode.next
: R9 d* K2 b' ?$ w: \" C+ x8 P" V. E- Z9 |$ P) M
        beforeNode.next = newNode, newNode.prev = beforeNode
' e% n- ?  ~5 L5 U        newNode.next = afterNode, afterNode.prev = newNode
% i! Y5 k# I' ?        this.length++
& E+ E- E' v0 i5 v( d        return true; z* r; |9 x+ a. `
    }3 J7 t& z& ]; K: l
}8 @2 T( f. ~% P! p3 M$ p+ L
双链表的大 O 表示法为:插入 - O(1)删除 - O(1)搜索 - O(n)访问 - O(n)树树是一种以父子关系相连的节点之间的数据结构,也就是说节点之间相互依赖。: P+ b2 d. Y2 L" {2 W0 ~* t
fd92e5e73697e697bc309c9ac88d42c5.png   q* R2 O4 M9 z8 \! k1 c
   树结构树由根节点(树的第一个节点)开始,其他所有由根发展出来的节点被称作子节点。树结构最底部的节点没有“后代”,被称为叶节点。树的高度由父子节点相连的层数决定。和链表及数组不同的地方是,树是非线性的,程序可以在数据结构内选择不同的方向遍历数据,从而得出不同的值。而在链表或者数组中,程序由一个端点开始遍历到另一端点,每一次都重复同样的路径。构成树结构一个重要的要素是仅从父到子连接的节点是合法的。“亲属”之间或者由子向父节点是我连接都不被允许(这样的连接会形成图表,是另一种数据结构),另一个重要的要素是树只能有一个根节点。程序中使用树的场景有:DOM 模型人工智能中的情景分析操作系统中的文件夹有不同类型的树,每一种类型的树的值都遵从不同的模式而组织起来,这样也就适用于不同的解决问题的场景。最常见的两种树是二叉树和堆。二叉树二叉树是每个节点最多只有两个节点的树结构。
0 Y) C) m$ }" l8 J5 q cdaeec79f41638433ba953b6f7214ab1.png
! C: j4 j( Z( y7 q. c' R. L   二叉树二叉树的一个重要使用场景是搜索。用于搜索的二叉树被称为二叉查找树(BST)。BST 和普通二叉树类似,只是内部的数据结构被排列成易于搜索的结构。在 BST 中的值是排过序的,所有节点的左子节点的值要小于父节点,所有节点的右子节点的值要大于父节点。) @  Z! V9 q. i! r+ q
d39490b067f4d4200fda63989d412b1b.png
7 \7 M/ |# Z* R, u   二叉查找树这样给值排过序的数据结构非常适合做搜索,因为树的每一层都可以对比是比父节点大还是小,在对比的过程中,我们可以逐步舍弃掉一半的数据得到最终我们需要的值。当插入或者删除值的时候,我们的算法会进行如下步骤:检查是否存在根节点如果存在根节点,检查这个需要添加或删除的值是比根节点大还是小如果比根节点小,则检查左边是否有节点,并重复上面的步骤;如果左边没有节点,则将这个节点在当下位置添加或者删除如果比根节点大,则检查右边有没有节点,并重复上述步骤;如果有变没有节点,则将这个节点在当下位置添加或者删除在 BST 中查找与上述方法类似,但是没有添加或者删除值,取而代之的是与节点比较我们搜寻的值的大小。树的大 O 复杂度呈对数(log(n))。但是需要注意的是,想要实现这样的时间复杂度,必须保证树结构的每一步都是左右对称的,这样我们才可以在搜索的过程中“丢弃”一半的数据。如果在任意一边存储的值更多,树结构的搜索效率就会打折扣。实现 BST 的方法如下:// 我们创建树的节点7 n' E* o& X% w% N, x; m- P
class Node{- V4 V, _5 e+ \" e
    // 每一个节点有三个属性:其值,以及指向左节点的指针和指向右节点的指针9 ?$ j$ ?+ @& D3 y* ^* j1 F2 Y$ L
    constructor(value){  ^/ L  t9 s* I' @' B  J
        this.value = value' S1 V' l( Y- O5 ?& g
        this.left = null4 Y8 n  C/ W( y# e5 N
        this.right = null
# O* L# U( U: k2 H  ~    }4 I1 F/ @; ]6 p, L- x
}
6 u9 s& u0 I' {. [& L// 创建BST的类2 Q; M- V5 }7 Q7 D6 q
class BinarySearchTree {2 n! I% B) G# S4 P/ ]. O( X
    // 这个树只有一个属性即根节点
$ u- S. J8 k& _+ e$ W0 K    constructor(){
9 ~- Y, X$ Y  H2 Z$ ~        this.root = null2 P8 n9 K) O9 T" ^
    }
9 i. x$ T. B9 P8 G0 w4 x    // insert 方法将一个值作为参数,并将值插入树对应的位置
6 Y- ^" J* o8 n+ Z* j    insert(value){
+ k2 C, I, l) `9 ^/ u: P! p; h        const newNode = new Node(value)! E/ v1 A- s1 R, F4 i# i( Y
        if(this.root === null){* V9 L! k6 Z) i3 H6 J
            this.root = newNode
0 m2 V% N& u# t2 T, l* S9 `' ?            return this. Z+ c8 J, L0 i+ f
        }# k8 ?5 X2 Z9 n0 R& ~$ u
        let current = this.root
" _; l( M$ }7 _+ _        while(true){+ m/ G% M) }( `0 ^( `1 B  j5 z
            if(value === current.value) return undefined! x& S) v& L* l  w
            if(value < current.value){1 M1 B, Z7 S( T! N6 E4 a
                if(current.left === null){
) J/ e& F0 b( U4 L( p+ t: S                    current.left = newNode
$ s* o% ]% P3 u& Z7 f                    return this: I% P! u" @5 Y; `
                }
9 V# i, e! |$ K6 W                current = current.left
4 u: u/ z- J5 i4 S6 o( g7 T4 n            } else {
$ ?) M1 x7 l2 s! d! D1 E7 t0 G$ _  J. B* a                if(current.right === null){
$ y2 s! Z1 M8 m" t+ k                    current.right = newNode# ^6 v6 U8 e) b
                    return this3 `  g2 N) E. s# |9 C. ]
                } & S5 v3 ^& ^. n% M1 t% k
                current = current.right
* F9 Z* g- t# {: h2 N            }
4 }8 ]1 g$ |, @+ T) C% V7 V( G        }: g" H3 Z+ g( [# }! T: o& s5 W, {0 C! T
    }
. E% s; e7 @! W3 ?5 M2 n8 A    // find 方法将值作为参数,遍历树寻找对应的值
; _. _3 ?3 {# {4 r; w    // 如果找到了,返回找到的值,如果没有找到,返回undefined
& e, C% O0 z( Y; ~    find(value){# E: T& o1 o+ J8 [8 B/ y: s  [+ T9 C
        if(this.root === null) return false; }' s1 X: U% j& {. w! T; W* a2 }; T
        let current = this.root,
( W% C/ w) Y. ]; W            found = false
& _- s3 [7 i& N" O+ k$ }' i# I        while(current && !found){
: K& V; ~8 N4 l7 a5 B5 m            if(value < current.value){
( `  e' G( g8 e6 |                current = current.left
+ I+ A8 U; [* F& x3 ?0 m# b            } else if(value > current.value){
$ `- P% n- A* L                current = current.right
, T  n) C5 H+ ?0 O: e            } else {
4 Y) l4 J* }$ n3 K                found = true
2 w6 @7 c$ A7 w( D* D+ `1 D- o            }- Y* E( W+ n9 [+ s# {/ B1 a6 Z2 z
        }
5 f$ L* M0 P" }; h7 \0 i8 n        if(!found) return undefined
  ]9 \% t& b3 C3 ~& L! ?( ^        return current% n6 v- U3 `0 f9 g
    }
& q9 b+ Q( @# s    // contain 方法将值作为参数,如果找到树中对应的值返回 true,如果没有找到则返回 false4 f8 q& C2 C3 Z* g; d
    contains(value){
2 `1 H  _! Q+ e% j3 W3 I        if(this.root === null) return false
5 J( E: f9 q, j9 J7 L        let current = this.root,
* w: g+ V" d2 M$ Y            found = false
) k0 f# d: O8 M: w; v        while(current && !found){
* _: U* D) V5 N# j6 A- S            if(value < current.value){
1 I+ s! G* o( K; _, f: W& u. `3 @4 E                current = current.left& B) M; x! h! I7 ~. ^7 G1 B
            } else if(value > current.value){
# F7 d- f) U# \; x- Y                current = current.right9 ]* |' T+ ~) L, S& m) e2 v
            } else {3 H' B' T+ N& ^3 n
                return true
" b, I$ t3 N) z$ q5 b0 ]            }5 @* ^! g3 t" t7 t( ^
        }6 V2 N9 `1 Q4 [4 [
        return false. d$ ~( Z$ A( V, U  w! ?& w
    }
* v6 h  F1 w& r) s0 t, |1 M; b5 Z}0 J; y. t  x3 u: e5 T" n
堆堆是有特殊规则的树结构。主要有两种形式的堆:最大堆和最小堆。在最大堆中,父节点的值必须比子节点大;在最小堆中,父节点的值必须比子节点小。
- W; c: ~2 q3 ?* { 3d50a9f0dfa635acc2cf350957a92f3d.jpg - E' T7 l- F6 Y. ]+ y; j3 A
   最大堆
- {) t3 i! P3 A8 s* L6 L& ?( `4 \$ S* D0 I 5898d9e657301e9a4e183f6fa48afaf2.jpg " D# B( Y6 j7 \! N2 n5 q
   最小堆堆结构的规则不适用于相邻的两个节点,也就是说在同一层的节点除了必须比自己的父节点大或者小,不需要遵循其他规则。另外,堆越紧凑越好,也就是每一层都尽可能填满空位,新的节点首先添加到左边。堆,特别是二进制堆,通常被用来解决优先队列问题,也被运用到知名的算法问题——戴克斯特拉算法。优先队列是一种数据结构,在这种结构中,每一个元素都被关联了优先级,优先级高的元素优先展示出来。图图是一种有一组节点相互连接的数据结构。和树不一样的是,图并没有根或者叶节点,也没有“头”或者“尾”。不同的节点随机关联在一起,之间并没有父子关系。5 p$ z) n: T4 @% Q
6e6c34e930d64ef6808f083b13539b13.png % d: i: k. a1 K" L- [
   图图经常被应用于:社交网络地理定位推荐系统根据节点之间关联的特征,可以把图分成不同的类别:有向图和无向图如果节点之间没有的关联没有定义方向,我们就称这个图为无向图。在下图中我们可以看到节点 2 和节点 3 之间的关联没有方向性,我们可以从节点 2 到节点 3,也可以从节点 3 到节点 2。无定向意味着节点间的连接是双向的。
  p- I# M$ K( y- _* H+ k 519a838ab66a7dbdb8285a2b6e3c7976.png 5 v) F* M) K4 y- f/ F
   无向图你可能已经猜出来了,有向图就是完全相反的。让我们再次使用上面的图,这时节点之间的连接是有固定方向的。在这幅图中,你可以由节点 A 到节点 B,但是不能从节点 B 到节点 A。  u& A# d; ^1 n

: X  R! v# P$ x7 D! p* z' b: t, |   有向图加权图和非加权图如果节点之间的连接被分配了权重,我们就称其为加权图。权重仅分配给了节点之间的连接,仅和连接相关,不和节点相关。在下面的例子中我们可以看到,节点 0 和节点 4 之间连接的权重是 7;而节点 3 和节点 1 之间的权重是 4。& l) s7 F7 w1 Y1 L# {2 ~5 U) s
ddce93a9bfcdfeebb95346e430be6141.png * @$ [( [8 |  X/ b6 o
   加权图想要了解加权图,可以想象你需要向用户展现一个标注了不同地点的地图,你需要告诉用户从一个地方到另一个地方需要花多长时间。加权图就可以用来表现这个场景,你可以使用节点来存储地点的信息,节点之间的连接就是两个地点之间的道路,连接的权重代表从一个地点到另一个地点的物理距离。
  ~7 \* m+ C( f; P0 y& A- q a24d8efd090bdd8abb219df6a337bbcd.jpg
% \3 y9 ?0 d) b$ b   加权图被大量应用在定位系统你应该已经猜到了,无加权图即节点之间的连接没有被分配权重,所以节点间的连接没有额外的信息,只表达节点间的关系。如何表达图在编码图的时候,主要可以使用两种方法:邻接矩阵和邻接列表。让我们分别看看这两种方法的优缺点。邻接矩阵是一个二维结构代表图的节点和节点之间的连接。如果我们使用这个的例子:: B! y6 ~" l3 r$ L
5e2672b7002d34d333c2e012c7d22b17.png   P- g( f9 w9 v% r* J

1 j( ^7 `/ d* I0 C' s我们的邻接矩阵会是这个样子:
5 Q2 [4 F+ Y% p 0163bb755169f19fd2de33f2f8003b77.png
6 k% w) }6 y# ?/ z/ H# p矩阵可以用表格来表示,列和行来代表图里的节点,单元格内的值表示节点之间连接,如果单元格的值为 1,则表示该位置的行和列是相关联的,如果是 0,则表示没有联系。4 h* F* Y: i! O$ e* h) H; C
这个表格可以用简单的二维数组来表示:[% y- I, @8 Y" l4 c
    [0, 1, 1, 0]8 j+ B  m1 a- r2 b3 o5 F) y+ @6 G' u
    [1, 0, 0, 1]! i- v  H7 n9 z& ~1 s
    [1, 0, 0, 1]3 r( K0 W" t/ E
    [0, 1, 1, 0]: R7 V) E9 R3 P9 y" @6 y
]7 F& Y% `5 e2 _- X
邻接列表可以使用键值对结构来表示,键代表节点而值代表对应节点的连接。上面的例子,用邻接列表可以表达为:{: |# @, x/ u2 A3 @% N
    A: ["B", "C"],, K/ w+ W8 Y# T- M$ u8 e' b$ w" t
    B: ["A", "D"],
4 U2 i! q; T6 ]7 T  S    C: ["A", "D"],& h( I* m- O2 i0 m4 R
    D: ["B", "C"],5 [9 z* k, P0 x0 h5 x4 b
}6 A4 Q* }; {! s) z- c
每一个节点为一个键,对应的值是与节点相连接的节点组成的数组。这就是邻接矩阵和列表的所有区别吗?除此之外,当我们需要添加或者删除节点的时候,列表会更加方便;而当我们需要查询某个节点之间的关联的话,矩阵更方便。假设要在我们的图里添加一个新的节点:5 Y1 f( k8 o2 X' q$ u  Y9 U  x6 ?
8e1f56fd7897b253c956836fe42e7f5c.png 8 s' N& v+ W* P% }& g

' p1 O, i9 [% q8 F' [1 J4 a如果要用矩阵来表达的话,我们需要添加一个全新的列和行:$ v1 W+ F9 g2 O
57c09843ecb1f36dfb51a735acd67508.png 7 h0 F, C& S1 x
但是在列表中,我们只需要在 B 的连接数组中添加一个值,以及再添加一个代表 E 的键值对就够了:0 V& E4 R9 s& G9 i5 C. q
{! u* R8 G; e5 _/ `; k7 i0 O
    A: ["B", "C"],/ u2 y5 M, Y7 C/ l
    B: ["A", "D", "E"],+ N6 `. I5 I: j$ @
    C: ["A", "D"],  X" Y* D* ~5 Y8 B1 `1 F, ~$ [3 F
    D: ["B", "C"],
! y  Q/ A2 E+ b! t    E: ["B"],' G* H% G* R' a: e
}$ e4 z+ p" j' M
现在假设我们需要验证 B 和 E 之间是否存在连接,在矩阵中检查就非常简单,因为我们知道节点间关联的位置位于哪个单元格。
" v8 G8 Y" s% s* I/ L eac8473246f24f25c97013c8d6be80c7.png 6 m% d2 A/ [& J  U! V7 s+ G
但如果是在列表中,我们不能马上得出结论,必须先遍历所有和 B 的连接相关的数组,来查看是否有 E。通过这个例子你就了解了两种形式的优劣了。邻接列表的完全实现如下,我们把图限定在无向和无权重,来简化代码:// 为图创建一个类$ y, s$ K. ^% `$ P1 b6 U, J
class Graph{
8 X$ x# T* c9 X( W, [0 T    // 图仅有一个属性,即邻接列表
$ w7 H7 _; U8 r- @  S* J& Z) @    constructor() {1 V6 m/ r6 A/ V( J0 F3 x# n
        this.adjacencyList = {}
; R  r9 K% t1 ^. z    }2 @4 I3 g# `6 G* ?" K
    // addNode 将节点值作为参数,如果邻接列表没有键的话,就把节点值传入邻接链表作为键
( e0 u% p: V- I% \6 n: b    addNode(node) {& S- l6 s7 I5 `0 I  v6 C" q/ H
        if (!this.adjacencyList[node]) this.adjacencyList[node] = []
. Q7 P; V% z1 b6 |' s6 _5 f/ n    }
; f1 u' {/ q$ \* u& v    // addConnection 将两个节点作为参数,并添加到每一个节点键对应的值的数组中
2 `* y* X+ w; X, j/ M1 q7 E    addConnection(node1,node2) {! S  Z9 D* L* j$ L
        this.adjacencyList[node1].push(node2)
' {7 x7 o' \. l3 F1 i        this.adjacencyList[node2].push(node1)
! G# K3 {  C/ E, r    }# b" ?+ G- x! E  W% }
    // removeConnection 方法将两个节点作为参数,并删除掉非自己节点对应数组里的值, m( W+ f! L! n" I# x
    removeConnection(node1,node2) {) s+ z- ^" c9 v1 w
        this.adjacencyList[node1] = this.adjacencyList[node1].filter(v => v !== node2)# W7 P0 _8 g9 @0 X$ i3 j, r
        this.adjacencyList[node2] = this.adjacencyList[node2].filter(v => v !== node1)
: [* y+ a$ q2 Z( E% G6 m    }  v- _* v2 }7 P6 A1 d
    // removeNode 方法将节点作为参数,删除该节点所有的连接,并且删除列表中该节点相关的键
5 [' F& ?, k+ q- x    removeNode(node){& w# K6 P4 A' V3 \" _
        while(this.adjacencyList[node].length) {, ^6 l2 C, y9 C8 W6 C1 k
            const adjacentNode = this.adjacencyList[node].pop()' ~! s$ l1 [$ H( v5 [
            this.removeConnection(node, adjacentNode). V  E3 @4 j* J0 ^( S$ |' H
        }+ b( c' H1 m% O$ m" [
        delete this.adjacencyList[node]- G2 U6 a6 m* C
    }
/ C0 d$ |* w/ m7 l3 p/ a! a}% p; ^. v, U5 b" G3 |6 ]8 e$ U0 U
5 z% X" i1 Z2 s6 ~, L
const Argentina = new Graph()
2 I% Q' T9 o4 n% J+ QArgentina.addNode("Buenos Aires")4 D* v  ]' n% u+ W% M
Argentina.addNode("Santa fe")
4 K+ N; ?$ ^& w% r* p3 rArgentina.addNode("Córdoba")
, {5 \% V! \( d/ z" \, T4 EArgentina.addNode("Mendoza")6 Z7 C8 N7 y* w7 o! K
Argentina.addConnection("Buenos Aires", "Córdoba")6 \: H) b( E8 U$ f3 _
Argentina.addConnection("Buenos Aires", "Mendoza")- M4 O$ ], ?. M9 p6 l  \
Argentina.addConnection("Santa fe", "Córdoba")
5 A1 c) y9 V6 a- a7 B8 A
& p2 _. K1 {8 |+ I2 a4 B7 U$ Vconsole.log(Argentina)
7 O; H- b: X" f# V// Graph {
# j4 n0 t0 p) C8 [# N//     adjacencyList: {
2 i* c( ]+ x% s//         'Buenos Aires': [ 'Córdoba', 'Mendoza' ],; F: D) D( T# Q1 h/ X. y. C9 X! x
//         'Santa fe': [ 'Córdoba' ],
, X0 R' P' X1 ?; I; S. E//         'Córdoba': [ 'Buenos Aires', 'Santa fe' ],
2 h) |/ D9 T* C* U//         Mendoza: [ 'Buenos Aires' ]' V* r3 k) S) q% R( [
//     }
/ [& b0 k. j5 C. U// }1 w* i2 B! E, x* b/ A4 W
总结以上就是全部内容。在这篇文章中我们介绍了计算机科学和软件开发中的主要数据结构。这些数据结构是许多程序的基础,所以学习这些知识非常有用。虽然刚开始接触这个话题的时候,你会觉得非常抽象甚至有些害怕,但是我相信当你把这些数据结构当作解决日常任务的一种方式的时候,你会更理解它们。希望你享受阅读这篇文章,并且从中受益。我们下篇文章见!
% E# X: f" d/ h4 }2 e原文链接:https://www.freecodecamp.org/new ... ript-with-examples/作者:Germán Cocca译者:Papaya&#8205;HUANG# B: j* F' o5 t) o# Q
在线贡献者交流会预告在线贡献者交流会将于北京时间 2022 年 7 月 10 日周日上午 10:00 - 11:00 开展(每两周一次,都在这个时间段开展)。欢迎大家添加小助手微信 fcczhongguo,加入会议室。! o$ o" a. U$ K3 A) R4 s, ^7 s  l
74f76f2eafcd9ba2233554b01a85b130.jpg
$ f% n3 l0 I2 [1 L- R开源公益社区 freeCodeCamp.org 自 2014 年成立以来,以“帮助人们免费学习编程”为使命,创建了大量免费的编程教程,包括交互式课程、视频课程、文章等。我们正在帮助全球数百万人学习编程,希望让世界上每个人都有机会获得免费的优质的编程教育资源,成为开发者或者运用编程去解决问题。&#10024; &#10024; &#10024;年度总结丨2021 年世界各地的开发者在 freeCodeCamp 学习 21 亿分钟(4000 年)freeCodeCamp 教育公益下一个目标:免费提供大学计算机科学学士学位参与 freeCodeCamp 开源社区翻译协作,帮助全世界人们用母语免费学习编程) b5 p" X9 V9 T6 ~/ W: q
' Y" E  h( j+ c! Y) }* r

' I" U" L8 `/ M5 @) y7 l点击“阅读原文”在 freeCodeCamp 专栏了解更多         
6e6c34e930d64ef6808f083b13539b13.png

最近浏览会员:

  • 北极孤星
    2023-08-02
商乾电商学院,中国最大的电商资源交流基地!
您需要登录后才可以回帖 登录 | 加入我们

本版积分规则

商乾全球电商人、电商交流学习与电商实战技术分享、电商爬虫、生活交流专业网站
  • 官方手机版

  • 微信公众号

  • 商务合作