Loiane Groner

Novatec
Copyright © Packt Publishing 2016. First published in the English language under the title ‘Learning
JavaScript Data Structures and Algorithms - Second Edition – (9781785285493)’

Copyright © Packt Publishing 2016. Publicação original em inglês intitulada ‘Learning JavaScript
Data Structures and Algorithms - Second Edition – (9781785285493)’. Esta tradução é publicada e
vendida com a permissão da Packt Publishing.

© Novatec Editora Ltda. [2017].

Todos os direitos reservados e protegidos pela Lei 9.610 de 19/02/1998. É proibida a reprodução
desta obra, mesmo parcial, por qualquer processo, sem prévia autorização, por escrito, do autor e
da Editora.

Editor: Rubens Prates PY20170322

Tradução: Lúcia A. Kinoshita
Revisão gramatical: Priscila A. Yoshimatsu
Editoração eletrônica: Carolina Kuwabata

ISBN: 978-85-7522-553-0

Histórico de impressões:
Março/2017 Primeira edição

Novatec Editora Ltda.

Rua Luís Antônio dos Santos 110
02460-000 – São Paulo, SP – Brasil
Tel.: +55 11 2959-6529
E-mail: novatec@novatec.com.br
Site: www.novatec.com.br
Twitter: twitter.com/novateceditora
Facebook: facebook.com/novatec
LinkedIn: linkedin.com/in/novatec
 Sumário

Agradecimentos................................................................................................. 13
Sobre a autora................................................................................................... 14
Sobre a revisora................................................................................................. 15
Prefácio............................................................................................................. 16
1 JavaScript – uma rápida visão geral............................................................... 21
Estrutura de dados e algoritmos em JavaScript......................................................... 22
Configuração do ambiente....................................................................................... 22
Configuração mínima para trabalhar com JavaScript............................................... 23
Usando servidores web (XAMPP).............................................................................24
Tudo a ver com JavaScript (Node.js)........................................................................ 25
Básico sobre o JavaScript..........................................................................................27
Variáveis................................................................................................................. 28
Escopo das variáveis...........................................................................................30
Operadores..............................................................................................................31
Truthy e falsy...........................................................................................................34
Funções dos operadores de igualdade (== e ===)......................................................35
Estruturas de controle..............................................................................................37
Instruções condicionais.......................................................................................37
Laços.......................................................................................................................39
Funções.................................................................................................................. 40
Programação orientada a objetos em JavaScript.........................................................41
Depuração e ferramentas..........................................................................................43
Introdução à ECMAScript....................................................................................... 44
ECMAScript 6 e ECMAScript 7......................................................................... 44
Tabela de compatibilidade...................................................................................45
Usando o Babel.js............................................................................................... 46

5
6 Estruturas de dados e algoritmos em JavaScript

Funcionalidades da ECMAScript 6...........................................................................47

Declarando variáveis com let em vez de var..........................................................47
Escopo das variáveis com let................................................................................48
Constantes.........................................................................................................50
Templates literais................................................................................................50
Funções de seta...................................................................................................51
Valores padrão para parâmetros de função...........................................................51
Declarando os operadores spread e rest................................................................52
Propriedades melhoradas de objetos....................................................................53
Programação orientada a objetos com classes.......................................................55
Herança..............................................................................................................56
Trabalhando com getters e setters........................................................................56
Outras funcionalidades.......................................................................................57
Funcionalidades da ECMAScript 7...........................................................................58
Compatibilidade de ES6 e ES7 com versões anteriores..........................................58
Resumo...................................................................................................................59

2 Arrays........................................................................................................... 60
Por que devemos usar arrays?.................................................................................. 60
Criando e inicializando arrays..................................................................................61
Acessando elementos e iterando em um array............................................................62
Acrescentando elementos.........................................................................................63
Usando o método push............................................................................................63
Inserindo um elemento na primeira posição............................................................. 64
Usando o método unshift........................................................................................ 64
Removendo elementos..............................................................................................65
Removendo um elemento da primeira posição...........................................................65
Usando o método shift............................................................................................ 66
Acrescentando e removendo elementos de uma posição específica............................ 66
Arrays bidimensionais e multidimensionais...............................................................67
Iterando pelos elementos de arrays bidimensionais....................................................69
Arrays multidimensionais.........................................................................................69
Referências para métodos de array em JavaScript......................................................70
Juntando vários arrays.............................................................................................71
Funções de iteração..................................................................................................72
Iterando com o método every...................................................................................72
Iterando com o método some...................................................................................72
Iterando com forEach...............................................................................................73
Usando map e filter..................................................................................................73
Usando o método reduce..........................................................................................73
ECMAScript 6 e novas funcionalidades de Array......................................................74
Sumário 7

Iterando com forEach e funções de seta.....................................................................75

Iterando com o laço for..of........................................................................................75
Usando o novo iterador da ES6 (@@iterator)............................................................75
Métodos entries, keys e values de array................................................................76
Usando o método from...................................................................................... 77
Usando Array.of..................................................................................................78
Usando o método fill...........................................................................................78
Usando o método copyWithin.............................................................................79
Ordenando elementos............................................................................................. 80
Ordenação personalizada....................................................................................81
Ordenando strings..............................................................................................82
Pesquisa.............................................................................................................83
ECMAScript 6 – os métodos find e findIndex......................................................83
ECMAScript 7 – usando o método includes........................................................ 84
Convertendo um array em uma string...................................................................... 84
Classe TypedArray...................................................................................................85
Resumo.................................................................................................................. 86

3 Pilhas............................................................................................................ 87
Estrutura de dados pilha..........................................................................................87
Criando uma pilha.................................................................................................. 88
Empilhando elementos na pilha................................................................................89
Desempilhando elementos da pilha...........................................................................89
Dando uma espiada no elemento que está no topo da pilha...................................... 90
Verificando se a pilha está vazia............................................................................... 90
Limpando e exibindo os elementos da pilha..............................................................91
Usando a classe Stack...............................................................................................91
EcmaScript 6 e a classe Stack....................................................................................93
Declarando a classe Stack usando a sintaxe da ES6...................................................93
Classes ES6 com Symbols no escopo....................................................................... 94
Classes ES6 com WeakMap.....................................................................................95
Resolvendo problemas usando pilhas........................................................................97
Decimal para binário...............................................................................................98
Algoritmo conversor de base.................................................................................... 99
Resumo.................................................................................................................100

4 Filas.............................................................................................................101
Estrutura de dados fila...........................................................................................101
Criando uma fila....................................................................................................102
Inserção de elementos na fila.............................................................................103
8 Estruturas de dados e algoritmos em JavaScript

Remoção de elementos da fila............................................................................103

Espiando o elemento que está na frente na fila...................................................103
Verificando se a fila está vazia............................................................................104
Exibindo os elementos da fila............................................................................104
Usando a classe Queue.................................................................................104
A classe Queue usando a sintaxe da ECMAScript 6................................................106
Fila de prioridades.................................................................................................106
Fila circular – Batata Quente..................................................................................109
Filas de tarefas em JavaScript................................................................................. 111
Resumo.................................................................................................................112

5 Listas ligadas...............................................................................................113
Estrutura de dados da lista ligada...........................................................................113
Criando uma lista ligada........................................................................................115
Concatenando elementos no final da lista ligada................................................ 116
Removendo elementos da lista ligada................................................................. 118
Inserindo um elemento em qualquer posição.....................................................121
Implementando os demais métodos...................................................................124
Método toString..........................................................................................124
Método indexOf..........................................................................................124
Métodos isEmpty, size e getHead..................................................................126
Listas duplamente ligadas.......................................................................................126
Inserindo um novo elemento em qualquer posição.............................................127
Removendo elementos de qualquer posição........................................................130
Listas ligadas circulares..........................................................................................133
Resumo.................................................................................................................134

6 Conjuntos.....................................................................................................135
Estruturando um conjunto de dados.......................................................................135
Criando um conjunto.............................................................................................136
Método has (value)............................................................................................137
Método add......................................................................................................137
Métodos delete e clear.......................................................................................138
Método size......................................................................................................139
Método values..................................................................................................140
Usando a classe Set........................................................................................... 141
Operações relacionadas a conjuntos........................................................................ 141
União de conjuntos........................................................................................... 142
Intersecção de conjuntos...................................................................................143
Diferença entre conjuntos.................................................................................. 145
Sumário 9

Subconjunto.....................................................................................................146
ES6 – a classe Set...................................................................................................148
Operações com a classe Set da ES6....................................................................149
Simulando a operação de união....................................................................149
Simulando a operação de intersecção............................................................149
Simulando a operação de diferença...............................................................150
Resumo.................................................................................................................151

7 Dicionários e hashes.....................................................................................152
Dicionários............................................................................................................152
Criando um dicionário......................................................................................152
Métodos has e set.........................................................................................153
Método delete..............................................................................................154
Métodos get e values....................................................................................154
Métodos clear, size, keys e getItems..............................................................155
Usando a classe Dictionary...............................................................................156
Tabela hash............................................................................................................157
Criando uma tabela hash..................................................................................158
Usando a classe HashTable................................................................................160
Tabela hash versus conjunto hash...................................................................... 161
Tratando colisões nas tabelas hash.................................................................... 161
Encadeamento separado...............................................................................163
Sondagem linear..........................................................................................168
Criando funções melhores de hash...............................................................172
Classe Map da ES6................................................................................................173
Classes WeakMap e WeakSet da ES6..................................................................... 174
Resumo................................................................................................................. 175

8 Árvores........................................................................................................176
Estrutura de dados para árvores............................................................................. 176
Terminologia de árvores.........................................................................................177
A árvore binária e a árvore binária de busca............................................................178
Criando a classe BinarySearchTree....................................................................178
Inserindo uma chave em uma árvore.................................................................180
Percorrendo uma árvore.........................................................................................183
Percurso em ordem...........................................................................................184
Percurso pré-ordem...........................................................................................185
Percurso pós-ordem..........................................................................................186
Pesquisando valores em uma árvore........................................................................187
Pesquisando valores mínimos e máximos..........................................................188
10 Estruturas de dados e algoritmos em JavaScript

Pesquisando um valor específico........................................................................189

Removendo um nó............................................................................................192
Removendo uma folha.................................................................................194
Removendo um nó com um filho à esquerda ou à direita...............................195
Removendo um nó com dois filhos...............................................................195
Árvores autobalanceadas........................................................................................196
Árvore de Adelson-Velskii e Landi (árvore AVL).................................................197
Inserindo um nó na árvore AVL...................................................................197
Completando o método insertNode..............................................................203
Mais informações sobre árvores binárias...........................................................204
Resumo.................................................................................................................204

9 Grafos......................................................................................................... 205
Terminologia dos grafos.........................................................................................205
Grafos direcionados e não direcionados.............................................................207
Representando um grafo........................................................................................208
Matriz de adjacências........................................................................................208
Lista de adjacências...........................................................................................209
Matriz de incidência..........................................................................................210
Criando a classe Graph..........................................................................................211
Percorrendo grafos.................................................................................................213
Busca em largura (BFS)..................................................................................... 214
Encontrando os caminhos mais curtos usando BFS.......................................218
Estudos adicionais sobre algoritmos de caminhos mais curtos.......................221
Busca em profundidade (DFS)...........................................................................221
Explorando o algoritmo DFS........................................................................224
Ordenação topológica usando DFS...............................................................227
Algoritmos de caminhos mais curtos......................................................................229
Algoritmo de Dijkstra........................................................................................230
Algoritmo de Floyd-Warshall.............................................................................232
Árvore de extensão mínima (MST).........................................................................234
Algoritmo de Prim............................................................................................234
Algoritmo de Kruskal........................................................................................236
Resumo.................................................................................................................238

10 Algoritmos de ordenação e de busca............................................................ 239

Algoritmos de ordenação........................................................................................239
Bubble sort.......................................................................................................240
Bubble sort melhorado.................................................................................243
Selection sort....................................................................................................244
Sumário 11

Insertion sort....................................................................................................246
Merge sort........................................................................................................248
Quick sort........................................................................................................251
Processo de partição....................................................................................253
Quick sort em ação......................................................................................254
Heap sort..........................................................................................................258
Counting, bucket e radix sorts (as ordenações por distribuição)..........................261
Algoritmos de busca...............................................................................................262
Busca sequencial...............................................................................................262
Busca binária....................................................................................................263
Resumo.................................................................................................................265

11 Padrões de algoritmos................................................................................. 266

Recursão................................................................................................................266
Limitação do tamanho da pilha de chamadas em JavaScript...............................267
Sequência de Fibonacci.....................................................................................268
Programação dinâmica...........................................................................................270
O problema do número mínimo de moedas para troco.......................................271
O problema da mochila..................................................................................... 274
A maior subsequência comum...........................................................................277
Multiplicação de cadeia de matrizes...................................................................280
Algoritmos gulosos................................................................................................282
O problema do número mínimo de moedas para troco.......................................283
O problema fracionário da mochila...................................................................284
Introdução à programação funcional......................................................................286
Programação funcional versus programação imperativa......................................286
ES2015 e a programação funcional....................................................................287
A caixa de ferramentas funcional de JavaScript – map, filter e reduce..................288
As bibliotecas e estruturas de dados funcionais de JavaScript.............................291
Resumo.................................................................................................................292

12 Complexidade de algoritmos....................................................................... 293

Notação big-O.......................................................................................................293
Compreendendo a notação big-O......................................................................294
O(1)............................................................................................................294
O(n)............................................................................................................294
O(n2)...........................................................................................................296
Comparando as complexidades.........................................................................297
Estruturas de dados.....................................................................................298
Grafos.........................................................................................................298
12 Estruturas de dados e algoritmos em JavaScript

Algoritmos de ordenação..............................................................................298
Algoritmos de busca.....................................................................................299
Introdução à teoria de NP-completo..................................................................299
Problemas impossíveis e algoritmos heurísticos............................................ 300
Divertindo-se com algoritmos.................................................................................301
Resumo.................................................................................................................302