Javascript estrutura de dados e algoritmos 2 Ed. https://github.com/loiane/javascript-datastructures-algorithms/
Meu resumo e Código fonte do livro Javascript Estrutura de Dados e Algoritmos Ed. 2
Repositorio Oficcial - Loiane G. original do livro
Capítulo 01 JavaScript – uma visão geral rápida Capítulo 02 Visão geral sobre ECMAScript e TypeScript Capítulo 03 Arrays Capítulo 04 Pilhas Capítulo 05 Filas e deques Capítulo 06 Listas ligadas Capítulo 07 Conjuntos Capítulo 08 Dicionários e hashes Capítulo 09 Recursão Capítulo 10 Árvores Capítulo 11 Heap binário e heap sort Capítulo 12 Grafos Capítulo 13 Algoritmos de ordenação e de busca Capítulo 14 Designs de algoritmos e técnicas Capítulo 15 Complexidade de algoritmos
- Estrutura de dados e algoritmos em JavaScript - Configurando o ambiente - Configuração mínima para trabalhar com JavaScript - Básico sobre o JavaScript <!DOCTYPE html>
< html >
< head >
< meta charset ="UTF-8 ">
< title > 01</ title >
</ head >
< body >
< script type ="text/javascript " src ="01-helloWorld.js "> </ script >
< script type ="text/javascript ">
// alert('Hello, World!');
// console.log('Hello, World!');
</ script >
</ body >
</ html > function output ( t ) {
document . write ( '<h1>' + t + '</h1>' ) ;
}
alert ( 'Hello, World!' ) ;
console . log ( 'Hello, World!' ) ;
output ( 'Hello, World!' ) ; <!DOCTYPE html>
< html >
< head >
< meta charset ="UTF-8 ">
< title > 02</ title >
</ head >
< body >
< script type ="text/javascript " src ="02-Variables.js "> </ script >
</ body >
</ html > var num = 1 ; // {1}
num = 3 ; // {2}
var price = 1.5 ; // {3}
var myName = 'Packt' ; // {4}
var trueValue = true ; // {5}
var nullVar = null ; // {6}
var und ; // {7}
console . log ( 'num: ' + num ) ;
console . log ( 'myName: ' + myName ) ;
console . log ( 'trueValue: ' + trueValue ) ;
console . log ( 'price: ' + price ) ;
console . log ( 'nullVar: ' + nullVar ) ;
console . log ( 'und: ' + und ) ;
// ******* Variable Scope
var myVariable = 'global' ;
myOtherVariable = 'global' ;
function myFunction ( ) {
var myVariable = 'local' ;
return myVariable ;
}
function myOtherFunction ( ) {
myOtherVariable = 'local' ;
return myOtherVariable ;
}
console . log ( myVariable ) ; //{1}
console . log ( myFunction ( ) ) ; //{2}
console . log ( myOtherVariable ) ; //{3}
console . log ( myOtherFunction ( ) ) ; //{4}
console . log ( myOtherVariable ) ; //{5} /* Arithmetic operators */
var num = 0 ; // {1}
console . log ( 'num value is ' + num ) ;
num = num + 2 ;
console . log ( 'New num value is ' + num ) ;
num = num * 3 ;
console . log ( 'New num value is ' + num ) ;
num = num / 2 ;
console . log ( 'New num value is ' + num ) ;
num ++ ;
num -- ;
console . log ( 'New num value is ' + num ) ;
console . log ( 'num mod 2 value is ' + num % 2 ) ;
/* Assignment operators */
num += 1 ;
num -= 2 ;
num *= 3 ;
num /= 2 ;
num %= 3 ;
console . log ( 'New num value is ' + num ) ;
/* Assignment operators */
console . log ( 'num == 1 : ' + ( num == 1 ) ) ;
console . log ( 'num === 1 : ' + ( num === 1 ) ) ;
console . log ( 'num != 1 : ' + ( num != 1 ) ) ;
console . log ( 'num > 1 : ' + ( num > 1 ) ) ;
console . log ( 'num < 1 : ' + ( num < 1 ) ) ;
console . log ( 'num >= 1 : ' + ( num >= 1 ) ) ;
console . log ( 'num <= 1 : ' + ( num <= 1 ) ) ;
/* Logical operators */
console . log ( 'true && false : ' + ( true && false ) ) ; // false
console . log ( 'true || false : ' + ( true || false ) ) ; // true
console . log ( '!true : ' + ! true ) ; // false
/* Bitwise operators */
console . log ( '5 & 1:' , 5 & 1 ) ; // same as 0101 & 0001 (result 0001 / 1)
console . log ( '5 | 1:' , 5 | 1 ) ; // same as 0101 | 0001 (result 0101 / 5)
console . log ( '~ 5:' , ~ 5 ) ; // same as ~0101 (result 1010 / 10)
console . log ( '5 ^ 1:' , 5 ^ 1 ) ; // same as 0101 ^ 0001 (result 0100 / 4)
console . log ( '5 << 1:' , 5 << 1 ) ; // same as 0101 << 1 (result 1010 / 10)
console . log ( '5 >> 1:' , 5 >> 1 ) ; // same as 0101 >> 1 (result 0010 / 2)
/* typeOf */
console . log ( 'typeof num:' , typeof num ) ;
console . log ( 'typeof Packt:' , typeof 'Packt' ) ;
console . log ( 'typeof true:' , typeof true ) ;
console . log ( 'typeof [1,2,3]:' , typeof [ 1 , 2 , 3 ] ) ;
console . log ( 'typeof {name:John}:' , typeof { name : 'John' } ) ;
/* delete */
var myObj = { name : 'John' , age : 21 } ;
delete myObj . age ;
console . log ( myObj ) ; // Object {name: "John"} function testTruthy ( val ) {
return val ? console . log ( 'truthy' ) : console . log ( 'falsy' ) ;
}
testTruthy ( true ) ; // true
testTruthy ( false ) ; // false
testTruthy ( new Boolean ( false ) ) ; // true (object is always true)
testTruthy ( '' ) ; // false
testTruthy ( 'a' ) ; // true
testTruthy ( 'Packt' ) ; // true
testTruthy ( new String ( '' ) ) ; // true (object is always true)
testTruthy ( 1 ) ; // true
testTruthy ( - 1 ) ; // true
testTruthy ( NaN ) ; // false
testTruthy ( new Number ( NaN ) ) ; // true (object is always true)
testTruthy ( { } ) ; // true (object is always true)
var obj = { name : 'John' } ;
testTruthy ( obj ) ; // true
testTruthy ( obj . name ) ; // true
testTruthy ( obj . age ) ; // false (property age does not exist) - Funções dos operadores de igualdade (== e ===) // Packt == true
console . log ( 'packt' ? true : false ) ;
// outputs true
console . log ( 'packt' == true ) ;
// 1 - converts Boolean using toNumber
// 'packt' == 1
// 2 - converts String using toNumber
// NaN == 1
// outputs false
console . log ( 'packt' == false ) ;
// 1 - converts Boolean using toNumber
// 'packt' == 0
// 2 - converts String using toNumber
// NaN == 0
// outputs false
console . log ( [ 0 ] == true ) ;
// 1 - converts Boolean using toNumber
// [0] == 1
// 2 - converts Object using toPrimitive
// 2.1 - [0].valueOf() is not primitive
// 2.2 - [0].toString is 0
// 0 == 1
// outputs false
//* ****************************** ===
console . log ( 'packt' === true ) ; // false
console . log ( 'packt' === 'packt' ) ; // true
var person1 = { name : 'John' } ;
var person2 = { name : 'John' } ;
console . log ( person1 === person2 ) ; // false, different objects - Instruções condicionais - Programação orientada a objetos em Javascript - Depuração e ferramentas Voltar ao Índice
- ECMAScript ou JavaScript? - ES6, ES2015, ES7, ES2016, ES8, ES2017 e ES.Next - Tabela de compatibilidade - Funcionalidades das versões ECMAScript 2015+ - let e const no lugar de var - Escopo de variáveis com let e const - Valores default para parâmetros de funções - Declarando os operadores de espalhamento e rest - Propriedades melhoradas de objetos - Programação orientada a objetos com classes - Trabalhando com getters e setters - Operador de exponencial - Executando módulos ES2015 no navegador e com o Node.js - Usando importações nativas da ES2015 no Node.js - Executando módulos ES2015 no navegador - Compatibilidade de versões anteriores a ES2015+ - Introdução ao TypeScript - Outras funcionalidades do TypeScript - Verificações do TypeScript em tempo de compilação em arquivos JavaScript Voltar ao Índice
- Por que devemos usar arrays? - Criando e inicializando arrays - Acessando elementos e fazendo uma iteração em um array - Acrescentando elementos - Inserindo um elemento no final do array - Inserindo um elemento na primeira posição - Usando o método unshift - Removendo um elemento do final do array - Removendo um elemento da primeira posição - Adicionando e removendo elementos de uma posição específica - Arrays bidimensionais e multidimensionais - Iterando pelos elementos de arrays bidimensionais - Arrays multidimensionais - Referências para métodos de array em JavaScript - Iterando com o método every - Iterando com o método some - ECMAScript 6 e as novas funcionalidades de array - Iterando com o laço for…of - Usando o objeto @@iterator - Métodos entries, keys e values de array - Usando o método Array.of - Usando o método copyWithin - Ordenação personalizada - ECMAScript 2015 – os métodos find e findIndex - ECMAScript 2016 – usando o método includes - Convertendo um array em uma string Voltar ao Índice
- Criação de uma biblioteca de estruturas de dados e algoritmos JavaScript - Estrutura de dados de pilha - Criando uma classe Stack baseada em array - Push de elementos na pilha - Pop de elementos da pilha - Dando uma espiada no elemento que está no topo da pilha - Verificando se a pilha está vazia - Limpando os elementos da pilha - Criando uma classe JavaScript Stack baseada em objeto - Push de elementos na pilha - Verificando se a pilha está vazia e o seu tamanho - Pop de elementos da pilha - Dando uma espiada no topo e limpando a pilha - Criando o método toString - Protegendo os elementos internos da estrutura de dados - Convenção de nomenclatura com underscore - Classes ES2015 com símbolos no escopo - Classes ES2015 com WeakMap - Proposta para campos de classe na ECMAScript - Resolvendo problemas usando pilhas - Convertendo números decimais para binários - Algoritmo conversor de base Voltar ao Índice
- Estrutura de dados de fila - Inserção de elementos na fila - Remoção de elementos da fila - Dando uma espiada no elemento que está na frente da fila - Verificando se a pilha está vazia e o seu tamanho - Criando o método toString - Estrutura de dados de deque - Adicionando elementos na frente do deque - Resolvendo problemas usando filas e deques - Fila circular – Batata Quente - Verificador de palíndromo - Filas de tarefas em JavaScript Voltar ao Índice
- Estrutura de dados da lista ligada - Criando a classe LinkedList - Inserindo elementos no final da lista ligada - Removendo elementos de uma posição específica da lista ligada - Percorrendo a lista com um laço até alcançar a posição desejada - Refatorando o método remove - Inserindo um elemento em qualquer posição - Método indexOf: devolvendo a posição de um elemento - Removendo um elemento da lista ligada - Métodos isEmpty, size e getHead - Listas duplamente ligadas - Inserindo um novo elemento em qualquer posição - Removendo elementos de qualquer posição - Listas ligadas circulares - Inserindo um novo elemento em qualquer posição - Removendo elementos de qualquer posição - Listas ligadas ordenadas - Inserindo elementos na ordem - Criando a classe StackLinkedList Voltar ao Índice
- Estruturando um conjunto de dados - Intersecção de conjuntos - Aperfeiçoando o método intersection - Diferença entre conjuntos - ECMAScript 2015 – a classe Set - Operações com a classe Set da ES2015 - Simulando a operação de união - Simulando a operação de intersecção - Simulando a operação de diferença - Usando o operador de espalhamento Voltar ao Índice
- Estrutura de dados de dicionário - Criando a classe Dictionary - Verificando se uma chave está presente no dicionário - Definindo uma chave e um valor no dicionário, e a classe ValuePair - Removendo um valor do dicionário - Obtendo um valor do dicionário - Métodos keys, values e valuePairs - Iterando pelos ValuePairs do dicionário com forEach - Métodos clear, size, isEmpty e toString - Usando a classe Dictionary - Criando uma classe HashTable - Criando uma função de hash - Inserindo uma chave e um valor na tabela hash - Obtendo um valor da tabela hash - Removendo um valor da tabela hash - Usando a classe HashTable - Tabela hash versus conjunto hash - Tratando colisões nas tabelas hash - Criando funções melhores de hash - Classes WeakMap e WeakSet da ES2015 Voltar ao Índice
- Calculando o fatorial de um número - Limitação do tamanho da pilha de chamadas em JavaScript - Fibonacci com memoização - Por que usar recursão? É mais rápido? Voltar ao Índice
- Estrutura de dados de árvore - Terminologia de árvores - Árvore binária e árvore binária de busca - Criando as classes Node e BinarySearchTree - Inserindo uma chave na BST - Pesquisando valores em uma árvore - Pesquisando valores mínimos e máximos - Pesquisando um valor específico - Removendo um nó com um filho à esquerda ou à direita - Removendo um nó com dois filhos - Árvores autobalanceadas - Árvore de Adelson-Velskii e Landi (árvore AVL) - Altura de um nó e o fator de balanceamento - Operações de balanceamento – rotações na árvore AVL - Rotação Esquerda-Esquerda: rotação simples à direita - Rotação Direita-Direita: rotação simples à esquerda - Esquerda-Direita: rotação dupla à direita - Direita-Esquerda: rotação dupla à esquerda - Inserindo um nó na árvore AVL - Removendo um nó da árvore AVL - Inserindo um nó na árvore rubro-negra - Verificando as propriedades da árvore rubro-negra após a inserção - Rotações na árvore rubro-negra Voltar ao Índice
- Estrutura de dados do heap binário - Criando a classe MinHeap - Representação da árvore binária com um array - Inserindo um valor no heap - Encontrando os valores mínimo e máximo no heap
- Extraindo os valores mínimo e máximo do heap
- Criando a classe MaxHeap Voltar ao Índice
- Terminologia dos grafos - Grafos direcionados e não direcionados - A matriz de adjacências - Encontrando os caminhos mais curtos usando BFS - Estudos adicionais sobre algoritmos de caminhos mais curtos - Busca em profundidade (DFS) - Explorando o algoritmo DFS - Ordenação topológica usando DFS - Algoritmos de caminho mais curto - Algoritmo de Floyd-Warshall - Árvore de extensão mínima (MST) Voltar ao Índice
- Algoritmos de ordenação - Algoritmos de embaralhamento - Algoritmo de embaralhamento de Fisher-Yates Voltar ao Índice
- Problema do número mínimo de moedas para troco - Maior subsequência comum - Multiplicação de cadeia de matrizes - Problema do número mínimo de moedas para troco - Problema fracionário da mochila - Algoritmos de backtracking - Introdução à programação funcional - Programação funcional versus programação imperativa - ES2015+ e a programação funcional - Caixa de ferramentas funcional de JavaScript – map, filter e reduce - Bibliotecas e estruturas de dados funcionais de JavaScript Voltar ao Índice
- Compreendendo a notação big-O - Comparando as complexidades - Algoritmos de ordenação - Introdução à teoria de NP-completo - Problemas impossíveis e algoritmos heurísticos - Divertindo-se com algoritmos Voltar ao Índice