estrutura de dados -...

Estrutura de DadosEstrutura de DadosEstrutura de DadosEstrutura de DadosCarlos Eduardo Batista

Centro de Informática - [email protected]

� Métodos de pesquisa e classificação de dados (continuação)

Estruturas de DadosEstruturas de Dados2

� Algoritmo de busca◦ Recebe como argumento o índice para a busca e o

conjunto no qual a busca será realizada

� Conjunto de dados◦ Um vetor de registros◦ Uma lista encadeada◦ Uma árvore

� Busca

Pesquisa e classificação de dadosPesquisa e classificação de dados

◦ Sequencial◦ Binária◦ Busca por interpolação, em árvores e hashing

� Busca deve ser realizada com menor custo◦ Utilizar menor quantidade de recursos possíveis

3

� Busca sequencial◦ Forma mais simples

◦ Aplica-se a vetores, listas encadeadas e estruturas que possuem sequência de ordenação

◦ São consultados todos os registros até que se encontre o que se busca

Pesquisa e classificação de dadosPesquisa e classificação de dados4

234 567 353 276 958 598 988 544

Encontrar 988 em um vetor com 8 elementos inteiros

Iteração 1... 7ª. Iteração!

int A[] = { 234, 567, 353, 276, 958, 598, 988, 544 } ;int x = 988;for (i=0; i<8; i++) {

if (A[i] == x)return(i); /*chave encontrada*/

}return(-1); /* chave não encontrada */

int A[] = { 234, 567, 353, 276, 958, 598, 988, 544 };

A


int A[] = { 234, 567, 353, 276, 958, 598, 988, 544 };int x = 988;int i;int n = 8;A[n] = 988;for (i=0; x!=A[i]; i++)

if (i < n) return(i); /*chave encontrada*/else return(-1); /*chave não encontrada*/

B

� Busca sequencial◦ Tamanho fixo do vetor � Desperdício de memória pode ocorrer

◦ Alternativa: usar lista encadeada

� Complexidade◦ Pesquisa com sucesso � melhor caso: O(1)� pior caso: O(n)


� pior caso: O(n) � caso médio: O((n+1) / 2)

◦ Pesquisa sem sucesso � O(n)

6

� Busca sequencial◦ Em estrutura ordenada (pelos valores das chaves a serem buscadas)

◦ Melhor eficiência� Pior caso (não encontrada a chave): O(n)

� Caso médio: O(n/2)

◦ Tabela de índices


234

697

987

1000

100

110

234

345

697

987

Chave Registro


1000 987

999

1000

� Busca binária◦ Se os dados estiverem ordenados em um arranjo...

◦ Arr[i] <= Arr[i+1] (ordem crescente)

◦ Arr[i] >= Arr[i+1] (ordem decrescente)

◦ Parte-se do elemento ‘do meio’ do arranjo para realizar a busca


� Se igual, busca bem sucedida

� Se maior ou menor, realizar busca na metade correspondente (dependendo se ordenado crescente ou decrescentemente)

9

123 133 222 245 321 334 411 544

133 < 245

Buscando 133...


123 133 222 245 321 334 411 544

133 = 133Elemento encontrado!

� Busca binária◦ Complexidade

� O(log n) – cada comparação reduz o número de possíveis candidatos por um fator de 2

◦ Eficiente e simples

◦ Porém...� Nem todo arranjo está ordenado

� Faz uso do fato que os índices são inteiros consecutivos


� Faz uso do fato que os índices são inteiros consecutivos ◦ Não se aplica a todos os tipos de estruturas

� Pode-se combinar com busca sequencial (organização da tabela secundária)

11

struct registry { int id; /* chave do registro */ ... /* outros campos do registro */

}


typedef struct registry Registry;

/* tamanho do vetor = n *//* função retorna posição do registro no vetor v,

ou -1 se não encontrou */int binsearch(Registry *v, int id) {

if (n <= 0)return -1;

int esq = 0;int dir = n - 1;int i;do {

i = (esq + dir) / 2;if (id > v[i].id)


if (id > v[i].id)esq = i + 1;

elsedir = i - 1;

} while ((id != v[i].id) && (esq <= dir));if (id == v[i].id)

return i;return -1;

}

� Ordenação (Classificação)◦ Rearranjar um conjunto de objetos

� Ordem ascendente ou descendente

◦ Ordenação interna� Tudo na memória principal� Seleção� Inserção� QuickSort� MergeSort


� MergeSort

◦ Ordenação externa� QuickSort externo� Intercalação balanceada

14

� Ordenação◦ Facilitar a recuperação de itens do conjunto ordenado

◦ Registros e chaves� Regra de ordenação

� Comparação de chaves

◦ Ordenação por distribuição


� Ordenação interna� Complexidade

◦ Número de comparação entre chaves◦ Número de movimentações entre itens

� Usar memória com parcimônia sempre� Métodos simples

◦ Pequeno volume de informações◦ O(n2)


◦ O(n )

� Métodos eficientes◦ Menos comparações◦ O(n log n)

16

� Ordenação por seleção◦ Algoritmo simples

� Seleciona-se o menor item do vetor

� Troca-se com o item da primeira posição do vetor

� Repetir com n-1 restantes, depois n-2...◦ Até que reste apenas um elemento


◦ Até que reste apenas um elemento

� (n2/2) – (n/2) comparações

� 3(n-1) movimentações de registro

17

Ordenação por seleção


typedef int Indice;typedef Item Vetor[MaxTam + 1];Vetor A;

void selecao(Item *A, Indice *n) {Indice i, j, Min;Item x;for (i = 1; i <= *n - 1; i++) {

Min = i;for (j = i + 1; j <= *n; j++)


if (A[j].Chave < A[Min].Chave)Min = j;

x = A[Min];A[Min] = A[i];A[i] = x;

}}

� Ordenação por seleção◦ Utilizado para ordenar conjuntos com registro grandes ou poucos registros

◦ Ordenação prévia (ou semi-ordenação) não ajuda em nada

◦ Algoritmo não é estável


� Ordenação por inserção

� Em cada passo a partir do 2º (i=2), faça◦ Selecione o i-ésimo item da sequência fonte

◦ Coloque-o no lugar correto (de acordo com o critério de ordenação) na sequência destino

� O processo de ordenação termina quando◦ Um item com chave menor que o item em

consideração é encontrado


consideração é encontrado

◦ O final da sequência destino é atingido ‘a esquerda

� Usa-se um sentinela na posição 0 do vetor

21

void insercao(Item *A, Indice *n) {Indice i, j;Item x;for (i = 2; i <= *n; i++) {

x = A[i];j = i - 1;A[0] = x; /* sentinela */while (x.Chave < A[j].Chave) {

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

23

j -- ;}A[j + 1] = x;

}}

� Ordenação por inserção◦ O número mínimo de comparações ocorre quando os registros já estão ordenados

◦ O número máximo de comparações ocorre quando os registros estão na ordem reversa

◦ Método a ser utilizado quando o conjunto está “quase” ordenado

Algoritmo estável


� Algoritmo estável

24

� Quicksort

� Mais rápido para um grande leque de possibilidades

� Dividir para conquistar◦ Problemas menores são ordenados separadamente,

resultado é combinado

� Vetor é rearranjado a partir de um pivô


� Processo de partição◦ A parte esquerda com chaves menores ou iguais

◦ ao pivô.

◦ A parte direita com chaves maiores ou iguais ao pivô.

25

� Particionamento◦ Escolha do pivô (x)

◦ Percorre-se o vetor a partir da esquerda até que o valor seja maior ou igual ao pivô � V[i] >= x

◦ Percorre-se o vetor a partir da direita até que o valor seja menor igual ao pivô

V[j] <= x


� V[j] <= x

◦ Troca-se V[i] e V[j]

◦ Continuar o processo até que i e j se cruzem

26

� Particionamento

� Vetor V estará particionado de forma que◦ V[esq], V[esq+1]..., V[j] são menores ou iguais ao pivô (x)

◦ V[i], V[i+1],..., V[dir] são maiores ou iguais ao pivô (x)


typedef struct {Indice Esq, Dir;

} TipoItem;void QuickSort_NaoRec(Item *A, Indice *n) {

TipoPilha Pilha;Indice Esq, Dir, i, j;TipoItem Item;FPvazia(Pilha);Esq = 1;Dir = *n;Item.Dir = Dir;Item.Esq = Esq;Empilha(Item, Pilha);repeatif (Dir > Esq) {

Particao ( Esq, Dir , &i, &j, A);


Particao ( Esq, Dir , &i, &j, A);Item.Dir = Dir; Item.Esq = i;Empilha(Item, Pilha);Dir = j;

} else {Desempilha(Pilha, Item);Dir = Item.Dir;Esq = Item.Esq;

}}while (!Vazia(Pilha));}

void particao(Indice Esq, Indice Dir, Indice *i, Indice*j, Item *A) {

Item x, w;*i = Esq;*j = Dir;x = A[(*i + *j) / 2]; /* obtem o pivo x */do {

while (x.Chave > A[*i].Chave)(*i)++;

while (x.Chave < A[*j].Chave)(*j) -- ;


(*j) -- ;if ((*i) ≤ (*j)){ w = A[*i]; A[*i] = A[*j]; A[*j] = w;

(*i)++; (*j)--;}

}while (*i <= *j);}

void qordena(Indice Esq, Indice Dir, Item *A) {particao(Esq, Dir, &i, &j, A);if (Esq < j)

qordena(Esq, j, A);if (i < Dir)

qordena(i, Dir, A);}

void quicksort (Item *A, Indice *n) {


void quicksort (Item *A, Indice *n) {qordena(1, *n, A);

}

� Eficiente para situações genéricas

� Requer em média n log n comparações para n itens◦ Pior caso O(n2)

� Método não estável


� Listas, Pilhas e Filas

Próximas aulasPróximas aulas34

� Notas de Aula do Prof. Bruno B. Boniati

� Notas de Aula do Prof. João Luís Garcia Rosa

� http://www2.dcc.ufmg.br/livros/algoritmos/

ReferênciasReferências35

Estrutura de DadosEstrutura de DadosEstrutura de DadosEstrutura de DadosCarlos Eduardo Batista

Centro de Informática - [email protected]

estrutura de dados -...

Documents