Estruturas de Dados

Revisão

Gabriel Novy

PILHA

Último a entrar é o primeiro a sair

PILHA class Pilha

{

private class Celula

{

public int valor;

public Celula proxima;

}

private Celula inicio;

public Pilha()

{

inicio = new Celula();

}

PILHA

public void inserir(int num)

{

Celula nova = new Celula();

nova.valor = num;

nova.proxima = inicio.proxima;

inicio.proxima = nova;

}

PILHA

public void mostrar()

{

Celula aux = inicio.proxima;

while (aux != null)

{

Console.Write(aux.valor + " ");

aux = aux.proxima;

}

}

PILHA

public int excluir()

{

int aux = -1;

if (inicio.proxima != null)

{

aux = inicio.proxima.valor;

inicio.proxima = inicio.proxima.proxima;

}

return aux;

}

}

FILA

Primeiro a entrar é o primeiro a sair

FILA class Fila

{

private class Celula

{

public int valor;

public Celula proxima;

}

private Celula inicio;

public Fila()

{

inicio = new Celula();

}

FILA

public void inserir(int num)

{

Celula nova;

Celula aux = inicio;

while (aux.proxima != null)

aux = aux.proxima;

nova = new Celula();

nova.valor = num;

aux.proxima = nova;

}

FILA

public int excluir()

{

int aux = -1;

if (inicio.proxima != null)

{

aux = inicio.proxima.valor;

inicio.proxima = inicio.proxima.proxima;

}

return aux;

}

}

LISTA

Inserem em qualquer posição e retira de qualquer

posição

LISTA

class Lista

{

private class Celula

{

public int valor;

public Celula proxima;

}

private Celula inicio;

public Lista()

{

inicio = new Celula();

}

LISTA

public void inserir(int num, int pos) {

Celula nova;

Celula aux = inicio;

int i = 0;

while (aux.proxima != null && i < pos){

aux = aux.proxima;

i++;

}

nova = new Celula();

nova.valor = num;

nova.proxima = aux.proxima;

aux.proxima = nova;

}

LISTA

public int pesquisarPosicao(int num){

Celula aux = inicio.proxima;

int pos = 0;

while (aux != null && aux.valor != num){

aux = aux.proxima;

pos++;

}

if (aux != null)

return pos;

else

return -1;

}

LISTA

public void excluir(int pos)

{

Celula aux = inicio;

int i = 0;

while (aux != null && i < pos){

aux = aux.proxima;

i++;

}

if (aux != null && aux.proxima != null)

aux.proxima = aux.proxima.proxima;

}

}

RECURSIVIDADE

Uma função recursiva chama ela mesma

O difícil é definir o ponto de parada

RECURSIVIDADE // função recursiva para calcular o fatorial de n

public static int fatorial(int n)

{

if (n == 0)

return 1;

else

return n * fatorial(n - 1);

}

RECURSIVIDADE // A função buscaBinaria2 recebe um número x e um vetor

// crescente v[0..n-1]. Ela devolve um índice m

// em 0..n-1 tal que v[m] == x. Se tal m não existe,

// devolve -1.

// A função buscaBinaria1 recebe um número x e um vetor

// crescente v[e..d]. Ela devolve um índice m

// em e..d tal que v[m] == x. Se tal m não

// existe, devolve -1.

public static int buscaBinaria2( int num, int []v) {

return buscaBinaria1( num, 0, v.Length-1, v);

}

RECURSIVIDADE public static int buscaBinaria1( int num, int inicio, int fim,

int []v) {

if (inicio > fim) return -1;

else {

int meio = (inicio + fim)/2;

if (v[meio] == num)

return meio;

if (v[meio] < num)

return buscaBinaria1( num, meio+1, fim, v);

else

return buscaBinaria1( num, inicio, meio-1, v);

}

}

ORDENAÇÃO

INSERÇÃO

Seleciona um elemento e o insere na posição

correta da parte ordenada à esquerda

INSERÇÃO

static int[] insertionSort(int[] A) {

int i, j, eleito;

for (i = 1; i < A.Length; i++) {

eleito = A[i];

j = i;

while ((j > 0) && (A[j -1] > eleito)) {

A[j] = A[j -1];

j = j - 1;

}

A[j] = eleito;

}

return A;

}

INSERÇÃO

Melhor caso: 1, 2, 3, 4, ..., n

Comparação: O(n)

Troca: O(n)

Pior caso: n, n-1, n-2, ..., 1

Comparação: O(n2)

Trocas: O(n)

SELEÇÃO

Seleciona o menor elemento e o insere no início do

vetor

SELEÇÃO public void SelectionSort(int[] vetor) {

int min, aux;

for (int i = 0; i < vetor.Length - 1; i++) {

min = i;

for (int j = i + 1; j < vetor.Length; j++)

if (vetor[j] < vetor[min])

min = j;

if (min != i) {

aux = vetor[min];

vetor[min] = vetor[i];

vetor[i] = aux;

}

}

}

SELEÇÃO

Comparação

Melhor e pior caso compara sempre (O(n2))

Troca

Melhor caso: 1, 2, 3, ..., n -> O(1) pois nenhuma troca é

realizada

Pior caso: n, n-1, n-2, ..., 1 -> O(n2) pois realiza todas as

trocas

BOLHA

“Empurra” o maior elemento para o final, sempre

trocando-o se o vizinho é maior que ele

BOLHA

public void BubbleSort(int[] intArray) { for (int i = intArray.Length - 1; i > 0; i--){ bool troca = false; for (int j = 0; j <= i - 1; j++){ if (intArray[j] > intArray[j + 1]){ int highValue = intArray[j]; intArray[j] = intArray[j + 1]; intArray[j + 1] = highValue; troca = true; } } if(troca == false) i = 0; }

}

BOLHA

Comparação

Melhor caso em uma passada verifica vetor ordenado

(O(n))

Pior caso compara sempre (O(n2))

Troca

Melhor caso: 1, 2, 3, ..., n -> O(1) pois nenhuma troca é

realizada

Pior caso: n, n-1, n-2, ..., 1 -> O(n2) pois realiza todas as

trocas

SHELL SORT

Similar ao Inserção, mas compara elementos a uma

distância H. Reduz a distância H até 1, quando se

torna o método de Inserção.

SHELL SORT void shellSort(int[] nums) {

int h = 1;

int n = nums.length;

while(h < n)

h = h * 3 + 1;

int c, j;

while (h > 0) {

h = h / 3;

for (int i = h; i < n; i++) {

c = nums[i];

j = i;

while (j >= h && nums[j - h] > c) {

nums[j] = nums[j - h];

j = j – h; }

nums[j] = c; }

}

}

MERGE SORT

Considera dois conjuntos ordenados e cria um

terceiro conjunto ordenado que é a união dos dois

primeiros.

MERGE SORT void MergeSort(int [] numbers)

{

MergeSort_Recursive(numbers, 0, numbers.Length - 1);

}

void MergeSort_Recursive(int [] numbers, int left, int right)

{

int mid;

if (right > left)

{

mid = (right + left) / 2;

MergeSort_Recursive(numbers, left, mid);

MergeSort_Recursive(numbers, (mid + 1), right);

DoMerge(numbers, left, (mid+1), right);

}

}

MERGE SORT void DoMerge(int[] numbers, int left, int mid, int right) { int[] temp = new int[rigth-left+1]; int i, left_end, num_elements, tmp_pos; tmp_pos = 0; left_end = (mid - 1); num_elements = (right - left + 1); while ((left <= left_end) && (mid <= right)) { if (numbers[left] <= numbers[mid]) temp[tmp_pos++] = numbers[left++]; else temp[tmp_pos++] = numbers[mid++]; } while (left <= left_end) temp[tmp_pos++] = numbers[left++]; while (mid <= right) temp[tmp_pos++] = numbers[mid++]; for (i = num_elements - 1; i >= 0; i--) { numbers[right] = temp[i]; right--; } }

HEAP SORT

Organiza os elementos do vetor em uma estrutura

em árvore, de forma que o pai seja sempre maior

que os filhos. Retira o maior elemento (raiz) e refaz

a operação para o conjunto restante.

HEAP SORT

public void heapSort(int[] v) {

buildMaxHeap(v);

int n = v.Length;

for (int i = v.Length - 1; i > 0; i--) {

swap(v, i, 0); //apenas troca os elementos

maxHeapify(v, 0, --n);

}

}

private static void buildMaxHeap(int[] v) {

for (int i = v.Length / 2 - 1; i >= 0; i--)

maxHeapify(v, i, v.Length);

}

HEAP SORT

private static void maxHeapify(int[] v, int pos, int n) {

int max = 2 * pos + 1, right = max + 1;

if (max < n) {

if (right < n && v[max] < v[right])

max = right;

if (v[max] > v[pos]) {

swap(v, max, pos); //apenas troca os elementos

maxHeapify(v, max, n);

}

}

}

QUICK SORT

Seleciona um pivô (primeiro ou último número)

Coloca todos os menores à esquerda e todos os

maiores à direita

Realiza o mesmo processo para cada metade

QUICK SORT

void Ordenar(int[] vetor, int inicio, int fim) {

if (inicio < fim) {

int posicaoPivo = Separar(vetor, inicio, fim);

Ordenar(vetor, inicio, posicaoPivo - 1);

Ordenar(vetor, posicaoPivo + 1, fim);

}

}

QUICK SORT int Separar(int[] vetor, int inicio, int fim) {

int pivo = vetor[inicio], i = inicio + 1, f = fim;

while (i <= f) {

if (vetor[i] <= pivo)

i++;

else if (pivo < vetor[f])

f--;

else {

swap(v, i, f);

i++;

f--;

}

}

vetor[inicio] = vetor[f];

vetor[f] = pivo;

return f;

}