O QUE SÃO ARRAYS?
Arrays são estruturas de dados que armazenam elementos do mesmo tipo
em posições contíguas de memória. Cada elemento é acessado através de
um índice numérico, permitindo acesso direto O(1) a qualquer posição.
São a base para muitas outras estruturas de dados e fundamentais na
programação.
Características
- Tamanho fixo definido em tempo de compilação
- Elementos armazenados sequencialmente na memória
- Não há verificação de bounds automática
- Nome do array é um ponteiro para o primeiro elemento
- Acesso via aritmética de ponteiros
- Passados por referência para funções
Operações Principais
- Acesso: array[index] ou *(array + index)
- Inicialização: int arr[5] = {1,2,3,4,5}
- Cópia: usar memcpy() ou loop manual
- Busca: implementação manual O(n)
- Tamanho: sizeof(array)/sizeof(array[0])
int arr[5] = {1, 2, 3, 4, 5};
printf("%d", arr[0]); // 1
printf("%d", *(arr + 2)); // 3
int size = sizeof(arr)/sizeof(int);
Acesso
O(1)
Direto via índice
Inserção
N/A
Tamanho fixo
Características
- Arrays são objetos com atributo .length
-
Verificação automática de bounds
(ArrayIndexOutOfBoundsException)
- Inicializados com valores padrão (0, null, false)
- Suporte a arrays multidimensionais
- Tipos primitivos e objetos suportados
- Gerenciamento automático de memória (GC)
Operações Principais
- Acesso: array[index] com verificação de bounds
- Clonagem: array.clone() ou Arrays.copyOf()
- Busca: Arrays.binarySearch() para arrays ordenados
- Ordenação: Arrays.sort() O(n log n)
- Comparação: Arrays.equals() e Arrays.deepEquals()
int[] arr = new int[5];
int[] arr2 = {1, 2, 3, 4, 5};
System.out.println(arr.length); // 5
Arrays.sort(arr2);
int index = Arrays.binarySearch(arr2, 3);
Acesso
O(1)
Com bounds check
Busca Binária
O(log n)
Arrays.binarySearch()
Características
- Arrays são objetos com propriedade .length
- Tamanho dinâmico (cresce/diminui automaticamente)
- Pode conter elementos de tipos diferentes
- Índices podem ter "buracos" (sparse arrays)
- Suporte a métodos funcionais nativos
- Acesso a índices inexistentes retorna undefined
Operações Principais
- Adicionar: push() O(1), unshift() O(n)
- Remover: pop() O(1), shift() O(n), splice() O(n)
- Busca: indexOf() O(n), find() O(n)
- Transformação: map(), filter(), reduce()
- Iteração: forEach(), for...of, for...in
const arr = [1, 2, 3, 4, 5];
arr.push(6); // [1,2,3,4,5,6]
const doubled = arr.map(x => x * 2);
const evens = arr.filter(x => x % 2 === 0);
const sum = arr.reduce((a, b) => a + b, 0);
Push/Pop
O(1)
Final do array
Splice
O(n)
Meio do array
Características
- Lists são arrays dinâmicos mutáveis
- Suporte a slicing avançado [start:end:step]
- Podem conter qualquer tipo de objeto
- List comprehensions para criação concisa
- Suporte a operadores + e * para concatenação
- Índices negativos para acesso reverso
Operações Principais
- Adicionar: append() O(1), insert() O(n)
- Remover: pop() O(1), remove() O(n)
- Busca: index() O(n), count() O(n)
- Ordenação: sort() O(n log n), reverse() O(n)
- Slicing: list[start:end:step] O(k)
arr = [1, 2, 3, 4, 5]
arr.append(6) # [1,2,3,4,5,6]
print(arr[-1]) # 6 (último elemento)
squared = [x**2 for x in arr]
print(arr[1:4:2]) # [2, 4]
Slicing
O(k)
k = tamanho slice
Características
- Arrays são tipos de referência imutáveis em tamanho
- Verificação de bounds automática
- Suporte a arrays multidimensionais e jagged
- List<T> para arrays dinâmicos tipados
- LINQ para consultas funcionais
- Integração com .NET Collections
Operações Principais
- Array: Acesso direto O(1), tamanho fixo
- List<T>: Add() O(1), Insert() O(n)
- Busca: Array.IndexOf() O(n), BinarySearch() O(log n)
- LINQ: Where(), Select(), OrderBy()
- Conversão: ToArray(), ToList()
int[] arr = {1, 2, 3, 4, 5};
List<int> list = new List<int>(arr);
list.Add(6);
var evens = arr.Where(x => x % 2 == 0);
var sorted = arr.OrderBy(x => x).ToArray();
Array Access
O(1)
Bounds checked
List<T> Add
O(1)
Amortizado