🍕 Pizza Flow: Sistema Inteligente de Gestão e Logística

Este repositório documenta minha trajetória completa no curso de Algoritmos e Estrutura de Dados, culminando em um sistema de gestão de pizzaria que utiliza conceitos avançados de computação para otimizar processos de venda, logística e análise de dados.

📂 Organização do Repositório

📍 Unidade 01: Introdução e Fundamentos

Nesta fase inicial, foquei na base sólida da linguagem Java e manipulação de dados simples.

• Exercícios de Entrada/Saída: Manipulação de tipos primitivos e classes System.
• Lógica Matemática: Implementação de algoritmos de números primos e verificação de paridade.
• Estruturas de Controle: Loops (for/while) e condicionais aplicados.
• Manipulação de Coleções: CRUD básico de números usando ArrayList.
• Mini Projetos Internos:
  • 🎮 TicTacToe (Jogo da Velha): Lógica de matrizes, alternância de turnos e verificação de vitória.
  • 📦 Sistema de Estoque: Aplicação prática de POO com classes Stock, métodos de atualização e gerenciamento de listas.
  • 👥 Gerenciador de Pessoas: Cadastro e listagem utilizando classes personalizadas.

---

📍 Unidade 02: Estruturas Lineares e Algoritmos de Ordenação

Nesta etapa, o foco foi a implementação de estruturas clássicas e a manipulação eficiente de dados utilizando coleções avançadas do Java.

🛠️ Estruturas Implementadas

• Pilhas (Stack): * Algoritmo de Validação de Parênteses (Lógica de abertura e fechamento).
  • Inversão de listas utilizando o comportamento LIFO (Last-In, First-Out).
• Filas (Queue/ArrayDeque):
  • Simulação de Fila de Espera real com sistema de chamadas.
  • Gerenciamento de ordem de chegada (FIFO - First-In, First-Out).
• Tabelas Hash (HashMap):
  • Contagem de frequência de palavras em textos (Data Analysis).
  • Mesclagem de mapas (Merge Maps) com tratamento de chaves duplicadas.

⚡ Algoritmos de Ordenação e Manipulação

• Quick Sort: Implementação do algoritmo de ordenação mais eficiente da categoria "Dividir e Conquistar", utilizando pivô e particionamento.
• In-place Reverse: Algoritmo para inverter um ArrayList sem criar uma lista auxiliar, otimizando o uso de memória.
• Remoção de Duplicatas: Lógica de limpeza de arrays mantendo a integridade dos dados.

📊 Análise de Eficiência (Big O)

Algoritmo / Estrutura	Operação	Complexidade de Tempo
Quick Sort	Ordenação	$O(n \log n)$ (médio)
Binary Search	Busca	$O(\log n)$
HashMap	Inserção/Busca	$O(1)$
Stack/Queue	Push/Pop/Add	$O(1)$
ArrayList	Acesso por índice	$O(1)$

📂 Destaques de Código (Unidade 02)

Validação de Expressões com Stack

Um exemplo clássico de como pilhas são essenciais para compiladores e análise de sintaxe:

// Trecho simplificado do Ex4
for (Character character : expression.toCharArray()) {
    if (character == '(') stack.push(character);
    else if (character == ')') {
        if (stack.isEmpty()) return false;
        stack.pop();
    }
}

Ordenação Eficiente (Quick Sort)

Implementação de particionamento para garantir performance em grandes volumes de dados:

private static int partition(ArrayList<Integer> arr, int low, int high) {
    int pivot = arr.get(high);
    int i = low - 1;
    for (int j = low; j < high; j++) {
        if (arr.get(j) > pivot) { // Ordenação decrescente
            i++;
            swap(arr, i, j);
        }
    }
    swap(arr, i + 1, high);
    return i + 1;
}

---

📍 Unidade 03: Estruturas Não-Lineares e Algoritmos de Busca

Nesta etapa, o foco mudou para estruturas de dados hierárquicas e relacionais, explorando a eficiência da busca binária e a complexidade dos grafos.

🌳 Árvores Binárias (Binary Search Tree - BST)

Implementação de estruturas de dados hierárquicas para otimização de buscas e organização de dados.

• Percursos Recursivos: Implementação dos três tipos de travessia para manipulação de nós:
  • Pre-Order: Raiz → Esquerda → Direita.
  • In-Order: Esquerda → Raiz → Direita (Resulta em dados ordenados).
  • Post-Order: Esquerda → Direita → Raiz.
• Lógica de Verificação: Desenvolvimento de um algoritmo para validar se uma árvore binária atende aos requisitos de uma BST (propriedade de ordenação).
• Operações de Extremo: Implementação de busca recursiva para encontrar o valor mínimo (findMin) utilizando a lógica de que o menor valor sempre estará na extremidade esquerda.

🕸️ Teoria e Algoritmos de Grafos

Exploração de conexões entre vértices e busca de caminhos otimizados.

• Busca em Largura (BFS): Utilizada para encontrar o caminho mais curto em grafos não ponderados, explorando nível por nível com auxílio de uma Queue.
• Busca em Profundidade (DFS): Implementação recursiva para exploração completa de ramos, utilizando Set para controle de nós visitados.
• Algoritmo de Dijkstra: Implementação avançada para busca de caminho mínimo em grafos ponderados (com pesos), utilizando PriorityQueue para garantir a melhor performance.

🔍 Eficiência em Buscas

• Busca Linear vs. Busca Binária: Análise comparativa de performance. Enquanto a busca linear opera em $O(n)$, a busca binária reduz drasticamente o tempo para $O(\log n)$, dividindo o espaço de busca consecutivamente.

📂 Destaques de Código (Unidade 03)

Validação de Árvore Binária de Busca (BST)

Exemplo de uso de recursividade para garantir a integridade da estrutura, um dos pontos fortes destacados no meu feedback:

private boolean isBST(Node node, int min, int max) {
    if (node == null) return true;
    
    // O valor do nó deve estar estritamente dentro do intervalo permitido
    if (node.value <= min || node.value >= max) return false;
    
    // Verifica recursivamente as subárvores esquerda e direita atualizando os limites
    return isBST(node.left, min, node.value) && 
           isBST(node.right, node.value, max);
}

Implementação de Busca em Largura (BFS)

Lógica para encontrar o caminho entre dois nós, utilizando uma fila e um mapa de "parents" para reconstruir a rota:

while (!queue.isEmpty()) {
    int current = queue.poll();
    if (current == to) break;

    for (Integer neighbor : adj.get(current)) {
        if (!visited.contains(neighbor)) {
            visited.add(neighbor);
            parent.put(neighbor, current);
            queue.add(neighbor);
        }
    }
}

Localização do Menor Valor (Recursão)

Aplicação direta das propriedades da árvore para busca eficiente:

int findMin(Node node) {
    // Em uma BST, o menor valor está sempre no nó mais à esquerda
    return node.left == null ? node.value : findMin(node.left);
}

---

🚀 Insights do Feedback (Unidade 03)

A avaliação destacou minha segurança técnica e a capacidade de equilibrar a explicação de conceitos complexos com clareza didática.

• Destaque: Compreensão profunda do raciocínio por trás dos algoritmos, priorizando a lógica sobre a simples funcionalidade (especialmente no algoritmo de Dijkstra).
• Maturidade: Código limpo, bem indentado e com nomes de métodos coerentes, demonstrando cuidado no desenvolvimento.

---

📍 Unidade 04: Projeto Integrador - Pizza Flow (BI & Grafos)

O ápice da trajetória. Transformei um sistema de gestão de pedidos em uma ferramenta de Business Intelligence (BI), utilizando Grafos para mapear o comportamento de consumo e otimizar a logística.

1. 🧠 Business Intelligence com Grafos (Relatório de Vendas)

A grande joia do projeto. Em vez de um relatório simples, utilizei a Teoria dos Grafos para mapear o comportamento do consumidor.

• Conceito: Cada sabor de pizza é um Vértice. Quando um cliente pede dois ou mais sabores na mesma pizza, o sistema cria/incrementa uma Aresta (ligação) entre eles em uma Matriz de Adjacência.
• Valor: Isso permite que o dono da pizzaria saiba exatamente quais sabores "casam" melhor, facilitando a criação de promoções e combos inteligentes.

2. 🚛 Motor de Logística (Cálculo de Frete)

Implementação de um cálculo de frete dinâmico que considera duas variáveis críticas:

• Distância ($km$): Otimização baseada na zona de entrega.
• Peso/Volume: Taxa por quantidade de itens no pedido.
• Lógica: $Frete = (km \cdot taxaKm) + (qtdPizzas \cdot taxaVolume)$

3. 🛠️ Gestão Dinâmica de Pedidos (CRUD Avançado)

O método alterarPedido foi estruturado para ser robusto e flexível:

• Busca híbrida por ID ou Nome do Cliente.
• Manipulação de listas em tempo real para adição/remoção de sabores sem perder a integridade dos dados originais.

📂 Destaques de Código (Unidade 04)

O Coração do BI: Mapeamento de Afinidade

Este trecho demonstra como a lógica de grafos é aplicada para fortalecer as conexões entre sabores na matriz de adjacência:

// Dentro da geração do relatório de BI
for (int i = 0; i < saboresNoPedido.size(); i++) {
    for (int j = i + 1; j < saboresNoPedido.size(); j++) {
        int idx1 = buscarIndiceSabor(saboresNoPedido.get(i));
        int idx2 = buscarIndiceSabor(saboresNoPedido.get(j));
        
        // Incrementa o peso da ligação entre os dois sabores (Grafo Não-Direcionado)
        matrizAdjacencia[idx1][idx2]++;
        matrizAdjacencia[idx2][idx1]++;
    }
}

Motor de Cálculo de Frete

Uma regra de negócio clara e bem implementada:

public double calcularFrete(double km, int quantidadePizzas) {
    double taxaPorKm = 2.50;
    double taxaPorPizza = 1.00;
    return (km * taxaPorKm) + (quantidadePizzas * taxaPorPizza);
}

🚀 Insights do Feedback (Unidade 03)

O projeto final consolidou a percepção de maturidade técnica e visão de negócio.

• Destaque Principal: O uso de Grafos para ligar sabores foi citado como um grande diferencial, demonstrando que a tecnologia serve ao propósito do negócio.
• Habilidade de Apresentação: "Conseguiu equilibrar explicação técnica com clareza didática", provando domínio total sobre a arquitetura do software.
• Organização: Código modularizado e fácil de manter, seguindo boas práticas de POO.

---

📈 Evolução Técnica (Unidade a Unidade)

Unidade	Foco Principal	Estruturas Implementadas
01	Lógica e Ordenação	Arrays, Condicionais e Loops.
02	Estruturas Lineares	Stacks, Queues e o algoritmo QuickSort.
03	Estruturas Não-Lineares	BST (Árvore Binária de Busca) e percursos recursivos.
04	Projeto Integrador	Grafos, Mapas de Adjacência e Regras de Negócio.

---

⭐ Reconhecimento e Feedback

Durante as avaliações, o projeto recebeu feedbacks extremamente positivos, destacando:

"Vitor demonstrou domínio sólido... conseguiu equilibrar explicação técnica com clareza didática. O uso de Grafos para ligar sabores demonstra entendimento real da estrutura de dados e aplicação prática do conceito." 🚀

Pontos Fortes destacados:

• Maturidade Técnica: Código limpo, bem indentado e modularizado.
• Comunicação: Capacidade de explicar lógicas complexas (como o funcionamento dos grafos) de forma simples.
• Resiliência: Capacidade de evoluir algoritmos complexos e propor soluções eficientes.

---

🛠️ Tecnologias e Conceitos Aplicados

• Java 17+ (Collections API, Streams, Lambdas).
• Recursividade para manipulação de Árvores.
• Complexidade de Algoritmos (Big O Notation).
• Regex para tratamento de strings e dados.

---

🚀 Como Executar

1. Clone o