Estruturas de Dados: Arrays, Pilhas, Filas, Árvores e Hash

Estruturas de dados são formatos de organização de informações na memória de um programa, usados para armazenar, acessar e manipular dados com eficiência. Arrays, listas, pilhas, filas, árvores, grafos e tabelas hash resolvem problemas de coleção, ordem de processamento, hierarquia e busca rápida.

• O que são estruturas de dados?
• Qual estrutura de dados usar em cada situação?
• Qual a diferença entre array e lista?
• Pilhas e filas: LIFO e FIFO na prática
• Árvores: hierarquia em nós pai e filho
• Para que servem os grafos?
• Como funcionam as tabelas hash?

O que são estruturas de dados?

Estruturas de dados são formas padronizadas de armazenar e organizar valores na memória, de modo que operações como busca, inserção e remoção sejam executadas no menor tempo possível. Enquanto uma variável guarda um único dado, a estrutura de dados define como vários dados se relacionam entre si — e essa escolha determina a velocidade e o consumo de memória do software.

Estruturas de dados formam, junto com os algoritmos, a base da lógica de programação: não existe programa eficiente sem uma decisão consciente sobre como os dados serão guardados. A relevância do tema segue alta: a Stack Overflow Developer Survey 2025 mostra o JavaScript como linguagem mais usada, por 66% das pessoas desenvolvedoras, e o SQL por 59% — e ambos dependem diretamente de arrays, árvores e tabelas hash em seus interpretadores e motores de consulta.

Qual estrutura de dados usar em cada situação?

A escolha da estrutura de dados depende de duas perguntas: como os dados precisam ser acessados e com que frequência eles mudam. Coleções de tamanho conhecido pedem arrays; inserções constantes pedem listas ligadas; ordem de processamento pede pilhas ou filas; hierarquias pedem árvores; relacionamentos em rede pedem grafos; e busca por chave pede tabelas hash.

A tabela acima resume o critério prático: identifique o padrão de acesso dominante do seu problema e escolha a estrutura cuja operação principal é a mais barata para esse padrão.

Qual a diferença entre array e lista?

Array é uma coleção ordenada de elementos do mesmo tipo, com tamanho fixo e acesso direto por índice — ideal quando a quantidade de itens é conhecida antecipadamente. Lista é uma coleção flexível, que cresce e encolhe em tempo de execução por meio de nós encadeados, como nas listas ligadas e duplamente ligadas.

Na prática, as linguagens modernas borram essa fronteira. Em JavaScript, o objeto Array documentado na MDN já se comporta como lista dinâmica, redimensionando-se automaticamente. Em Python, o tipo list da documentação oficial funciona da mesma forma — e o guia de Python do CodeCrush mostra essas listas com exemplos de código para quem está começando.

A diferença conceitual, porém, continua importando: arrays contíguos oferecem leitura em tempo constante e aproveitam melhor o cache do processador, enquanto listas ligadas permitem inserir e remover elementos no meio da coleção sem realocar todo o bloco de memória.

Pilhas e filas: LIFO e FIFO na prática

Pilhas e filas são estruturas especializadas que controlam a ordem de acesso aos elementos: não importa apenas o que está guardado, mas quem entra e quem sai primeiro. Cada uma possui operações específicas de inserção e remoção que seguem uma lógica fixa.

Pilha: funciona no princípio LIFO (Last In, First Out — último a entrar, primeiro a sair). Os elementos são adicionados e removidos sempre pelo topo. A pilha é usada no gerenciamento de chamadas de função (a call stack), no botão desfazer de editores e na navegação de histórico dos navegadores.

Fila: funciona no princípio FIFO (First In, First Out — primeiro a entrar, primeiro a sair). Os elementos entram no final e saem do início. A fila é usada em filas de impressão, processamento de tarefas em segundo plano e sistemas de mensageria, onde a ordem de chegada precisa ser respeitada.

Árvores: hierarquia em nós pai e filho

Árvores são estruturas hierárquicas compostas por nós interconectados a partir de um nó raiz, em relações de pai e filho. As árvores aparecem em índices de bancos de dados, sistemas de arquivos, interfaces (o DOM é uma árvore) e nos modelos de decisão usados em machine learning.

Um exemplo prático é a árvore de decisão, em que cada nó representa um teste sobre um atributo:

Árvore de decisão:
        Atributo X <= 30?
         /           \
       Sim           Não
        |             |
     Tomate         Maçã

Neste exemplo:

• O nó raiz pergunta se o atributo X é menor ou igual a 30.
• Se a resposta é sim, o caminho segue para o nó da esquerda, classificado como tomate.
• Se a resposta é não, o caminho segue para o nó da direita, classificado como maçã.

Essa mecânica de decisões encadeadas explica por que árvores dominam a classificação e a previsão em ciência de dados. O peso dessas áreas só cresce: no relatório Octoverse 2024, o GitHub registrou que o Python ultrapassou o JavaScript como linguagem mais usada da plataforma, impulsionado por IA (Inteligência Artificial) e ciência de dados, e que o uso de Jupyter Notebooks cresceu 92% em um ano.

Para que servem os grafos?

Grafos servem para modelar relacionamentos entre entidades: são conjuntos de nós conectados por arestas, capazes de representar qualquer rede — amizades em redes sociais, rotas entre cidades, dependências entre pacotes de software ou links entre páginas da web.

Um grafo de amizades ilustra a ideia. Considere três amigas: Renata, Carol e Maria.

Grafo de amizades:
  Renata —— Carol
    |
  Maria

Neste exemplo:

• Renata é amiga de Carol (aresta Renata—Carol).
• Renata também é amiga de Maria (aresta Renata—Maria).
• Carol e Maria não possuem aresta direta: a conexão entre elas passa por Renata.

Em uma rede social real, esse grafo cresce para milhões de nós e arestas, e outros tipos de relação — "segue", "trabalha com" — viram novas arestas. Algoritmos de caminho mínimo e de recomendação percorrem exatamente essa estrutura para sugerir amigos, calcular rotas e ranquear conteúdo.

Como funcionam as tabelas hash?

Tabelas hash funcionam aplicando uma função hash sobre a chave de cada item para calcular a posição onde o valor fica armazenado. Esse cálculo direto permite buscar, inserir e remover em tempo médio constante, independentemente do tamanho da tabela — por isso elas sustentam caches, índices e os dicionários nativos de várias linguagens.

Suponha um sistema bancário que armazena informações de clientes e precisa acelerar a busca:

Tabela hash de clientes:
  +---------------+---------------------------------------------+
  |     Chave     |                    Valor                    |
  +---------------+---------------------------------------------+
  |    123456     | Nome: Renata, Saldo: 5000, Tipo: Premium    |
  |    987654     | Nome: Carol,  Saldo: 3000, Tipo: Regular    |
  |    555555     | Nome: Maria,  Saldo: 8000, Tipo: Premium    |
  +---------------+---------------------------------------------+

Ao buscar o cliente de ID 123456, a função hash calcula diretamente a posição do registro na tabela, sem percorrer os demais — um acesso direto que não degrada conforme a base cresce.

Tabelas hash precisam tratar colisões, situações em que duas chaves diferentes produzem o mesmo valor de hash. As técnicas clássicas são o encadeamento (cada posição guarda uma pequena lista de itens) e a sondagem (o item procura a próxima posição livre). Os dicionários do Python, descritos na documentação oficial de estruturas de dados, implementam exatamente esse mecanismo de mapeamento chave-valor.

Conclusão

Dominar estruturas de dados é o investimento com melhor retorno técnico na carreira de quem programa: é o que separa código que apenas funciona de código que escala. Antes de escrever a próxima função, vale perguntar qual estrutura representa melhor o problema — trocar uma busca linear em lista por uma tabela hash, ou uma hierarquia improvisada por uma árvore, costuma render ganhos de desempenho de ordens de magnitude sem reescrever o sistema.