Visualizador Interativo de Estruturas de Dados — TCC IFG 2026

Array Estático

Estrutura de tamanho fixo com acesso direto por índice. Leitura e escrita em O(1); inserção/remoção requerem deslocamento O(n).

Leitura O(1) Escrita O(1) Inserção O(n) Remoção O(n)

memoria[0..n-1]

Vel:

int[] arr = new int[8];

// Leitura O(1) — acesso direto por índice

int val = arr[i];

// Inserção O(n) — desloca todos os elementos à direita

for (int k = arr.Length - 1; k > pos; k--)

  arr[k] = arr[k - 1];

arr[pos] = newVal;

Matriz Estática (int[4,5])

Array bidimensional de tamanho fixo com acesso direto por [linha][coluna] em O(1). Leitura por linhas (row-major) é eficiente em cache; leitura por colunas causa cache misses.

Read[r][c] O(1) Write O(1) ReadSeq O(n²) Col-Major cache miss

int[4,5] — row-major em memória

Vel:

int[,] m = new int[4, 5];

// Acesso direto O(1)

int v = m[r, c];

m[r, c] = newVal;

// Row-major O(n²) — cache friendly ✓

for (int r = 0; r < 4; r++)

  for (int c = 0; c < 5; c++) _ = m[r, c];

// Col-major O(n²) — cache miss ✗ (pula linhas)

for (int c = 0; c < 5; c++)

  for (int r = 0; r < 4; r++) _ = m[r, c];

Lista Dinâmica (ArrayList)

Array redimensionável que dobra a capacidade quando cheio. Add(end) é O(1) amortizado; RemoveAt(0) exige deslocar todos os elementos O(n).

Add O(1)* RemoveAt(0) O(n) Leitura O(1)

ArrayList<int>

Vel:

List<int> list = new List<int>();

// Add O(1) amortizado — resize 2× se cheio

list.Add(val);

// RemoveAt(0) O(n) — desloca todos

list.RemoveAt(0);

// Acesso O(1)

int v = list[i];

Pilha Dinâmica (Stack)

Estrutura LIFO — último a entrar, primeiro a sair. Push, Pop e Peek operam no topo em O(1). Usada em chamadas de função e backtracking.

Push O(1) Pop O(1) Peek O(1)

Stack<int> — LIFO

▲ BASE

Vel:

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

// Push O(1) — adiciona no topo

stack.Push(val);

// Pop O(1) — remove do topo

int top = stack.Pop();

// Peek O(1) — consulta sem remover

int peek = stack.Peek();

Fila Dinâmica (Queue)

Estrutura FIFO — primeiro a entrar, primeiro a sair. Enqueue adiciona no BACK; Dequeue remove do FRONT — ambos O(1) com lista ligada.

Enqueue O(1) Dequeue O(1) ReadSeq O(n)

Queue<int> — FIFO

FRONT →

→ BACK

Vel:

Queue<int> queue = new Queue<int>();

// Enqueue O(1) — adiciona no BACK

queue.Enqueue(val);

// Dequeue O(1) — remove do FRONT

int front = queue.Dequeue();

// Leitura sequencial O(n)

foreach (int item in queue) { /* ... */ }

Árvore Rubro-Negra

BST auto-balanceada com regras de coloração para garantir altura O(log n). Visualização simplificada baseada na implementação do TCC.

Busca O(log n) Inserção O(log n) Delete O(log n) Travessia O(n)

RedBlackTree<int>

Vel:

RedBlackTree<int> rbt = new();

// Inserção O(log n) — mantém balanceamento por cor

rbt.Insert(val); // rotações + recoloração automática

// Busca O(log n) — caminho raiz → folha

bool found = rbt.Contains(val);

// Travessia In-Order O(n) — produz saída ordenada

rbt.InOrder(node => Console.Write(node.Value + " "));

// Delete O(log n) — busca + remoção + rebalanceamento

rbt.Delete(val); // successor swap + recoloração

Algoritmos de Ordenação

Visualização passo a passo. Ciano = comparando · Âmbar = trocando · Verde = ordenado · Violeta = pivô

QuickSort O(n log n)* MergeSort O(n log n) HeapSort O(n log n)

0 Comparações

0 Trocas

0 Passos

0% Progresso

QuickSort

Vel:

// QuickSort — pivô no último elemento

void QuickSort(int[] arr, int lo, int hi) {

  if (lo >= hi) return;

  int p = Partition(arr, lo, hi);

  QuickSort(arr, lo, p - 1);

  QuickSort(arr, p + 1, hi);

}

// MergeSort — divide e conquista estável

void MergeSort(int[] arr, int lo, int hi) { /* ... */ }