Algoritmos e estruturas de dados em Java: guia completo para iniciantes

Algoritmos e Estruturas de Dados em Java: do Iniciante ao Desenvolvedor Confiante

Java é uma das linguagens de programação mais populares do mundo, e o conhecimento de algoritmos e estruturas de dados é uma habilidade obrigatória para qualquer desenvolvedor Java. Independentemente de você estar se preparando para uma entrevista em uma grande empresa de TI ou simplesmente querer escrever um código mais eficiente, entender as estruturas de dados e algoritmos básicos em Java abrirá novas oportunidades para você. Neste artigo, vamos abordar os conceitos-chave que todo desenvolvedor deve conhecer e mostrar sua implementação em Java com exemplos práticos.

1. Estruturas de Dados Básicas em Java

Estruturas de dados são formas de organizar e armazenar dados. O Java fornece um rico conjunto de coleções integradas, mas entender como elas funcionam "por baixo dos panos" ajudará você a tomar decisões arquitetônicas corretas.

1.1 Arrays

Um array é a estrutura de dados mais simples, armazenando elementos do mesmo tipo em uma área contígua de memória. Em Java, os arrays têm comprimento fixo.

// Declaração e inicialização de um arrayint[] numbers = new int[5];numbers[0] = 10;numbers[1] = 20;numbers[2] = 30;numbers[3] = 40;numbers[4] = 50;

// Ou diretamente com valoresString[] fruits = {"Maçã", "Banana", "Laranja"};

// Percorrendo o arrayfor (int i = 0; i < fruits.length; i++) {    System.out.println(fruits[i]);}

// Enhanced for-eachfor (String fruit : fruits) {    System.out.println(fruit);}

Vantagens: acesso rápido por índice (O(1)).
Desvantagens: tamanho fixo, dificuldade para inserir e remover elementos.

1.2 LinkedList

Uma lista ligada consiste em nós, cada um contendo dados e uma referência ao próximo (ou anterior) nó. Em Java, existe a implementação integrada java.util.LinkedList.

import java.util.LinkedList;

LinkedList<String> list = new LinkedList<>();list.add("Primeiro");list.add("Segundo");list.addFirst("Zerésimo"); // Adicionar no iníciolist.addLast("Terceiro");   // Adicionar no final

System.out.println("Primeiro elemento: " + list.getFirst());System.out.println("Último elemento: " + list.getLast());System.out.println("Tamanho da lista: " + list.size());

// Remover elementolist.remove("Segundo");

Vantagens: inserção e remoção rápidas no início/fim da lista (O(1)).
Desvantagens: acesso lento por índice (O(n)).

1.3 Stack

Uma pilha funciona pelo princípio LIFO (Last In, First Out) — o último a entrar é o primeiro a sair. O Java fornece a classe Stack e a interface Deque para trabalhar com pilhas.

import java.util.Stack;

Stack<Integer> stack = new Stack<>();

// Adicionar elementosstack.push(10);stack.push(20);stack.push(30);

// Visualizar o elemento do topo sem removerSystem.out.println("Elemento do topo: " + stack.peek()); // 30

// Remover o elemento do topoint top = stack.pop();System.out.println("Removido: " + top); // 30System.out.println("Novo topo: " + stack.peek()); // 20

// Verificar se a pilha está vaziaSystem.out.println("A pilha está vazia? " + stack.isEmpty()); // false

Pilhas são frequentemente usadas para verificar a validade de sequências de parênteses, percorrer árvores e implementar algoritmos de "voltar/avançar" em navegadores.

1.4 Queue

Uma fila funciona pelo princípio FIFO (First In, First Out) — o primeiro a entrar é o primeiro a sair. Em Java, a fila é implementada através da interface Queue e da classe LinkedList.

import java.util.LinkedList;import java.util.Queue;

Queue<String> queue = new LinkedList<>();

// Adicionar ao final da filaqueue.offer("Cliente 1");queue.offer("Cliente 2");queue.offer("Cliente 3");