Listas Encadeadas

Para manipulação básica de nós em uma lista encadeada, frequentemente utilizamos um nó sentinela (dummy node) para facilitar operações de inserção e remoção no início da lista.

// Criando um nó auxiliar apontando para o início da lista
ListNode* sentinela = new ListNode(-1, cabeca);

Pilhas (Stack)

A estrutura std::stack segue o princípio LIFO (Last In, First Out).

stack<int> pilha;
pilha.push(10);
pilha.push(20);

int topo = pilha.top();    // Retorna 20
int tamanho = pilha.size(); // Retorna 2
pilha.pop();               // Remove o 20
bool vazia = pilha.empty(); // Retorna false

Filas (Queue)

A std::queue opera no sistema FIFO (First In, First Out).

queue<string> fila;
fila.push("primeiro");
fila.push("segundo");

string inicio = fila.front(); // "primeiro"
string fim = fila.back();     // "segundo"
fila.pop();                   // Remove "primeiro"

Filas de Dupla Extremidade (Deque)

O std::deque permite inserções e remoções eficientes em ambas as pontas.

deque<int> dq;
dq.push_back(1);
dq.push_front(0);
dq.pop_back();
dq.pop_front();
int frente = dq.front();
int tras = dq.back();

Heap (Fila de Prioridade)

A std::priority_queue por padrão é um Max-Heap. Abaixo, um exemplo de implementação de um Min-Heap utilizando um comparador customizado para pares.

struct Comparador {
    bool operator()(const pair<int, int>& a, const pair<int, int>& b) {
        return a.second > b.second; // Ordem crescente pelo segundo elemento
    }
};

priority_queue<pair<int, int>, vector<pair<int, int>>, Comparador> minHeap;

minHeap.push({1, 100});
minHeap.pop();
auto topo = minHeap.top();

Vetores (Arrays Dinâmicos)

O std::vector é a estrutura mais versátil para coleções sequenciais. Nota: Ao inicializar com tamanho fixo, evite push_back se pretender usar índices diretamente.

// Vetor unidimensional: tamanho 10, preenchido com -1
vector<int> v(10, -1);

// Matriz bidimensional (Ex: 5x5 preenchida com 0)
vector<vector<int>> matriz(5, vector<int>(5, 0));

v.push_back(5);
v.pop_back();
v.insert(v.begin() + 1, 10); // Insere no índice 1
v.clear(); // Limpa elementos, mas nem sempre libera a memória alocada imediatamente

Listas Duplamente Encadedaas (std::list)

Útil para inserções rápidas em qualquer posição quando já se tem o ietrador.

list<int> listaL;
auto it = listaL.begin();
advance(it, 2); // Move o iterador 2 posições
listaL.insert(it, 50);

Conjuntos (Set)

Utilize unordered_set para busca em tempo constante médio ou set para manter os dados ordenados.

unordered_set<int> conjunto;
conjunto.insert(10);

if (conjunto.find(10) != conjunto.end()) {
    // Elemento encontrado
}

// Inicialização a partir de um vetor
vector<int> dados = {1, 2, 2, 3};
unordered_set<int> unico(dados.begin(), dados.end());

Mapas (Dicionários)

Estrutura de chave-valor. unordered_map é geralmente preferível por performance.

unordered_map<string, int> mapa;
mapa["id_01"] = 100;

auto busca = mapa.find("id_01");
if (busca != mapa.end()) {
    int valor = busca->second;
}

// Contagem de ocorrência de uma chave
if (mapa.count("id_01")) {
    // Chave existe
}

Manipulação de Strings

Strings em C++ são mutáveis e possuem diversos métodos utilitários.

string s = "Exemplo";
string sub = s.substr(0, 4); // "Exem"
s.insert(0, "Novo ");        // "Novo Exemplo"
s.erase(0, 5);               // Remove 5 caracteres do início

// Inversão
reverse(s.begin(), s.end());

// Conversões
int valor = stoi("42");
string texto = to_string(42.5);

// Leitura de linha com espaços
string linha;
getline(cin, linha);

Função Customizada para Split de String

vector<string> split(const string& texto, char delimitador) {
    vector<string> tokens;
    string temp = "";
    for (char c : texto) {
        if (c == delimitador) {
            if (!temp.empty()) {
                tokens.push_back(temp);
                temp = "";
            }
        } else {
            temp += c;
        }
    }
    if (!temp.empty()) tokens.push_back(temp);
    return tokens;
}

Limites Numéricos

Para evitar overflows, utilize as constantes definidas em <climits>.

int max_int = INT_MAX;
int min_int = INT_MIN;
long long max_ll = LLONG_MAX;

Operações de Bits e Utilitários

Operações rápidas e verificações de caracteres.

// Operadores bitwise
int dobrar = 5 << 1;  // Equivale a 5 * 2
int metade = 10 >> 1; // Equivale a 10 / 2

// Verificação e Conversão de Caracteres
char c = 'a';
bool eLetra = isalpha(c);
bool eDigito = isdigit(c);
char maiuscula = toupper(c);

// Formatação de saída (2 casas decimais)
cout << fixed << setprecision(2) << 3.14159 << endl;