Você está na página 1de 61

Estruturas de Dados

Marcelo B. Tenorio

Estrutura de Dados - IED-001 1


Referências
PEREIRA, Silvio do Lago. Estruturas de Dados Fundamentais.
Conceitos e Aplicações. 11ª Edição. São Paulo: Érica, 2008.

CORMEN, Thomas H.; LEISERSON, Charles E.; RIVEST, Ronald


L.; STEIN, Clifford. Algoritmos: teoria e prática. Rio de Janeiro:
Elsevier, 2002.

ZIVIANI, Nivio. Projeto de algoritmos : com implementações em


Pascal e C. 2ª edição. São Paulo: Thomson Learning, 2007.

PREISS, Bruno R. Estrutura de dados e algoritmos: padrões de


projetos orientados a objeto com Java.

FORBELONE, André Luiz Villar. Lógica de Programação: a


construção de algoritmos e estruturas de dados. São Paulo:
Makron Books, 1993.

KOFFMAN, Elliot B. Objetos, Abstração, Estrutura de Dados e


Projeto Usando o C++. Rio de Janeiro: LTC, 2006.
Estrutura de Dados - IED-001 2
Conteúdo
 Revisão
 Programação Visual (Texto X Gráfico)
 Lista linear sequencial
 Recursividade
 Lista linear encadeada
 Lista não linear
 Espalhamento
 Ordenação, Busca, Grafos e Complexidade

Estrutura de Dados - IED-001 3


Revisão
Algoritmos e Lógica de Programação (1º)
Linguagem de Programação (2º)

 Tipos de Dados
 Variáveis e Constantes (homogêneas e não indexadas)
 Operadores e Expressões
 Entrada e Saída (I/O)
 Decisão e Repetição
 Variáveis Indexadas (homogêneas)
 Funções
 Registros (variáveis heterogêneas)

Estrutura de Dados - IED-001 4


Programação Visual
 IDE Visual Studio e Linguagem C#
 Aplicativo do Windows Forms (.Net Framework)
 Entrada e Saída
Label, TextBox, ListBox, ComboBox, Button, RadioButton,
CheckBox

 Vetor
int[] vet;
vet = new int[10];

 Função (parâmetro por valor e por referência)


void soma(int v1, int v2, ref int s) // Implementação
soma(v1, v2, ref s); // Chamada
Estrutura de Dados - IED-001 5
Introdução
 Estruturas de Dados

 Organizações dos dados utilizadas pelo


computador para controle de diversas atividades.

 Exemplos: Chamadas das funções,


Escalonamento de processos, Criptografia,
Localização dos dados, Fila de Impressão, etc.

Estrutura de Dados - IED-001 6


Lista linear sequencial

 Dados organizados de maneira sequencial

 Vetor

 Tipos
 Pilha

 Fila
Estrutura de Dados - IED-001 7
Pilha

 Tipo de lista linear em que todas as


operações de inserção e remoção são
realizadas numa mesma extremidade,
denominada topo.

 LIFO (Last-in / First-out)

 Ilustração

Estrutura de Dados - IED-001 8


Pilha
 Aplicações
 Análise de expressões e sintaxe
 Compiladores

 Calculadoras

 Chamada das funções

 Inversão de dados

Estrutura de Dados - IED-001 9


Pilha
 2 operações básicas
Insere: insere um elemento no topo
Remove: remove um elemento do topo

 3 operações essenciais
Inicializa: inicializa no estado vazia
EstaVazia: verifica se está vazia
EstaCheia: verifica se está cheia

Estrutura de Dados - IED-001 10


Implementação de Pilha
// Organização dos dados
const int MAX = 50;
struct tp_pilha // Verificando limites
{ bool EstaVazia(tp_pilha p)
public int topo; {
public int[] vetor; return (p.topo == -1);
} }
tp_pilha pilha;
bool EstaCheia(tp_pilha p)
// Inicialização {
void Inicializa(ref tp_pilha p) return (p.topo == MAX - 1);
{ }
p.topo = -1;
p.vetor = new int[MAX];
} Estrutura de Dados - IED-001 11
Implementação de Pilha
// Insere um elemento
void Insere(ref tp_pilha p, int valor)
{
p.vetor[++p.topo] = valor;
}

// Remove um elemento
int Remove(ref tp_pilha p)
{
return (p.vetor[p.topo--]);
}

Estrutura de Dados - IED-001 12


Fila
 Tipo de lista linear em que as inserções são
realizadas num extremo (fim), ficando as
remoções restritas ao outro extremo (início).

 FIFO (First-In / First-Out)

 Ilustração

Estrutura de Dados - IED-001 13


Fila
 2 operações básicas
Insere: insere um elemento no fim
Remove: remove um elemento do início

 Aplicações
 Escalonamento de processos do SO
 Controle de requisições SQL no BD
 Fila de impressão do SO

Estrutura de Dados - IED-001 14


Implementação de Fila
// Organização dos dados
const int MAX = 50;
struct tp_fila // Verificando limites
{ bool EstaVazia (tp_fila f)
public int inicio, fim; {
public int[] vetor; return (f.inicio == f.fim);
} }
tp_fila fila;
bool EstaCheia(tp_fila f)
// Inicialização {
void Inicializa(ref tp_fila f) return (f.fim == MAX - 1);
{ }
f.inicio = f.fim = -1;
f.vetor = new int[MAX];
} Estrutura de Dados - IED-001 15
Implementação de Fila
// Insere um elemento
void Insere(ref tp_fila f, int valor)
{
f.vetor[++f.fim] = valor;
}

// Remove um elemento
int Remove(ref tp_fila f)
{
return (f.vetor[++f.inicio]);
}

Estrutura de Dados - IED-001 16


Recursividade
 Dividir para conquistar

 A função chamar ela mesma

 Divide o problema em subproplemas


menores

Estrutura de Dados - IED-001 17


Recursividade
 Solução trivial: dada por definição; isto é,
não necessita da recursão para ser obtida.

 Solução geral: parte do problema que em


essência é igual ao problema original, sendo
porém menor.

Estrutura de Dados - IED-001 18


Recursividade
 Exemplo: Fatorial

// Dada por definição


Solução trivial: 0! = 1;

// Requer aplicação da função para (n-1)!


Solução geral: n! = n * (n-1)!

Estrutura de Dados - IED-001 19


Fatorial
 Solução iterativa

int fat(int n)
{  Solução recursiva
int f = 1; int fat(int n)
while (n > 0) {
{ if (n == 0) return 1;
f = f * n; else return n * fat(n-1);
n--; }
}
return f;
}
Estrutura de Dados - IED-001 20
Recursividade - Ilustração

n=0

return 1
n=1
n=1
return 1 *
return 1 * fat(0)
fat(0)
n=2 n=2
n=2
return 2 * return 2 *
return 2 * fat(1)
fat(1) fat(1)
n=3 n=3
n=3 n=3
return 3 * return 3 *
return 3 * fat(2) return 3 * fat(2)
fat(2) fat(2)
n=4 n=4
n=4 n=4 n=4
return 4 * return 4 *
return 4 * fat(3) return 4 * fat(3) return 4 * fat(3)
fat(3) fat(3)

Estrutura de Dados - IED-001 21


fat(4) fat(3) fat(2) fat(1) fat(0)
Alocação estática de memória

 Vetor: Aloca-se a quantidade máxima de memória em


tempo de programação. Esta alocação NÃO pode ser
alterada em tempo de execução do software.
 Aplica-se quando é conhecido, em tempo de
programação, a quantidade máxima de memória
necessária para solução do problema.

 Vantagem
 Agilidade no acesso aos valores. (índices)
 Desvantagem
 Desperdício de memória.

Estrutura de Dados - IED-001 22


Alocação dinâmica de memória

 Ponteiro: Aloca-se a quantidade de memória necessária,


conforme a execução do software. Esta alocação PODE
ser alterada em tempo de execução.
 Aplica-se quando NÃO é conhecido, em tempo de
programação, a quantidade máxima de memória
necessária para solução do problema.

 Vantagem
 Poupa memória.
 Desvantagens
 Não há acesso aos valores por índice.

Estrutura de Dados - IED-001 23


Ponteiros
void funcao()
{
char x = 'Z', y = 'K';
char *px, *py;
px = &x; py = &y;

exibe “Endereco de px:“ + &px;


exibe “Endereco de py:“ + &py;
exibe "Conteudo de px:“ + px;
exibe "Conteudo de py:“ + py;
exibe “Conteudo para onde px aponta:“ + *px;
exibe “Conteudo para onde py aponta:“ + *py;
}
Estrutura de Dados - IED-001 24
Ponteiros

Estrutura de Dados - IED-001 25


Lista linear encadeada

 Diferença entre sequencial e encadeado

 Ponteiro

 Ilustração

Estrutura de Dados - IED-001 26


Implementação de Lista

// Organização dos dados


class tp_no // Inicialização
{ void Inicializa(ref tp_no l)
public int valor; {
public tp_no prox; l = null;
} }
tp_no inicio;

Estrutura de Dados - IED-001 27


Implementação de Lista
// Insere um elemento
void Insere(ref tp_no l, tp_no no)
{
if (l != null) no.prox = l;
l = no;
}

// Clique do botão Insere


{
tp_no no = new tp_no();
no.valor = Convert.ToInt32(TextBox.Text);
no.prox = null;
Insere(ref inicio, no);
}
Estrutura de Dados - IED-001 28
Implementação de Lista

// Remove um elemento
tp_lista Remove(ref tp_no l)
// Clique do botão Remove
{
{
tp_no no = null;
tp_no no = Remove(ref inicio);
if (l != null)
if (no != null)
{
LB.Items.Add(no.valor);
no = l;
else
l = l.prox;
MessageBox.Show(“Vazia”);
no.prox = null;
}
}
return no;
}

Estrutura de Dados - IED-001 29


Memória (stack e heap)

Estrutura de Dados - IED-001 30


Lista não linear
(generalizada)
 Diferença entre lista linear e não linear
a

b c d

h i j
e f g

k l m
Estrutura de Dados - IED-001 31
Árvore
 Coleção finita de nós
 Características:
 Raiz a
c

 Subárvore
h
l m

 Grau: quantidade de subárvores


 O nó a tem grau 3.
 O nó d tem grau 2.
Estrutura de Dados - IED-001 32
Árvore
 Nó de grau 0 é uma folha.

 Nós pai e filhos.


 Filhos do nó b são: e, f e g
 O nó h é o pai de l e m

 Altura de uma árvore


 O máximo dos níveis de todos os seus nós.
 Altura desta árvore exemplo: 4

Estrutura de Dados - IED-001 33


Árvores
 Aplicações:
 Jogos (análise de possibilidades), Dicionário de
linguagem de programação, Geometria computacional,
Conjuntos, Banco de dados, Sistemas de arquivos, etc

 Tipos
 Binária: Cada nó com no máximo 2 filhos
 AVL: Binária balanceada (busca mais rápida)
 Rubro-Negra: Binária balanceada com alguns
diferencias
 B: Cada nó com mais de 2 filhos

Estrutura de Dados - IED-001 34


Árvore Binária
R

b f

a d g

Estrutura de Dados - IED-001 35


Árvore Binária
 Inserção: Valores menores para a esquerda e
valores maiores para a direita

 Remoção
 Nó sem filhos: Atribui nulo para o ponteiro do pai e
apaga-o.
 Nó com 1 filho: Liga com o ponteiro do pai.
 Nó com 2 filhos: Iniciando a busca pela esquerda,
substitua-o pelo nó de maior valor. Faça os ajustes
necessários com o nó de maior valor (só sem filhos
ou nó com 1 filho).
Estrutura de Dados - IED-001 36
Organização dos dados
class tp_no
{
public tp_no esq;
public int valor;
public tp_no dir;
};
tp_no raiz;
void Inicializa(tp_no T)
{
T = null;
} Estrutura de Dados - IED-001 37
Inserir
void Insere(ref tp_no T, int X)
{
if (T == null)
{
T = new tp_no();
T.valor = X;
T.esq = T.dir = null;
}
else if (X < T.valor)
Insere(ref T.esq, X);
else
Insere(ref T.dir, X);
}
Estrutura de Dados - IED-001 38
Procurar
tp_no Busca(tp_no T, int X)
{
if (T == null)
return null;
else if (X == T.valor)
return T;
else if (X < T.valor)
return Busca(T.esq, X);
else
return Busca(T.dir, X);
} Estrutura de Dados - IED-001 39
Retornar o maior
tp_no RetornaMaior(ref tp_no T)
{
if (T.dir == null)
{
tp_no P = T;
T = T.esq;
return P;
}
else
return RetornaMaior(ref T.dir);
}
Estrutura de Dados - IED-001 40
tp_no Remove(ref tp_no T, int X)
{
if (T == null) // elemento nao encontrado
Remover
return null;
else if (X == T.valor) // elemento encontrado
{
tp_no P = T;
if (T.esq == null) // nao tem filho esquerdo
T = T.dir;
else if (T.dir == null) // nao tem filho direito
T = T.esq;
else
{ // tem ambos os filhos
P = RetornaMaior(ref T.esq);
T.valor = P.valor;
}
return P;
}
else if (X < T.valor)
return Remove(ref T.esq, X); // procura na subarvore esquerda
else
return Remove(ref T.dir, X); // procura na subarvore direta
Estrutura de Dados - IED-001 41
}
Exibir em Ordem
void EmOrdem(tp_no T)
{
if (T != null)
{
EmOrdem(T.esq);
ListBox.Items.Add(T.valor);
EmOrdem(T.dir);
}
}

Estrutura de Dados - IED-001 42


Exibir em Pré Ordem
void PreOrdem(tp_no T)
{
if (T != null)
{
ListBox.Items.Add(T.valor);
PreOrdem(T.esq);
PreOrdem(T.dir);
}
}

Estrutura de Dados - IED-001 43


Exibir em Pós Ordem
void PosOrdem(tp_no T)
{
if (T != null)
{
PosOrdem(T.esq);
PosOrdem(T.dir);
ListBox.Items.Add(T.valor);
}
}

Estrutura de Dados - IED-001 44


Espalhamento
(dispersão ou hashing)
 Principal característica:
 Maior agilidade na recuperação do dado.

 Há uma função que mapeia o valor a ser


armazenado e a posição de armazenamento.
 Função hashing

Estrutura de Dados - IED-001 45


Espalhamento – Redução do espaço de busca
Beatriz
Denis José
Sandra
k = ‘Maria’
Ana
Euardo Maria
Paula

Beatriz
Denis José
Sandra

k = ‘Maria’ Ana
f(k) = 2 Euardo Maria

Paula
Estrutura de Dados - IED-001 46
Tabela de espalhamento
(ou tabela de dispersão ou tabela hashing)

 Funções de espalhamento
 Resto da divisão inteira (ilustração)
 Meio do Quadrado
 Método da Dobra
 Método da Multiplicação
 Hashing Universal

Estrutura de Dados - IED-001 47


Implementação de Espalhamento
// Organização dos dados
const int N = 5;
int[] vetor; void Insere(ref int[] vet, int ch)
{
void Inicializa(ref int[] vet) int pos = Hash(ch);
{ vet[pos] = ch;
vet = new int[N]; }
for (int i = 0; i < N; i++)
vet[i] = 0; int Busca(int chave)
} {
int pos = Hash(chave);
int Hash(int chave) return pos;
{ }
return (chave % N);
} Estrutura de Dados - IED-001 48
Colisão
(espalhamento)

 A colisão ocorre quando um valor deve ser


armazenado numa posição já ocupada.

 Métodos para tratamento


 Endereçamento Aberto
 Tratamento linear

 Endereçamento Fechado
 Lista encadeada
Estrutura de Dados - IED-001 49
Implementação de Espalhamento

void InsereLinear(ref int[] vet, int chave)


{
int pos = Hash(chave);
while (vet[pos] != 0)
{
pos++;
pos = pos % N;
}
vet[pos] = chave;
}

Estrutura de Dados - IED-001 50


Implementação de Espalhamento
void InicializaEnc(ref tp_no[] vet)
{
vet = new tp_no[N];
for (int i = 0; i < N; i++)
vet[i] = null;
class tp_no }
{
public int valor; void InsereEnc(ref tp_no[] vet, tp_no no)
public tp_no prox; {
} int pos = Hash(no.valor);
if (vet[pos] != null)
no.prox = vet[pos];
vet[pos] = no;
}
Estrutura de Dados - IED-001 51
Ordenação
 Existem vários algoritmos de ordenação
 O mais rápido é o Quicksort

 A ordenação dos dados é essencial quando


algo é procurado (busca)

 Em bancos de dados, por exemplo, utiliza-se


algoritmo de ordenação

Estrutura de Dados - IED-001 52


Ordenação - Algoritmo Quicksort
void quick_sort(ref int a, int left, int right) {
int i, j, x, y;
i = left;
j = right;
x = a[(left + right) / 2];
while(i <= j) {
while(a[i] < x && i < right) i++;
while(a[j] > x && j > left) j--;
if(i <= j) {
y = a[i];
a[i] = a[j];
a[j] = y;
i++;
j--;
}
}
if(j > left) quick_sort(ref a, left, j);
if(i < right) quick_sort(ref a, i, right);
Estrutura de Dados - IED-001 53
}
Algoritmo Quicksort - Ilustração

Estrutura de Dados - IED-001 54


Busca
 Existem dois tipos

 Busca Linear (sequencial / exaustiva)


 Os dados podem estar desordenados
 Lenta

 Busca Binária
 Os dados precisam estar ordenados
 Rápida

Estrutura de Dados - IED-001 55


Busca Linear - Algoritmo

// A variável qtd significa a quantidade de valores no vetor


// A variável chave é o valor procurado

int i = 0;
while (i < qtd && chave != vetor[i])
i++;

if (i < qtd)
exibe “Encontrou na posição: “ + i;
else
exibe “Não encontrou”;

Estrutura de Dados - IED-001 56


Busca Binária - Algoritmo
int BuscaBinaria(int[] vetor, int chave)
{
int meio, Min = 0, Max = vetor.Length - 1;
do
{
meio = (int)(Min + Max) / 2;
if (vetor[meio] == chave)
return meio; // Retorna a posição que encontrou
else if (chave > vetor[meio])
Min = meio + 1;
else
Max = meio - 1;
}
while (Min <= Max);
return -1; // Retorno -1 significa que não encontrou
}
Estrutura de Dados - IED-001 57
Grafos
 Conjunto de elementos interligados (não
linear)

 Os algoritmos de grafos são utilizados


quando o problema envolve caminhos
Estrutura de Dados - IED-001 58
Grafos
 Aplicações
 Comunicação, Circuitos, Hidráulica, Transporte,
Computacionais (módulos do software, links da
internet, movimentos de jogos digitais)

 Algoritmos conhecidos:
 Dijkstra
 Kruskal

Estrutura de Dados - IED-001 59


Complexidade de Algoritmo
 Utilizada para analisar a eficiência do
algoritmo

 Observa-se a quantidade de operações


relevantes, por exemplo, comandos de
decisão (if) e repetição (for ou while)

 Geralmente, analisa-se o pior caso

 Notação O
Estrutura de Dados - IED-001 60
Notação O Grande

Notação Nome Exemplo

O (1) Constante Determinar se um número é par ou impar

O (log n) Logarítmico Encontrar um item numa matriz ordenada

O (n) Linear Encontrar um item numa lista desordenada

O (n2) Quadrático Quicksort

O (2n) Exponencial Caixeiro viajante (programação dinâmica)

O (n!) Fatorial Caixeiro viajante (força bruta)

Estrutura de Dados - IED-001 61

Você também pode gostar