DEV Community: Phyllipe Bezerra

File Compression: Understanding the Huffman Coding Algorithm

Phyllipe Bezerra — Thu, 26 Jan 2023 02:08:58 +0000

Hello! First of all I just wanna to make clear that this article is a result of me just trying to understand something new. Feel free to suggest or point out necessary corrections!

What is Huffman Enconding?

Huffman encoding is a lossless data compression algorithm that assings variable-length encoding "words" to fixed-length input characters based on their frequencies of occurence. These words are chosen in a way that more frequent characters have shorter words and less frequent characters have longer words.

Why Variable-length encoding?

Before that, let's understand what's the problem with fixed-length encoding. It's quite simple:

Fixed-length enconding waste space

See for example, the string "test tested test", since "test" appear three times we would be wasting space encoding this string with a fixed-length approach.

The solution

And here comes the variable-length approach:

Encoding of different lengths for different characters
Assing shorter encodings to frequently occuring characters

For exemple, take the word "test". First let's check the characters frequencies of occurence:

Characters	Frequency
t	2
e	1
s	1

Now create a linked list in ascending order based on the frequency, the list node element will have a character space, frequency space, a pointer to the next list node, and to make things simple, right and left pointers that we will use to create a binary tree soon. So it would be something like this:

Now we need to remove and "merge" the nodes with the two lowest frequencies, forming a new node that will be the parent node. The parent node will have the character value as an asterisk (*) and the frequency value will be the sum of its children. Also the left and right pointers will point to the lowest frequency child and the second lowest frequency child respectively. So for this step with our list we would get something like this:

And then we can put this tree at the tail of our list, and it will be like this:

While the head element of the list is not a parent node, i.e a node with character as asterisk, we need to repeat the previously step, so our list will be like this at the end of the second iteration:

At this point, we already can get the encoding for our characters. To get the enconding we need to go from the root node to the leaves tracking the direction, if we go left we can add the value 0 otherwise add 1 to the tracking value, for example:

To get the encoding for our character 'S' we need to go to the left and then left again, that way our enconding will be 00. For E character we need to go to the left and then right, so our encoding will be 01, and the T character we need to only go to the right and the encoding will be 1, at the end we would get the encodings as:

Characters	Frequency	Encoding
t	2	1
e	1	01
s	1	00

As you can see here we already have achieved the two rules previously mentioned:

Encoding of different lengths for different characters
Assing shorter encodings to frequently occuring characters

Now let's write down the encoded value of our string "test" and the binary value:

Binary Value: 01110100 01100101 01110011 01110100 - Length: 32
Encoded Value: 1 01 00 1 - Length: 6

As you can see here, we got a length reduction of 81%!

And that's my basic comprehension of the huffman encoding algorithm, next I will be probably coding a file compressor using the huffman encoding approach and I will leave the github repo link once done.

While that feel free to suggest or point out necessary corrections!

Estruturas de Dados: Entendendo e implementando Maps com Typescript

Phyllipe Bezerra — Sat, 17 Dec 2022 22:08:24 +0000

Vamos lá

Vamos lá, sobre Map: seu conceito é basicamente uma estrutura chave-valor, ou seja, teremos chaves únicas que são atreladas a determinados valores, bem como o nosso conhecido objeto do javascript mas com algumas diferenças:

Tipos das chaves

No objeto o tipo de dado que as chaves podem assumir estão restritos a números inteiros, strings e símbolos. Já no Map o tipo poe ser praticamente qualquer um (inteiros, strings, arrays, objetos, etc...)

const obj = {
    1: "Chave Número Inteiro",
    "A": "Chave String",
    [Symbol()]: "Chave Símbolo",

    [[1, 2, 3]]: "Chave Array" // Erro!
    [{ chave: "valor" }]: "Chave Objeto" // Erro!
};

Ordem dos elementos

No objeto a ordem dos elementos não é obrigatóriamente preservada, já nos Maps a ordem é preservada.

const obj = {
    "A": "Item 1",
    2: "Item 2",
    1: "Item 3"
};

console.log(Object.keys(obj)); // ["1", "2", "A"]

Para mais detalhes sobre o Map e suas diferenças é bom dar uma olhada na documentação:

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map

Map

Então vamos logo por a mão no código, vamos passar por cada método do Map e explicar a função de cada um, blz?

Definição

Para definir um Map é bem simples, para o nosso exemplo vamos criar um Map que servirá para guardar o nome e o email de diferentes alunos, o nome do aluno será a chave única que estará atrelada ao email do aluno.

// Criando um Map vazio, o primeiro tipo é o tipo da chave
// E o segundo tipo é o tipo do valor.
const alunos = new Map<string, string>();

Adicionando Valores

Agora precisamos adicionar os alunos nessa estrutura, certo? Para isso o Set conta com o método set que recebe dois parâmetros:

Map.set(key, value) - key é a chave que queremos atribuir o valor value.

Então digamos que precisamos adicionar 2 alunos novos e seus respectivos emails:

carlos, carlos@estudante.com
bianca, bianca@aluna.com

Para isso, basta fazer:

alunos.set("carlos", "carlos@estudante.com");
alunos.set("bianca", "bianca@aluna.com");

Recuperando Valores

Digamos agora que precisamos verificar qual o email de Bianca, para enviar as notas da prova para ela. Para isso podemos usar o método get do Map;

Map.get(key) - key é a chave do qual você deseja pegar o valor, é retornado então o valor caso exista, caso não exista é retornado undefined.

// Pegando o email dos alunos

const emailBianca = alunos.get("bianca");

console.log(emailBianca); // "bianca@aluna.com"

// Pegando email de um aluno que não está cadastrado
const emailFulano = alunos.get("fulano");

console.log(emailFulano); // undefined

Verificando Valores

Para prevenir esse problema de pegar o valor de uma chave que não existe, nós podemos simplesmente verificar se a chave realmente existe no Map, e para isso podemos usar o método has:

Map.has(key) - Verifica se no Map existe a chave key cadastrada e retorna true caso exista, false caso não exista.

// Verificando se o Fulano está cadastrado
const fulanoExiste = alunos.has("fulano");

console.log(fulanoExiste); // false

Removendo Chaves e Valores

Agora caso seja necessário remover um aluno cadastrado, tanto sua chave (nome) quanto seu valor (email), podemos utilizar o método delete:

Map.delete(key) - Remove a chave key e seu valor atrelado, retorna true caso a chave exista e tenha sido removida ou false caso a chave não exista e nada tenha sido removido.

// Removendo carlos
const carlosRemovido = alunos.delete("carlos");

console.log(carlosRemovido); // true

// Removendo um aluno que não existe
const fulanoRemovido = alunos.delete("fulano");

console.log(fulanoRemovido); // false

Verificando Tamanho e Limpando

Podemos também utilizar mais uma propriedade e um método bem úteis. A propriedade size e o método clear:

Map.size - Retorna um número inteiro contendo a quantidade de chaves presentes no Map.
Map.clear() - Limpa todos os valores do Map, ao final o Map não terá mais nada cadastrado nele.

// Verificando o tamanho do nosso map de alunos
// Tinhamos cadastrado 2 alunos no começo e removemos carlos
// anteriormente, então deve ter somente 1 aluno.

const quantidadeDeAlunos = alunos.size;

console.log(quantidadeDeAlunos); // 1

E agora, adivinha? Virou o ano, nova turma e precisamos limpar o Set para poder cadastrar os novos alunos que chegarão, então:

// Limpando nosso set
alunos.clear();

// Verificando o tamanho
console.log(alunos.size); // 0

E é isso, bem simples né? Para mais informações sobre a estrutura de dados e detalhes mais específicos sempre recomendo que leiam a documentação, segue o link:

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map

Estruturas de Dados: Entendendo e implementando Filas (Queues) com Typescript

Phyllipe Bezerra — Fri, 16 Dec 2022 23:40:39 +0000

Antes pilha, hoje fila

Anteriormente a gente tinha falado sobre pilhas (stacks) certo? Caso você não tenha lido é bom dar uma passada no artigo anterior pra entender algumas coisinhas que vamos abordar hoje, mas sem demorar muito, vamos lá.

Então, se lembram da stack? Eu tinha falado que ela era considerada na computação como do tipo FILO (First In, Last Out), no caso seria “Primeiro a entrar, último a sair”. Então, quando a gente pensa em filas (queues) é praticamente tudo idêntico as pilhas, a única diferença é que a fila é classificada como do tipo FIFO (!== FILO), perceba que o finalzinho muda:

FI LO - Primeiro a entrar, último a sair.
FI FO - Primeiro a entrar, primeiro a sair.

Isso significa que agora ao invés de pensar como se fosse uma pilha de livros a gente pode pensar como se fosse uma fila normal mesmo, de banco por exemplo; Imagina que você acordou 8h da manhã, precisa ir no banco pra resolver problema e tudo mais que não está funcionando resolver pelo app. Você chega lá e a fila ainda tá vazia! Primeiro da fila, pouco tempo depois chegam mais 10 pessoas atrás de você, qual seria a primeira pessoa a ser atendida?

Você que chegou primeiro, certo? Então pronto, a estrutura de dados fila é justamente isso, ao invés de remover o item do final da lista (como na pilha), nós vamos remover do começo.

Entendendo a fila

Então vamos falar da parte de código logo que é a coisa mais simples do mundo. Só duas coisinhas antes, provavelmente se vocês forem procurar conteúdos sobre filas e tudo mais, vão encontrar dois termos enqueue e dequeue, ambos são como geralmente são chamados o ato de adicionar na fila e remover, enqueue (enfileirar) e dequeue (desfileirar), ta bem? Aqui pra facilitar a gente vai usar os métodos do Typescript mesmo, que por sinal já nos dá de maneira nativa a opção de remover um item do começo de uma lista, é a função shift.

`shift()`

O método shift() remove o primeiro elemento da lista e retorna o elemento removido. Então a gente pode fazer assim:

// Vamos criar o array que vai ser nossa fila de pessoas no banco
const queue: string[] = [];

// Já sabemos do método `push` que vimos no artigo sobre pilhas, ele
// serve para adicionar um item no final do array, então digamos que
// a Carol acabou de chegar no banco e entrou na fila, então:

queue.push("Carol");

// Acabamos de adicionar a carol na fila [Carol], mas lógico que não
// vai ter só ela na fila, chegaram mais duas pessoas.

queue.push("Jaldo Script");
queue.push("Cecília Sharp");

// Então agora a nossa fila está com 3 pessoas [Carol, Jaldo, Cecília]
// O caixa chamou o próximo da fila, que é a carol que chegou primeiro
// então no código essa é a hora de retirar o primeiro da fila com o 
// método `shift`

let pessoaAtendida = queue.shift();

// Agora beleza, a carol que estava como primeira da fila acabou de ser
// atendida e não precisa mais estar na fila.

console.log(pessoaAtendida); // Carol
console.log(queue); // ["Jaldo Script", "Cecília Sharp"]

// E agora a nossa fila ficou assim [Jaldo, Cecília], logo após o caixa
// chamou o próximo que no caso foi o Sr. Jaldo Script

pessoaAtendida = queue.shift();
console.log(pessoaAtendida); // Jaldo Script

// E por fim, chamou a Sra. Cecília Sharp

pessoaAtendida = queue.shift();
console.log(pessoaAtendida);

// Pronto, atendemos todo mundo e na ordem certa, sem causar estresse!

E se lembrem... Sempre leiam a documentação!

E é isso, aprendemos mais um método simples e mais uma estrutura de dados! Vamos só repassar umas coisinhas:

Sempre adicionamos no final da fila, para isso usamos o método .push()
Sempre removemos do começo da fila e para isso usamos o .shift()
Filas ou Queues são classificadas como FIFO (First In First Out), ou seja, o primeiro a entrar é o primeiro a sair da fila.

Isso é quase tudo! Leiam as documentações e nos vemos na próxima estrutura.

Estruturas de Dados: Entendendo e implementando Pilhas (Stacks) com Typescript

Phyllipe Bezerra — Fri, 16 Dec 2022 23:22:23 +0000

Beleza, o que é uma pilha?

Tá bem, sem enrolar muito vamos lá... A pilha é uma estrutura que a gente escuta falar direto, é basicamente uma lista (array) só que tem a condição de que a última coisa que entra é a primeira que sai.

No typescript temos acesso a dois métodos muito úteis já presentes nas listas, vamos primeiro criar uma lista vazia e partir pra entender melhor esses métodos:

// Criando uma lista vazia que possuirá números
const list: number[] = [];

/* Nós apenas acabamos de definir a variável `list` 
* sendo do tipo `number[]`. o `number` é autoexplicativo, 
* é um número! Já o `[]` diz que será um array do tipo que
* vem antes, ou seja, um array de números! */

Agora que temos nossa lista vazia, vamos entender melhor esses dois métodos.

`push()`

Esse aqui é bem simples, ele adiciona ao final da lista o que passarmos pra ele. Como a lista que criamos antes vai conter números somente, então devemos apenas adicionar números, por exemplo:

// Vamos adicionar os números 2, 4 e 6 na lista que criamos

list.push(2); // Adiciona 2
list.push(4); // Adiciona 4
list.push(6); // Adiciona 6

console.log(list); // [2, 4, 6]

Simples né? E como retorno, ela retorna o tamanho da lista após adicionar o elemento, por exemplo:

const newList: number[] = [];

const listLength = newList.push(2);

console.log(listLength); // 1
console.log(newList); // [2]

Como sempre recomendo que vocês sempre leiam a documentação para ver detalhes mais específicos do que vocês vão utilizar. Link para a documentação

`pop()`

Esse também é bem simples, ele remove o elemento do final da lista e retorna esse elemento que foi removido, bem assim:

// Nossa lista está com 3 elementos se lembra? adicionamos [2, 4, 6]
// Agora vamos remover o último elemento
let removed = list.pop();

console.log(removed); // 6
console.log(list); // [2, 4]

// Removendo o último elemento de novo
removed = list.pop();

console.log(removed); // 4
console.log(list); // [2]

Porém, tem um ponto de atenção que precisamos tomar cuidado! Ele só vai remover elemento da lista enquanto houver elemento né?

Caso a lista esteja vazia ele não irá remover nada e nos retornará undefined, tipo assim:

const emptyList = [];

const removed = emptyList.pop();

console.log(removed); // undefined
console.log(emptyList); // []

Ai é só um ponto pra tomar cuidado, mas é facilmente tratado.

Leiam a documentação!

Ok, push e pop, mas e a pilha?

Vamos lá, (só uma informação antes). Se lembra que no começo eu falei que na pilha "última coisa que entra é a primeira que sai"? Então, esse conceito na programação é chamado de FILO (First In Last Out) (Primeiro a entrar, último a sair)

Usando e entendendo pilhas

Vamos pensar em uma pilha de livros real em cima de uma mesa, lá temos 3 livros. Como somos desenvolvedores, vamos simular esses livros empilhados com uma lista (só que de cabeça para baixo).

const books = [
    "Os três porquinhos", // Livro na base
    "Chapeuzinho vermelho", // Livro no meio
    "Alice no País das Maravilhas" // Livro no topo
];

Para você, é mais fácil pegar o livro que está em baixo de todos ou o que está em cima? Ao meu ver é mais fácil pegar o "Alice no país das maravilhas" do que levantar dois outros livros para poder pegar "Os três porquinhos", concorda?

Sendo assim, vamos pegar os livros do topo da pilha, para isso podemos usar o método pop que aprendemos.

let bookOnTop = books.pop();
console.log(bookOnTop); // "Alice no País das Maravilhas"

bookOnTop = books.pop();
console.log(bookOnTop); // "Chapeuzinho vermelho"

bookOnTop = books.pop();
console.log(bookOnTop); // "Os três porquinhos"

E agora nossa pilha está vazia, vamos adicionar um novo livro? Para isso também aprendemos o método push.

books.push("Crepúsculo");

console.log(books); // ["Crepúsculo"]

E é isso! Acabamos de entender como funciona uma pilha, só repassando tudo aqui:

Sempre adicionamos no topo da pilha e removemos também do topo
Para adicionar no topo utilizamos o método push
Para remover do topo utilizamos o método pop
Pilhas são do tipo FILO (First In Last Out) ou também podemos encontrar como LIFO (Last In First Out). Em ambos os casos é basicamente "O que entra por último, sai primeiro".

Isso é quase tudo! Leiam as documentações.

Agora praticando um pouquinho

O desafio de pilhas é o seguinte, você está trabalhando em um aplicativo de calculadora e o seu trabalho de hoje é criar uma função que cheque se os parênteses, colchetes e chaves de uma equação estão corretos, por exemplo:

Você receberá como entrada uma string como a string a seguir:

()[]{}

Podendo conter somente chaves, colchetes e parênteses, não terá nenhum outro caractere a não ser esses. A sua função deverá retornar verdadeiro caso a entrada seja válida ou falso caso não seja. Segue alguns exemplos de entrada abaixo:

1 - "()[]{}" // Entrada válida
2 - "([])"   // Entrada válida
3 - "([{"    // Entrada inválida, nenhum dos "(", "[" ou "{" abertos foram fechados
4 - "()]"    // Entrada inválida, o "]" foi fechado sem ter um par abrindo

É esse o desafio, uma dica é se atentem aos casos extremos, por exemplo, e se a entrada for vazia?

⚠️ Solução

Ta bem, vamos lá para a solução. Primeiro tem algumas regras que nós vamos precisar pensar:

Caso a entrada seja vazia, ela será válida pois não existe nada de errado nos parênteses, chaves ou colchetes da equação.
Só podemos fechar um caractere se o último caractere aberto for do mesmo tipo, por exemplo: (] não é válido, pois tentamos fechar com ] só que o que estava aberto era (.
Precisamos ficar atentos aos casos onde só tiveram caracteres abertos, por exemplo ((( não é uma entrada válida.

Então bora, primeiro vamos pensar o seguinte toda vez que tiver um char (caractere) abrindo nós vamos precisar salvar ele e toda vez que tiver um char fechando, vamos olhar qual foi o tipo do último char aberto. Caso seja do mesmo tipo podemos continuar, caso não seja já não é mais válido, blz?

Então vamos lá, primeiro vamos passar por todos os caracteres da entrada:

const checkEquation = (input: string): boolean => {
    // Vamos passar por todos os caracteres do input
    for (const char of input) {

    }
}

Vamos precisar criar um objeto para saber qual são os pares, por exemplo ( e ) são pares, e também precisamos checar quando que o caractere é abrindo e quando é fechando, para isso podemos só checar se o caractere é uma chave do nosso objeto de pares, se for então está abrindo.

const checkEquation = (input: string): boolean => {
    // Objeto para os pares
    const pairs = {
        "(": ")",
        "[": "]",
        "{": "}"
    };

    // Vamos passar por todos os caracteres do input
    for (const char of input) {
        if (char in pairs) {
            /* Caso {char} seja uma chave de {pairs} sabemos 
               que ele está abrindo */
        } else {
            // Caso não seja, ele está fechando
        }
    }
}

E agora é o seguinte, caso esteja abrindo nós precisamos salvar ele como o último char aberto, porém não podemos perder a referência dos anteriores também, é ai que entra a nossa pilha. Sempre que tiver abrindo vamos adicionar na pilha!

Caso precise ver o último char abrindo basta olhar o topo da pilha e o anterior fica lá até tirarmos o topo.

const checkEquation = (input: string): boolean => {
    // Objeto para os pares
    const pairs = {
        "(": ")",
        "[": "]",
        "{": "}"
    };

    // Criamos um tipo para os caracteres abertos
    type OpenChar = (keyof typeof pairs);

    // Criamos nossa pilha de chars abertos
    const queue = [];

    // Vamos passar por todos os caracteres do input
    for (const char of input) {
        if (char in pairs) {
            // Caso {char} seja uma chave de {pairs} sabemos 
            // que ele está abrindo.
            // E adicionamos na pilha
            queue.push(char);
        } else {
            // Caso não seja, ele está fechando
            // Ai precisamos verificar se o último char aberto 
            // é do mesmo tipo.

            // Primeiro antes de pegar o último aberto, vamos
            // checar se a pilha está vazia, se estiver não é 
            // válido já que estaria tentando fechar sem ter 
            // aberto.

            if (queue.length === 0) return false;

            // Se chegou até aqui sabemos que a pilha não está 
            // vazia, então vamos pegar o topo.
            const top = queue.pop() as OpenChar;

            // E verificar se são do mesmo tipo, {top} vai ser 
            // um char abrindo então podemos pegar seu par pelo
            // objeto {pairs} que criamos.

            const pair = pairs[top];

            // E verificamos se {char} e {pair} são iguais, se
            // for é valido e podemos seguir, se não é inválido.

            if (pair !== char) return false;
        }
    }
}

E agora precisamos checar dois pontos, primeiro caso a entrada seja vazia input.length === 0 e segundo caso a entrada seja só de char abertos, ai nossa pilha só teria char aberto, em outras palavras precisamos fechar todos os chars abertos para ser válido.

const checkEquation = (input: string): boolean => {
    // Caso a entrada seja vazia
    if (input.length === 0) return true;

    // Objeto para os pares
    const pairs = {
        "(": ")",
        "[": "]",
        "{": "}"
    };

    // Criamos um tipo para os caracteres abertos
    type OpenChar = (keyof typeof pairs);

    // Criamos nossa pilha de chars abertos
    const queue = [];

    // Vamos passar por todos os caracteres do input
    for (const char of input) {
        if (char in pairs) {
            // Caso {char} seja uma chave de {pairs} sabemos 
            // que ele está abrindo.
            // E adicionamos na pilha
            queue.push(char);
        } else {
            // Caso não seja, ele está fechando
            // Ai precisamos verificar se o último char aberto 
            // é do mesmo tipo.

            // Primeiro antes de pegar o último aberto, vamos
            // checar se a pilha está vazia, se estiver não é 
            // válido já que estaria tentando fechar sem ter 
            // aberto.

            if (queue.length === 0) return false;

            // Se chegou até aqui sabemos que a pilha não está 
            // vazia, então vamos pegar o topo.
            const top = queue.pop() as OpenChar;

            // E verificar se são do mesmo tipo, {top} vai ser 
            // um char abrindo então podemos pegar seu par pelo
            // objeto {pairs} que criamos.

            const pair = pairs[top];

            // E verificamos se {char} e {pair} são iguais, se
            // for é valido e podemos seguir, se não é inválido.

            if (pair !== char) return false;
        }
    }

    // Precisamos garantir que todos os char abertos foram fechados
    // para isso podemos só checar se a pilha ainda tem algum char.

    return queue.length === 0;
}

E é isso, algum dos resultados:

console.log(checkEquation("")); // true
console.log(checkEquation("()[]{}")); // true
console.log(checkEquation("([{}])")); // true
console.log(checkEquation("([{")); // false
console.log(checkEquation("}])")); // false

Pode parecer assustador a princípio por ser muitas linhas de código mas é por causa dos comentários, segue abaixo a função sem comentários:

const checkEquation = (input: string): boolean => {

    if (input.length === 0) return true;

    const pairs = {
        "(": ")",
        "[": "]",
        "{": "}"
    };

    type OpenChar = (keyof typeof pairs);

    const queue = [];

    for (const char of input) {
        if (char in pairs) {
            queue.push(char);
        } else {
            if (queue.length === 0) return false;

            const top = queue.pop() as OpenChar;
            const pair = pairs[top];

            if (pair !== char) return false;
        }
    }

    return queue.length === 0;
}

É isso, mas sempre comentem seus códigos viu!! Até a próxima estrutura de dados.

Entendendo e aplicando estruturas de dados com Typescript

Phyllipe Bezerra — Fri, 16 Dec 2022 23:13:12 +0000

Estrutura do que?

Algoritmos e estrutura de dados são dois termos que a gente escuta bastante ao longo da carreira como desenvolvedor, geralmente a maioria dos desenvolvedores sabem que esses dois pontos são bem importantes, porém devido ao nível de abstração que as linguagens de programação já se encontram, dificilmente o programador vai precisar implementar alguma estrutura de dados a partir do zero e com certeza já vai ter uma função já da linguagem ou até mesmo uma biblioteca que faça o serviço necessário. Mas parando para pensar, se estruturas de dados e algoritmos são usados por detrás dos panos já pra deixar tudo mais eficiente e rápido, por que não aprender sobre pra deixar o nosso código mais eficiente por exemplo?

Mas afinal, o que são estruturas de dados? Resumindo, a gente pode pensar que é uma maneira específica de organizar os dados na memória do computador de uma forma que certas operações fiquem mais fáceis e mais eficientes. Você já convive com estruturas de dados diariamente no seu código, variáveis comuns já são estruturas de dados primitivas, ou seja, quando você digita aquele:

const variável = 10;

Você acabou de definir uma estrutura de dados, ela está organizando os bits na memória do computador de forma que contenha o valor 10. Mas o que vamos falar é sobre estruturas de dados mais complexas.

Quais estruturas vamos aprender?

Atenção! Os artigos escritos tendem a focar na galera que está começando a aprender sobre as estruturas de dados, nenhum ou pouco código complexo será utilizado (caso tenha tentarei deixar o mais explicado possível).

Outro ponto é de que o conteúdo pode ser dinâmico, qualquer sugestão ou correção sintam-se a vontade para comentar!

Ao longo do tempo estarei escrevendo os artigos específicos para cada uma das estruturas abaixo, tentei manter de uma maneira em que o nível de complexidade seja crescente e que possamos utilizar conceitos reaproveitados de uma nas outras.

Pilhas (Stacks)
Filas (Queues)
Hash Maps
(Em Andamento) Hash Sets
(Em Andamento) Listas Encadeadas
(Em Andamento) Hash Tables
(Em Andamento) Árvores
(Em Andamento) Grafos