universidade federal de itajubá mestrado em ciências e tecnologia da informação prof. dr....

Universidade Federal de ItajubáMestrado em Ciências e Tecnologia da Informação

Prof. Dr. Alexandre C. B. [email protected]/ramos

Algoritmos e Estruturas de Dados

Objetivos

Mapear o domínio do problema no domínio da solução utilizando estruturas de armazenamento de informações adequadas e algorítimos eficientes.

Construir estruturas a partir de abstrações tanto de informações quanto do procedimentos.

Construir e analisar algorítimos para manipular e armazenar dados em programas.

Critério de avaliação: 70% - Prova bimestral 30% - Trabalhos

Programa – 1º. bimestre

Introdução Tipos abstratos de dados Registros Procedimentos e funções Recursividade

Complexidade de algoritmos Introdução Tipos de complexidade Notação O Algoritmos ótimos

Programa – 1º. bimestre

Listas, filas e pilhas Alocação sequencial Listas encadeadas Listas circulares Listas duplamente encadeadas Filas e pilhas

Árvores Percurso em árvores Árvores AVL Árvores rubro-negras Árvores múltiplas

Bibliografia

Tenenbaum, A. M. et all. Estruturas de Dados Usando C. Makron Books. São Paulo, 1995.

Estruturas de dados. Paulo Veloso, Clésio Veloso dos Santos e outros. Ed. Campus.

Algorítmos e Estruturas de dados. Guimarães Lages. Ed. LTC.

Estruturas de dados Fundamentais: conceitos e aplicações. Silvio do Lago. Ed. Érica

Avaliações

Trabalhos práticos individuais = 10pts Seminários em grupo = 20pts Avaliação escrita = 70 pts (26/09/2012)

Seminários

Apresentação e exercícios com correção. Temas e datas:

Árvores AVL : Diogenes, Ricardo e Wellison : 12/09

Árvores Rubro-negras : Daniele e Henrique : 12/09

Árvores B e B* : Iuri, Orlando e Rodrigo : 19/09 Árvores de Bit : João e Danillo : 19/09 Árvores R : Felipe e Flávio : 19/09

Avaliação: 26/09

Introdução

Desenvolvimento de Programas

O processo de solução de problemas por meio de computador pode ser descrito a partir das seguintes etapas:

1. Especificação do problema 2. Projeto em alto nível 3. Análise de alternativas 4. Refinamento e codificação 5. Verificação do comportamento

Desenvolvimento de Programas

Nesta descrição devemos ressaltar 3 pontos:• Estruturas de dados, que retratam as relações

lógicas existentes entre os dados, de modo análogo ao uso de um modelo matemático para espelhar alguns aspectos de uma realidade física.

• Operações, manipulam as estruturas de dados transformando-as.

• Estruturas de Representação, que são formas de armazenar na memória os dados, isto é, as estruturas de dados manipuladas pelas operações, que devem:– Preservar as relações lógicas existentes entre os

dados.– Permitir que as operações sejam descritas por

procedimentos simples e eficientes.

Exercício 1

Escreva um algoritmo para solucionar o seguinte problema:Três missionários e três canibais se encontram em

um lado do rio. Todos concordam que precisam chegar do outro lado.

Mas os missionários não confiam nos canibais. Assim, os missionários querem atravessar o rio de modo tal que o número de missionários em qualquer das margens nunca seja inferior ao número de canibais que estiver do mesmo lado.

O único barco disponível só carrega 2 pessoas por vez. Como todos poderão chegar ao outro lado, sem que os missionários arrisquem suas vidas?

Exercício 1bis

Escreva um programa em linguagem C que, de forma interativa, ajude o usuário a resolver o problema.

O programa deverá ser apresentado na tela de texto, sendo os canibais representados pela letra “C” e os missionarios pela letra “M”.

O usuário deverá escolher o conjunto certo de “C” e “M” para atravessar o rio para o lado desejado.

A aparencia do programa podera ser:

CC MMM C Vai: C C Volta:

Tipos Abstratos de Dados

Tipos Abstratos de Dados

Para descrever os algorítimos e procedimentos durante o curso, vamos utilizar uma linguagem de descrição algoritmica.

A noção do tipo de dados ocorre na maioria das linguagens de programação. O tipo da variável delimita o conjunto de valores que ela pode tomar e as operações que podemos efetuar com elas.

Geralmente uma linguagem de programação oferece 2 tipos de Tipos de dados:– Tipos Primitivos: São tipos básicos pré definidos– Tipos construídos: tipos criados a partir de

mecanismos presentes na linguagem.

Tipos primitivos Operações aceitasinteiro - int + - * div modreal - real + - * /lógico - log e ou não (.e. & .ou. V )caracter- car = Exemplos: Tipos inteiro ? Real ? Lógico ? Caracter ?

5 div 2 = 2

5 mod 2 = 1

5 2

1 2

V= F e F = V

Funções de Transferência

São operações especiais que manipulam variáveis de tipos primitivos, diferentes entre si, por exemplo: Xi sendo X real e inteiro.

Comparações também podem ser consideradas funções de transferência, por exemplo:X < i sendo X real e i inteiro e o resultado lógico F(V)

Trunc, converte um numero real em inteiro trunc (75.37)=75

Tier, converte inteiro em real tier (75)= 75.0Ord, transforma car em int que é seu numero de ordem

no conjunto de caracteres ASCII ord (‘0’) <...< ord (‘9’)<...< ord(‘A’)<...< ord(‘a’). Mais funções de transferencia podem ser obtidas nos tipos construídos.

Utilizados para construir tipos novos a partir de tipos primitivos, segundo a definição:

Tipos nome_do_tipo: definição_do_tipoa ser utilizada com os seguintes mecanismos:Tipos construídos forma Geral Vetor - Vet Vet (limite inferior...limite superior) de tipo

registro - reg reg (seletor1: tipo1, seletor2: tipo2,...,seletorn: tipon)

seqüência- seq seq de tipo p/ ex: tipo cadeia:: seq car

referência - ref ref a tipo p/ ex: tipo matricula:: ref int

alternativa - alt alt (tipo1 | tipo2 |...| tipon ) p/ ex: tipo questão:: alt (int | car)

string

ponteiro

Mecanismo para construção de tipos

Exemplos:

Vetor= tipo dia :: vet [0...30] de int [1,2,3,4,...31]onde dia[2] = 3 dia [i] = 31 então i= 30Registro= tipo inscrição::reg (disciplina: int, turma:

car)Se matricula: inscrição “Se matricula é uma variável

do tipo inscrição, então matricula (103, ‘a’)daí temos: matricula.turma= a matricula.disciplina= 103

O elemento da turma”a”, quer inscrever-se na disciplina 103

Seqüência= tipo cadeia:: seq carSe x: cadeia e x< ‘r’, ‘a’, ‘m’> Seq. De comprimento 3

y: cadeia e y<‘e’, ‘m’, ‘i’, ‘g’, ‘r’, ‘a’> Seq. De comprimento 6

Então princ x = ‘r’ cont x = < ‘a’, ‘m’> yconc x = < ‘e’, ‘m’, ‘i’, ‘g’, ‘r’, ‘a’, ‘r’, ‘a’, ‘m’>Se Z: cadeia e Z< ’a ’> Então princ Z=‘a’ cont z=<>

Seqüência nula de comprimento 0

Referência

Tipo de matricula :: ref intEste mecanismo permite uma modalidade

dinâmica de alocação, ao contrário dos mecanismos anteriores (vet, seq, etc.) cuja alocação é contínua.

Se geografia: matrícula o espaço necessário para a variável geografia compreende 2 partes:

1° parte do valor: armazena um valor do tipo int;2° parte de posição: armazena uma indicação de

posição da localização da parte de valor.

Aloque geografiaa) após a declaração da variável

b)após a execução do comando aloque

Desaloque geografiac)após a execução do comando

(Na memória) Parte de posição (geografia)

Parte de posição

Parte de valor geografia

Parte de posição

Sejam os comandos:

Alternativa= tipo questão:: alt ( int | car )Se resposta : questão Então resposta? tem valor igual a 1 (int) ou 2

(car)

EnumeraçãoPermite definir tipos de dados por meio dos valores

que os dados daquele tipo podem tomar. Tipo mês=

(jan,fev,mar,abr,mai,jun,jul,ago,set,out,nov,dez) seja mês_nasc: mês Se mês_nasc= dez Então Processo qualquer

Permite que uma mesma variável possa, em momentos diferentes, ter valores e tipos diferentes

jan<fev<mar<...<dez

Variáveis, Declarações e Expressões

Nomes (identificadores) podem ser usados para denotar variáveis, do seguinte modo:

var nome: tipo; ou nome1, nome2,...,nome3: tipo;

Todas as variáveis existentes no programa fonte devem ser declaradas uma vez ( e somente uma vez) no seu cabeçalho, exemplos:

Tipos Variáveismatr10:: vet [0..9] de vet [0..9] de real; adj, custo: matr10;status:: reg (no: int, ferias: log, dia: int); folha: seq de status;nome:: seq car; alfa: vet [1970...1975]

de nome;celula:: ref int; onde : celula

Exercício 2

Escreva um algoritmo que leiam duas strings de 0s e 1s representando inteiros não-negativos binários, e imprima a string representando a soma, a diferença e o produto, respectivamente.

Comandos Básicos

Comandos Básicos

São utilizados para manipular as variáveis, são eles:

Atribuição variável expressãoEntrada Leia ( lista_de_variáveis)Saída Escreva ( lista_de_variáveis) Se condição então

comando

Condicionais Se condição então comando senão

comando Interação Enquanto condição faça comando Repita

comando até (que) condição para variável de valor_inicial

incr valor_do_incremento até valor_inicial. Faça comando Escape de malha Saída ou escapeSeleção Conforme variável, Faça lista_dos_casos

Atribuição

V e (e precisa ser do mesmo tipo de V) X (Y+Z)/2.0 x,y e z: real; “O valor de X depois da avaliação será média

aritmética dos valores de Y e Z antes” i i+1 exemplo comum para contagens

Variáveis de tipo contruído: var custo: vet[1..5] de real; custo[1] custo[2] + 7.8

var matr: reg(disc: int, turma: car); matr (2015, ‘ a’ );

Exemplos:

Entrada de Dados

Leia (V1, V2, V3, ... , Vn); Neste caso todas as variáveis listadas recebem vetores do dispositivo de entrada. Por exemplo:

var x: real; i: int; a: vet [1..3] de int; Início leia (x,a,i) Fim. Causará a leitura do dispositivo de entrada

para x, a e i de um real, um vetor e um inteiro. Exemplos:

Saída de Dados

Escreva (V1, V2, V3, ...Vn); Neste caso todas as variáveis listadas serão escritas no dispositivo de saída, por exemplo:

var i: int; a: vet [1..5] de int; x: real; Início x 2.1; i i+ 2; a[2] i; escreva(i,a,x); Fim. Exemplos:

Condicional

Se L Então A Senão B var x,y,z: real; {Calcula o menor de 2

nos.} Se x < y Então z x {comando simples} Senão Início {comando composto} z y; Se x < z Então z x; Fim; A avaliação da condição não altera o valor de

nenhuma variável mesmo que ela contenha expressões como:

Se (2.0*y < x/3.2) .e. (z<>0) Então... Exemplos:

Iteração - Enquanto

Enquanto L Faça A Var x, y: int; Início Enquanto x =< y Faça x 2*y; Enquanto x <> y Faça Se x > y Então x x - y Senão y Y - x; Fim. Causa a repetição do comando até que x=y.

Caso o sejam no início o programa termina após o primeiro teste.

Iteração - Repita

Repita A até L Var x,y: int; Início Se x >< y Então Repita Se x > y Então x x-y Senão y y-x; Até x=y; Fim.

Iteração - Para

Para V de i incr P até F Faça A Var i, soma: int; valor: vet [1..10] de int; Início Soma 0.0; Para i 1 até 10 Faça soma soma+valor[i]; Fim.

Seleção

Caso V Faça (V1:C1, V2:C2,...,Vn:Cn) ou Caso V Faça (V1:C1, V2:C2,...,Vn:Cn) Senão Faça (V1:C2, V2:C3,...,Vn:Cn+1) Onde Vi são valores e Ci são comandos,

exemplo: Var Ch: car; Início Caso Ch Faça ‘A’..’Z’,’a’..’z’: Escreva (‘Letra’); ‘0’..’9’: Escreva(‘Digito’); ‘+’,’-’,’*’,’/’: Escreva (‘Operador’); Senão Escreva (‘Caracter especial’); Fim; Fim.

Exercício 3

Escreva um algoritmo para ler uma string de 0s e 1s representando um inteiro positivo em notação binária e imprima uma string de 0s, 1s e 2s representando o mesmo número em notação ternária

Escreva um programa em C que realize essa conversão

Variáveis Indexadas - Vetores

A utilização de vetores emcomputação é uma técnica muito útil para a otimizaçãode tempo e memória e tornaum programa mais elaboradoe eficiente.Forma geral:Tipo vetor:: vet[1..3] de int;Var A, B, C: vetorz;

Leitura e Escrita de um Vetor

Exemplo: Leitura Var x: vet[1..4] de int; Início Para i:= 1 até 4 Faça leia(x[i]); Fim. Exemplo: Escrita Var x: vet[1..4] de int; Início Para i:=1 até 4 Faça Escreva(x[i]); Fim. É bom lembrar que poderíamos usar os

comandos Repita e Enquanto, tanto na leitura quanto na escrita.

Variáveis Indexadas - Matrizes

Uma matriz é uma variávelindexada que possui 2 dimensõese portanto precisa de 2 índicespara marcação de valor. Suarepresentação matemática é:dimensão: m - linhas representação: Amxn n - colunasForma geral:Tipo matriz:: vetor[1..3,1..3] de int;Var A, B, C: matriz;

Leitura e Escrita de uma Matriz

Faz-se necessário 2 varreduras, uma com a variável “j” percorrendo as colunas e outra com a variável “i” percorrendo as linhas: Exemplo: Leitura Para i:= 1 até m Faça Para j:= 1 até n Faça Leia(A[i,j]); Exemplo: Escrita Para i:= 1 até m Faça Para j:= 1 até n Faça Escreva(A[i,j]);

Exemplo

Fazer um algoritmo Algoritmo Matriz; para ler e imprimir Var A: vet[1..3,1..3] de int;

i,j: int; a matriz: Inicio Para i:= 1 ate 3 Faça Para j:= 1 ate 3 Faça

Leia(A[i,j]); Para i:= 1 ate 3 Faça Para j:= 1 ate 3 Faça

Leia(A[i,j]); Fim.

Registros

São conjuntos de dados logicamente relacionados, mas de tipos diferentes (inteiro, real, car etc.); Utilizamos registros, quando vetores ou matrizes possuem diferentes componentes dentro de um mesmo campo, por exemplo:

Como criar uma matriz

desse tipo, onde existem

2 tipos de variáveis (int

e car)? Percebe-se que é

impossível a utilização

de matrizes, pois na mesma declaração só pode conter um tipo de elemento. Por isso utiliza-se “reg”.

Forma Geral de Registro

Tipo pagantes:: reg (cadast: int, nome: caract, bandeira: caract, pagamento: caract); Pode-se utilizar vetor composto por reg ou

matriz composta por reg, exemplo: Escreva um algoritmo que dados 10 codigos de

profissão, emita o nome da profissão correspondente.

Algoritmo Profissao;Tipo lista: reg(codigo: int, nome:caract);Var tab: vet [1..100] de lista; cod,i,k: int;Inicio Para i:= 1 ate 10 Faça leia(tab[i].codigo, tab[i].nome); Leia (cod); {recebe o codigo para comparar} Repita i:= 1; Enquanto(tab[i].cod<>cod) e (i=<10) Faça i:=i+1; Se (i>10) Então Escreva(‘Codigo invalido’) Senão Escreva(‘Cod. Desejado ‘,tab[i].nome); Ate(cod=0);Fim.

Arquivos

São estruturas de dados manipuladas fora do ambiente do programa. Considera-se como ambiente do programa a memória principal, onde nem sempre é possível ou conveniente manter certas estruturas de dados.

No ambiente do programa, tem de ser declaradas as estruturas externas de dados: declara-se primeiro o tipo do arquivo e depois os nomes dos arquivos deste tipo. Um exemplo: Algoritmo arquivo;

Var dados: text; Início Fim.

Abertura e Fechamento de um Arquivo

Para abrir um arquivo novo, utiliza-se o comando:

Rewrite (NomeArquivo);Este comando ignora os dados existentes e

imprime os novos dados no lugar dos antigos. Para a associação desta identificação interna

com o nome externo do arquivo usa-se o comando:

Assign (NomeArquivo, ‘NomeExtern’); Para abrir um arquivo cujo problema é não

perder os dados existentes:Reset(NomeArquivo); Assim, os dados não são perdidos e a impressão

é realizada depois da última linha de dados.

Associação de Arquivos no Programa

Para a associação, também utiliza-se o comando:

Assign(dados,’dados.txt’);Exemplo:Algortimo Arquivo;var dados:text;Inicio Assign(dados,’dados.txt’); Reset(dados);Fim.

Fechamento de Arquivo

Para terminar a geração do arquivo, faz-se necessário o comando de fechamento antes do “End.” final do programa, forma geral:

close(NomeArquivo); exemplo: ........ close(dados); Fim.

Escrevendo e Lendo de Arquivos

Toda vez que não for desejado ler da tela, ou imprimir na tela, uma pequena modificação deve ser feita nos comandos Escreva e Leia, por exemplo:

Leia (dados, x, y); Escreva (dados, x,y); Assim a estrutura completa fica:var dados: text; x,y: int;Inicio Assign(dados,’dados.txt’); Reset(dados); leia(dados,x,y); ........ Escreva(dados,x,y);....... Close(dados); Fim.

Exercicio 4

Desenvolver um algoritmo que leia os valores de duas matrizes mxn quaisquer e A e B, do arquivo entrada.dat e escreva os valores da matriz C=A+B no arquivo saida.dat. Escreva um programa que realize este algoritmo.

Procedimentos

São trechos de programa que possuem seus objetos (variáveis, arquivos etc.) e comandos próprios e que para serem executados devem ser ativados por um programa principal ou outro procedimento:

Forma Geral:Procedimento nome; declaração dos objetos locais ao procedimento Inicio comandos do procedimento Fim;

Exemplo de Procedimento

Algoritmo proced; var A,B,C,X,Y,Z: int; teste:log; Procedimento Repete; Inicio x SQR(A)+B*SQR(B)+SQR(C)*SQR(C); y A+C; Fim;Inicio Teste false; Leia (A,B,C); Repete; Se x>y Entao teste true; A A+1; Leia(z);

Repete; Escreva(x,y,z,teste);Fim.

Funções

Usada para atribuir o resultado da chamada de um procedimento a uma variável.

Forma Geral: Função nome: tipo; declaração dos objetos locais a função; Inicio comandos da função; Fim;

Exemplo de Função

Algoritmo funcao;var A, B, C: real;Inicio Funcao ABS(x): real; Var x: real; Inicio Se x>= 0 Entao ABS X Senao ABS -X; Fim; A 5; B -3; C -10; Escreva (ABS(A)); Escreva (ABS(-3)); E ABS(E**3) * A+B; Escreva

(E); Fim.

Ponteiros

São utilizados para alocação dinâmica de variáveis.

Alocação dinâmica: o programa é capaz de alocar área de memória, que não foram declaradas anteriormente;

Para alocar uma variável dinamicamente, deve-se:

1. Criar espaços para as novas variáveis em tempo de execução; e

2. Definir “ligações” entre essas variáveis dinamicamente.

A geração de uma variável dinâmica de tipo qualquer é feita pelo operador NEW.

Exemplo de Ponteiro

New(p); {Gera uma variável de tipo qualquer e a}

{coloca em P o endereço da variável }

Program Aloca;P Type ptr=

integer; Var P:^ptr;

{estatica}Memória usada Memória Livre Beginpelo programa do sistema New(P);

{dinamica} P $5C2D p^:= 1234; $5C2D 1234 writeln(p^); End.

Exemplo de Ponteiro em Pascal

Exercício 5

Escrever um algoritmo que leia uma tabela contendo registros de matriculas, nomes e notas (B1, B2 e MF) e permita ao usuário as funções inserir, excluir, alterar e pesquisar registros pelo numero da matricula. Escreva um programa que realize este algoritmo.

Recursividade

Recursividade

Chama-se método recursivo um método que, para ser aplicado a uma estrutura, envolve a aplicação dele mesmo às subestruturas componentes.

Todo procedimento recursivo (ou não) deve possuir pelo menos uma chamada proveniente de um local exterior a ele (chamada externa).

Em termos de programação, isso implica em procedimentos que chamam a si próprios, exemplo:

Proc fat : int (n:int) Suponha k <- fat(5) Se n=0 como n <> 0 Então 5*fat(4) retorne 1 4*fat(3)..... Senão 1*fat(0) retorne n * fat (n – 1) como n=0 a recursividade para e o resultado é calculado

Recursividade

A todo procedimento recursivo corresponde um outro não recursivo que executa, exatamente, a mesma computação, por exemplo:

Fa[0] = 1Para j = 1,...,n faça fat[j] = j x fat[j-1]

Exercício 6

1. Imagine A como um vetor de inteiros. Apresente algoritmos recursivos para calcular: O elemento máximo do vetor O elemento mínimo do vetor A soma dos elementos do vetor O produto dos elementos do vetor A média dos elementos do vetor

2. Determine o que a seguinte função calcula:Func(n) int n; { if (n==0) return (0); return (n+func(n-1);}

Exercício 6

3. Responder certo ou errado: Todo procedimento recursivo deve incorporar

terminações sem chamadas recursivas, caso contrário ele seria executado um número infinito de vezes.

O algoritmo que calcula o fatorial de forma recursiva, requer apenas uma quantidade constante de memória

O algoritmo fatorial não recursivo, requer o armazenamento do vetor fat, com n+1 elementos

4. Mostrar que o algoritmo para o problema da torre de Hanoi, requer exatamente 2n – 1 movimentos de disco para terminar.

5. Elaborar um programa não recursivo para a torre de Hanoi.

Complexidade de Algoritmos


A Complexidade de um Algoritmo consiste na quantidade de “trabalho” necessária para a sua execução.

A expressão matemática que define a complexidade de um algoritmo é determinada pela contagem de uma grandeza (por exemplo, as operações dominantes realizadas).

Operação dominante é o conjunto de operações básicas que são executadas repetidas vezes.


Um algoritmo serve para resolver um determinado problema, e todos os problemas têm sempre uma entrada de dados (N)

O tamanho desse N afeta sempre diretamente no tempo de resposta de um algoritmo

Dependendo do problema, já existem alguns algoritmos prontos, ou que podem ser adaptados

O problema é: qual algoritmo escolher?


A complexidade de um algoritmo pode ser dividida em: Complexidade Espacial: Quantidade de

recursos utilizados para resolver o problema; Complexidade Temporal: Quantidade de

Tempo utilizado. Pode ser visto também como o número de instruções necessárias para resolver determinado problema;

Em ambos os casos, a complexidade é medida de acordo com o tamanho dos dados de entrada (N)


Exemplo 1: inversão de uma sequênciaPara i = 1,...,[n/2] faça temp = S[i] S[i] = S[n-i+1] S[n-i+1] = temp

Nesse algoritmo cada entrada é uma sequencia que se deseja inverter e o algoritmo efetua sempre as mesmas operações para as sequencias de mesmo tamanho n.Cada passo executa uma troca de posições, então o número de passos é igual ao numero de execuções do bloco Para, ou seja, [n/2] sendo n>1.


Exemplo 2: Soma de matrizespara i = 1,...,n faça para j = 1,...,n faça cij = aij + bijQual o numero total de passos?

Como no exemplo o algoritmo sempre efetua as mesmas operações sempre que a e b forem matrizes nxn e n é o parâmetro independente.

Cada passo desse algoritmo corresponde a execução da soma aij + bij e o número total de passos é igual ao número total de somas, isto é, o algoritmo efetua n2 passos.


Exemplo 3: Multiplicação de matrizespara i = 1,...,n faça para j = 1,...,n faça cij = 0 para k = 1,...,n faça cij = cij + aik * bkjQual o numero total de passos?

Como no exemplo o algoritmo sempre efetua as mesmas operações sempre que A e b forem matrizes nxn e n é o parâmetro independente.

Cada passo desse algoritmo corresponde a execução do produto aik * bkj e o número total de passos é igual ao número total de somas, isto é, o algoritmo efetua n3 passos.


Existem três escalas de complexidade: Melhor Caso - Ω ômega Caso Médio - Θ theta Pior Caso Ο - ômicron

Nas três escalas, a função f(N) retorna a complexidade de um algoritmo com entrada de N elementos

Melhor Caso

Definido pela letra grega Ω (Ômega) É o menor tempo de execução em uma entrada

de tamanho N É pouco usado, por ter aplicação em poucos

casos. Ex.:

Se tivermos uma lista de N números e quisermos encontrar algum deles assume-se que a complexidade no melhor caso é f(N) = Ω (1), pois assume-se que o número estaria logo na cabeça da lista.

Caso Médio

Definido pela letra grega θ (Theta) Dos três, é o mais difícil de se determinar Deve-se obter a média dos tempos de execução de todas as

entradas de tamanho N, ou baseado em probabilidade de determinada condição ocorrer

No exemplo anterior: A complexidade média é P(1) + P(2) + ... + P(N) Para calcular a complexidade média, basta conhecer as

probabilidades de Pi; Pi = 1/N, 1 <= i <= N Isso resulta em P(1/N) + P(2/N) + ... + P(N/N) Que resulta em 1/N(1+2+...+N)

Que resulta em 1 N(N+1) = (N+1) N 2 2

Que resulta em f(N) = θ (N+1) 2

Pior Caso

Representado pela letra grega O (ômicron) ou O maiúsculo.

É o método mais fácil de se obter. Baseia-se no maior tempo de execução sobre todas as entradas de tamanho N

Ex.: Se tivermos uma lista de N números e

quisermos encontrar algum deles, assume-se que a complexidade no pior caso é O (N), pois assume-se que o número estaria, no pior caso, no final da lista.


Mas como saber qual é a complexidade de um determinado algoritmo implementado?

Para resolver esse problema, dividiu-se os algoritmos em “Classes de Problemas”, de acordo com o parâmetro que afeta o algoritmo de forma mais significativa

Classes de Algoritmos

São elas:– Complexidade Constante– Complexidade Linear– Complexidade Logarítmica– NlogN– Complexidade Quadrática– Complexidade Cúbica– Complexidade Exponencial

Complexidade Constante

São os algoritmos de complexidade O(1) Independe do tamanho N de entradas É o único em que as instruções dos algoritmos

são executadas num tamanho fixo de vezes Ex.:

Function Vazia(Lista: TipoLista): Boolean;Begin

Vazia := Lista.Primeiro = Lista.Ultimo;End;

Complexidade Linear

São os algoritmos de complexidade O(N) Exemplo 4:

Complexidade Linear

Uma operação é realizada em cada elemento de entrada

Exemplo 5: pesquisa de elementos em uma lista

Procedure Busca(Lista: TipoLista; x: TipoElem; Var pos: integer)

Var i: integer;Begin

i:=1;while Lista.Elemento[i] <> x do

i := i+1;if i >= Lista.MaxTam then

pos := -1else

pos := i;End;

Complexidade Linear

Exemplo 6: Determinar a complexidade do laço for (i = soma = 0; i < n; i++)

soma += a[i];

Primeiro, duas variáveis são inicializadas, então o laço for itera n vezes e, durante cada iteração, executa duas atribuições, uma das quais a soma e a outra atualiza i.

Assim, existem 2 +2n atribuições para a rodada completa desse laço for; sua complexidade é O(n).

Complexidade de Linear

Exemplo 7: Determinar a complexidade do código de inversão de sequências

for ( i = 1; i <= n/2; i++) { temp = S[i]; S[i] = S[n-i+1]; S[n-i+1] = temp;}

Nesse caso o código apresenta a propriedade de o número de passos manter-se o mesmo quando aplicado a entradas diferentes de mesmo tamanho, isto é, para um mesmo valor de n o resultado permanece constante.

A variável independente é o valor de n, então as complexidades de pior, médio e melhor caso são iguais entre si.

O código sempre efetua [n/2] passos, logo sua complexidade é O(n)

E para o caso de soma e multiplicação de matrizes?

Complexidade Logarítmica

São os algoritmos de complexidade O(logN) Ocorre tipicamente em algoritmos que dividem

o problema em problemas menores Ex.: O algoritmo de Busca Binária

Complexidade NlogN

Como o próprio nome diz, são algoritmos que têm complexidade O(NlogN)

Ocorre tipicamente em algoritmos que dividem o problema em problemas menores, porém juntando posteriormente a solução dos problemas menores

A maioria dos algoritmos de ordenação externa são de complexidade logarítmica ou N Log N

Complexidade Quadrática

São os algoritmos de complexidade O(N²) Itens são processados aos pares, geralmente com um loop

dentro do outro


São os algoritmos de complexidade O(N²) Itens são processados aos pares, geralmente com

um loop dentro do outro Ex.:

Procedure SomaMatriz(Mat1, Mat2, MatRes: Matriz);Var i, j: integer;Begin

for i:=1 to n dofor j:=1 to n doMatRes[i,j] := Mat1[i, j] + Mat2[i,j];


Exemplo 8: Determinar a complexidade do código que produz a soma de todas as submatrizes que começam com a posição 0

for (i = 0; i < n; i++) {

for (j = 1, soma = a[0]; j < n-i; j++)

soma += a[j];

cout<<”soma para submatriz 0 até “<<i<<”e “<<soma<<endl;

}Antes que os laços comecem, i é inicializado. O laço mais externo é realizado n vezes, executando em cada iteração um laço for mais interno, uma impressão e as atribuições para 1, j e soma. O laço mais interno é executado i vezes para cada i Є {1,...,n-1} com duas atribuições para cada iteração: uma para soma e outra para j. Assim existem 1+3n+ Σi=1

n-1 2i = 1+3n+2(1+2+...+n-1)= 1+3n+n(n-1)= =O(n)+O(n2) = O(n2) atribuições são executadas antes que o programa termine.

Complexidade Cúbica

São os algoritmos de complexidade O(N³) Itens são processados três a três, geralmente com

um loop dentro do outros dois Ex.:

Procedure SomaElementos_Vetor_Indices_Matriz (mat: Matriz, vet: Vetor);

Var i, j: integer;Begin

for i:=1 to n dofor j:=1 to n dofor k:=1 to n do

mat[i, j] := mat[i, j] + vet[k];

Complexidade Exponencial

São os algoritmos de complexidade O(2N) Utilização de “Força Bruta” para resolvê-los

(abordagem simples para resolver um determinado problema, geralmente baseada diretamente no enunciado do problema e nas definições dos conceitos envolvidos)

Geralmente não são úteis sob o ponto de vista prático

Ordens mais comuns

n2

n

f

n log n

(linear)

(exponencial)

log n

(constante)

Cálculo da complexidade

Foi visto que, para calcular a complexidade de um algoritmo, deve-se analisar o pior caso

A análise deve ser feita no programa todo, de acordo com a tabela a seguir

Algumas operações com a notação O

Exemplo 9 Procedure Verifica_Item_Lista (Lista: TipoLista; x: TipoItem; pos: integer);

Var i: integer; Begin i:=1; achou := false; while (i <= Lista.Tamanho) and not achou do begin inc(i); if Lista.Item[i] = x then achou := true; end; if achou then pos := i else pos := -1;

O(1)

O(N)

f(N) = O(9 * O(1) + O(N)) = O(O(1) + (O(N)) = O(N)

O(1)

Exemplo 10

Procedure Verifica_Item(Lista: TipoLista; x: TipoItem; pos: integer);

Var i: integer; Begin i:=1; achou := false; while (i <= Lista.Tamanho) and not achou do if Lista.Item[i] = x then achou := true; if achou then pos := i else for i:= Lista.Tamanho +1 to MaxTam; Lista.Item[i] := x;

O(1)

O(N)

O(1)

f(N) = O(7 * O(1) + 2*O(N)) = O(O(1) + (O(N)) = O(N)

O(N)O(1)

Exercício 7

1. Escrever as seguintes funções em notação O: n3 – 1 n2 + 2 log n 3nn +5 * 2n (n-1)n + nn-1

2. Certo ou errado: E - Se f,g são funções tais que f=O(g) e g= Ω(f) então f = Ɵ(g) E - Se a complexidade de melhor caso de um algoritmo for f,

então o número de passos que o algoritmo efetua, qualquer que seja a entrada é Ω(f)

E - Se a complexidade de pior caso de um algoritmo for f, então o número de passos que o algoritmo efetua, qualquer que seja a entrada é Ɵ(f)

Listas Lineares

Listas Lineares

São estruturas que permitem representar um conjunto de dados de forma a preservar a relação de ordem linear (ou total) entre eles.*

Definição: conjunto de n 0 nós X1, X2, X3, ..., Xn,

organizados estruturalmente de forma a refletir as posições relativas dos mesmos:

Se n > 0, então X1 é o primeiro nó e Xn é o último nó. Quando n=0 a lista é vazia:

Operações com Listas Lineares

Acessar o k-ésimo nó para obter ou alterar seu conteúdo

Inserir um novo nó após (ou antes) o k-ésimo nó da lista

Remover o k-ésimo nó da lista Concatenar duas listas Determinar o número de nós de uma lista Localizar o nó que contém um dado valor

Algoritmo para Acessar o K-ésimo Nó de uma Lista

Algoritmo AcessarKesimo;var x:vet[1..10] de int; k,fim: int; sinal:log, val: int;Inicio x[2] 3; leia(k); fim 5; {Uso 5 elementos da

lista} Se (K=<0) ou (k>fim) {Verifica a validade de K} Entao sinal false Senao Inicio val x[k]; sinal true; Fim; Escreva (‘O k-ésimo vale: ‘,x[k]); Fim.

Programa para Acessar o K-ésimo Nó de uma Lista

Algoritmo para Alterar o valor do K-ésimo Nó

Algoritmo AlterarKesimo;var x:vet[1..10] de int; k,fim: int; sinal:log, val: int;Inicio x[3] 1; leia(k); leia(val); fim 5; {Uso 5 elementos da lista} Se (K=<0) ou (k>fim) {Verifica a validade de K} Entao sinal false Senao Inicio x[k] val; sinal true; Fim; Escreva (‘O k-ésimo vale: x[‘,k,‘]= ‘,x[k]); Fim.

Algoritmo para Inserir um Novo Nó

Algoritmo InserirKesimo;var x:vet[1..10] de int; i,k,fim: int; sinal:log, val: int;Inicio leia(k); leia(val); fim 5; {Uso 5 elementos da

lista} Se (K=<0) ou (k>fim) Entao sinal false {Verifica a validade de

K} Senao Para i fim inc -1 ate K Faça Inicio x[i+1] x[i]; fim fim+1; x[k] val; sinal true; Fim; Escreva (‘O k-ésimo vale: x[‘,k,‘]=‘,x[k]); Fim.

Supõe-se que haja ao menos um elemento disponível

Programa para inserir um novo nó

Algoritmo para Remover o K-ésimo da Lista

Algoritmo RemoverKesimo;var x:vet[1..10] de int; i,k,fim: int; sinal:log, val: int;Inicio leia(k); leia(val); fim 10; {Uso todos elementos

da lista} Se (K=<0) ou (k>fim) Entao sinal false {Verifica a validade de

K} Senao Inicio Para i k inc 1 ate Fim-1 Faça x[i] x[i +1]; fim fim-1; sinal true; Fim; Escreva (‘O k-ésimo vale: x[‘,k,‘]=‘,x[k]); Fim.

Programa para remover um nó

Listas Encadeadas

Resolvem o problema do comprimento máximo da lista permitindo a alteração dinâmica do tamanho da lista aumentando seu comprimento inicial. Neste tipo de lista, cada nó além de conter o dado propriamente dito, deverá também conter a indicação do nó seguinte, caso existir (contiguidade lógica).

X1 X2 Xn-1 Xn ...Representação: referência tipo no:: reg(dado: real, proximo:

ref no); dado proximo var primeiro: ref no; p^.dado p^.proximo

Obtenção dos Nós

A obtenção dos nós para compor a lista é feita por meio do comando new(p) onde p também é uma variável do tipo referência a nó.

New(p) : aloca dinamicamente um espaço na memória do computador correspondente a um nó. O endereço deste espaço é atribuído à variável p.

Exemplo: Desenvolvimento de um algoritmo para criação de uma lista encadeada com um nó apenas;

Algoritmo para a criação de um nó

Algoritmo listaUmNo;tipo no:: reg(dado: real, proximo: ref no); {especifica o tipo

de no} var lista, p: ref no; valor: real; {lista e p

apontam p/no}Inicio lista nil; { lista recebe nil} leia (valor); {le um dado em coloca

em valor} new(p); { aloca 1 no o valor de p e o

endereco do no} p^.proximo lista; { o componente proximo de p recebe

lista} lista p; { lista recebe o valor da variavel p} p^.dado valor; { ou lista^.dado valor} Fim;

Para incluir um outro nó

(1) new(p);(2) p^.proximo lista;(3) lista p;

Para remover o último nó de uma lista

(1) p lista;(2) lista p^.proximo; {ou lista

lista^.proximo;}(3) dispose(p);Ao remover o último nó dalista, esta voltaráà situação inicialde lista vazia:lista /

Exemplo

Algoritmo para determinar o comprimento de uma lista encadeada.

Algoritmo MedeLista;Tipo no::reg(dado:real; proximo: ref no); Enquanto p^;proximo><

nil FaçaVar lista, p: ref no; valor: real; Inicio INICIO q p;...... p p^.proximo; Se lista = nil Entao execute rotinaerro2 fim; Senao Se lista^.proximo= nil Entao q^.proximo nil; Inicio dispose(p); dispose(lista); Fim; lista nil; ........... Fim FIM. Senao Inicio p lista;

Listas com Descritor

Listas com Descritor

Simplificam a representação das listas encadeadas pois reunem em um só elemento as referências do primeiro e do último elemento da lista chamado “nó descritor” ou líder da lista.

O nó descritor: tipo descritor :: reg (i:

ref nó;

n: int; f:

ref nó);

Neste caso a representação da lista vazia é:

Utilizando listas com descritor

Nesse tipo de lista deve-se criar uma lista vazia, que consiste em:1. Alocar um nó do tipo descritor;2. Tornar suas duas referências nulas; e3. Fazer a variável que indica o início da lista

apontar para o nó.O procedimento ao lado Proc criar (d: ref

descritor) implementa início esta operação: aloque(d); d^.i nil; d^.n 0; d^.f nil; fim

Inserindo um nó à esquerda da lista

Inserimos um nó com um dado valor à esquerda da lista cujo descritor é apontado pela variável d.

Inserindo um nó à direita da lista

Inserimos um nó com um dado valor à direita da lista cujo descritor é apontado pela variável d.

Removendo um nó da esquerda

O procedimento a seguir remove o primeiro nó da lista, se houver, e retorna o dado que o nó removido continha através

do parâmetro valor.Para remover um nóda lista devemospercorrer todos osnós da lista a partirdo primeiro (esq)até atingir o nó dadireita.

Pilhas e Filas

Pilhas e filas

São utilizadas em aplicações onde são impostos critérios para a inserção e retirada de elementos cuja ordem não depende da ordem natural dos valores dos dados. São 2 os critérios mais usados: LIFO “last in first out”: o primeiro a ser

retirado é o último que tiver sido inserido, ex.: pilha de pratos;

FIFO “first in first out”: o primeiro elemento a ser retirado é o primeiro que tiver sido inserido, ex.: fila de banco.

Pilhas

Pilhas

São estruturas essencialmente dinâmicas. Implementamos utilizando sequências. Supondo que os elementos do conjunto são do tipo dado (pilhas de dados), já definido, podemos definir:tipo pilha_seq:: seq dado; var p: pilha_seq; i,j: dado;

Inicialmente a pilha está vazia: p<- <>

Empilhar e Desempilhar

Para inserir um elemento i (empilhar): p <- < i > conc p

Para retirar um elemento (desempilhar): p <- cont p Obs.: o último elemento inserido da pilha é o

primeiro componente da sequencia. Caso a pilha esteja vazia, a retirada de um

elemento não implica em erro pois a continuação da sequência nula é a própria sequência nula.

Acesso ao topo da pilha

Em geral, só se admite acesso ao elemento do “topo” da pilha (o último inserido). Para se obter esse elemento fazemos:Se p =< > entao erro {pilha vazia}senão j<- princ p

Por serem estruturas dinâmicas as pilhas podem crescer e decrescer aleatoriamente durante a execução do programa.

Definindo o tipo pilha

Quando se pode prever o tamanho máximo de uma pilha, é possível implementa-la por meio de registros contendo um n° inteiro e um vetor de dados:tipo pilha_vet :: (topo: int; elementos: vet[1..100] de

dado);var p: pilha_vet; i,j: dado;

Definindo e inicializando uma pilha em Pascal

Inicializando a pilha e empilhando

A inicialização como pilha vazia faz-se por: p.topo <- 0;

Para o empilhamento, devemos verificar se ainda há espaço no vetor para mais um elemento:Se p.topo = 100 entao erro {excesso de

elementos} Senao inicio p.topo <- p.topo + 1; p.elementos[p.topo] <- i; fim

Desempilhando

Para o desempilhamento, verifica-se se a pilha está vazia:Se p.topo = 0 entao nada {a pilha esta vazia} senao p.topo <- p.topo - 1;

Para obter o elemento do topo:Se p.topo = 0 entao erro {a pilha esta vazia} senao j <- p.elementos[p.topo]

Programa para empilhar e desempilhar

Filas

Enquanto Pilhas sofrem inserções e retiradas na mesma extremidade (o topo), as filas exigem acesso às duas extremidades:a) começo - onde é feita a retirada; eb) fim - onde é feita a inserção.

Definição de filas - forma geral:tipo fila_vet :: reg (comeco:int; termino:int; elementos: vet [1..10] de

dado);var f: fila_vet; i,j: dado;

Operações básicas

Inicializaçãof.comeco <- 1;f.termino <- 0;

InserçãoSe f.termino =10 entao erro {excesso de

elementos} Senao inicio f.termino <- f.termino + 1; f.elementos[f.termino] <- i; fim;

Definindo e inicializando filas

Operações básicas

Retirada:Se f.termino < f.comeco entao nada { fila vazia } Senao f.comeco <- f.comeco + 1;

Consulta ao elemento no começo da filaSe f.termino < f.comeco entao erro {fila

vazia} Senao j <- f.elementos[f.comeco];

Representação na memória

Após a inicialização, a fila vazia tem o seguinte aspecto:

A atribuição do valor 1 inicial a f.comeco é para garantir que f.termino < f.comeco notando que se f.comeco = f.termino não indica fila vazia e sim uma fila com somente um elemento. A inserção dos elementos: 26,18,12,9,3,11,4,2,13 faz:

Representando na memória

Havendo 4 retiradas da fila temos:

Como a retirada envolve o incremento de f.comeco nota-se que a fila vai se deslocando da esquerda para a direita do vetor.

Para inserir mais um elemento (17, por exemplo) soma-se 1 a f.termino, o qual passa a conter o índice 10, posição em que colocamos o valor 17. Se agora quisermos inserir mais um valor, isso não será possível (f.termino = 10 indica erro se for tentada uma inserção) o que de certo modo é absurdo, já que as posições 1 a 4 estão livres

Resolvendo inconsistências

Para permitir a reutilização de posições já ocupadas, inserimos mais um componente “f.tamanho” que indica quantos elementos existem na fila no momento. Portanto as operações serão executadas conforme os algoritmos:

Inicialização:f.comeco <- 1;f.termino <- 0;f.tamanho <- 0;


Inserção:Se f.tamanho = 10 entao erro {excesso de

elementos} Senao inicio f.tamanho <- f.tamanho + 1; f.termino <- (f.termino mod 10) + 1; f.elementos[f.termino] <- i; fim;Antes de incrementar f.termino tomamos o resto

de sua divisão pelo n° de elementos do vetor, ex.: para inserir mais um elemento, f.termino será calculado por 10 mod 10 + 1 e o novo elemento será inserido na primeira posição do vetor.


Retirada:Se f.tamanho = 0 entao nada {fila vazia} Senão inicio f.tamanho <- f.tamanho - 1; f.comeco <- (f.comeco mod 10) + 1; fim;

Consulta:Se f.tamanho = 0 entao erro {fila vazia} Senao j <- f.elementos[f.comeco];

Trabalho Individual 1

Desenvolver um programa que seja capaz de avaliar expressões aritméticas inteiras utilizando a estrutura de dados Pilha. Utilizar os operadores: +, -, *, / (div), % (mod), ^ (potência).

Supor que as expressões possuem identificadores contendo somente uma única letra em maiúscula, conforme visto em sala de aula. Seu programa deve possibilitar a leitura de expressões do tipo:

A*B+C/B-A%D^3Obs.: A expressão deve ser corretamente parentizada pelo

usuário antes de ser analisada.

Valor do trabalho: 5.0 pts. Referência Bibliográfica: PEREIRA, S. L. Estrutura de

dados fundamentais: conceitos e aplicações. São Paulo: Erica, 1996.

Trabalho Individual 2Um simulador é um programa que modela o funcionamento de algum fenômeno do mundo real. Ele deve tratar eventos que ocorrem no decorrer do tempo. Para isso, ele implementa um motor de simulação, que gerencia o funcionamento do simulador. A passagem do tempo é implementada através de ciclos. Em cada ciclo o motor de simulação deve: • Gerar eventos aleatoriamente; • Tratar o próximo evento.- Funcionamento de um Simulador de Aeroporto:O aeroporto apresenta 3 pistas que podem ser usadas para pousos ou decolagens. Duas pistas comportam aviões de grande e pequeno porte. A terceira pode ser usada apenas por monomotores (pequeno porte). A escolha da pista a ser usada para pouso ou decolagem é realizada pela torre de controle, que tem como objetivo otimizar o uso das pistas sem provocar colisões ou acidentes por falta de combustível.Colisões ocorrem quando dois aviões usam a mesma pista no mesmoInstante. O problema da falta de combustível será descrito a seguir.A cada instante (ciclo do simulador): o Um número variável de aviões pode chegar ao aeroporto.o Os aviões aguardando pouso têm sua quantidade de combustível decrescida de uma unidade. Esta quantidade é atribuída pelo simulador (aleatoriamente) no instante em que o avião chega no aeroporto.o Cabe à torre de controle gerenciar uma fila de pousos de forma que não ocorram quedas de aviões por falta de combustível.o A torre de controle pode autorizar um pouso ou decolagem em cada pista.Ao final, o simulador deve gerar alguns eventos estatísticos, como por exemplo, aquantidade de aviões que pousaram, quantos decolaram, etc

Árvores

Baseado em: Material do prof. L. Baldochi

http://pt.wikipedia.org/wiki/arvore_binaria

Árvores

Utilizadas em muitas aplicações Modela uma hierarquia entre elementos

Árvore genealógica Diagrama hierárquico de uma organização Modelagem de algoritmos

O conceito de árvores está diretamente ligado à recursão

Árvores

Um conjunto finito de elementos onde um elemento é chamado de raiz os outros são divididos em subconjuntos

disjuntos, onde cada um define uma árvorecada elemento é um nó ou vértice da árvorearcos ou arestas conectam os vértices

Árvores

Uma coleção não vazia de vértices e ramos que satisfazem a certos requisitos

vértice (ou nó): é um objeto simples que pode ter um nome e mais

alguma outra informação associada arco ou aresta (direcionado ou não):

é uma conexão entre dois nós

Representação

Á rvore

E F

B

G H I

C

L M

O

S

P Q R

N

K

J

C

A

Terminologia e Propriedades

cada vértice (exceto a raiz) tem exatamente um antecessor imediato ou pai

cada vértice tem nós sucessores imediatos ou filhos, a não ser:

nós sem filhos terminais ou folhas ou externos

filhos de um mesmo pai - irmãos

nós com pelo menos um filho não-terminais ou internos


caminho em uma árvore:

é uma lista de vértices distintos e sucessivos, conectados por arcos (arestas) da árvore

nó raiz

existe exatamente um caminho entre a raiz e cada um dos nós da árvore

se existir mais de um caminho ou nenhum grafo


grau

é o número de subárvores de um nó

no exemplo: grau de A é 3; de N é 4; de J é 1

qualquer nó é a raiz de uma sub-árvore consistindo dele e dos nós abaixo Á rvore

E F

B

G H I

C

L M

O

S

P Q R

N

K

J

C

A

Árvores

Á rvore (1 )

E F

B C

G

D

A

Árvore (2)

C

G

D

E F

B

A

Árvores

A única diferença entre as duas árvores é a ordem das sub-árvores Uma árvore ordenada é definida como uma

árvore onde as sub-árvores formam um conjunto ordenado

Em uma árvore ordenada define-se o primeiro, segundo e último irmão, de acordo com alguma propriedade

Terminologia

os vértices da árvore estão classificados em níveis

é o número de nós no caminho entre o vértice e a raiz

E F

B

G H I

C

L M

O

S

P Q R

N

K

J

D

A nível da raiz é zero

nível de C é 1

nível de K é 3

nível de um nó = nível de seu pai + 1

nível de P é 5

Terminologia

Altura de uma árvore corresponde ao maior nível

maior distância entre a raiz e qualquer nó

Floresta um conjunto de árvores

se removemos a raiz e os arcos que a ligam às sub-árvores, ficamos com uma floresta

Árvore Binária

É um conjunto finito de elementos que é ou vazio ou composto de três conjuntos disjuntos (aqueles sem elementos em comum)

o primeiro contém um único elemento, a raiz

os outros dois subconjuntos são árvores binárias

as sub-árvores da esquerda e da direitaAs sub-árvores da esquerda ou da direita

podem estar vazias

Árvore Binária

A

B

G

FED

C

H I

UA

B CD

E F

GH I

Árvores Binárias

Considerando que os dois filhos de cada nó interno são ordenados:

o filho da esquerda e

o filho da direita

Cada nó interno tem que ter filho da direita ou da esquerda, sendo que um ou ambos podem ser nós externos

Árvores Binárias

uma árvore binária vazia: consiste de nenhum nó interno e um nó externo

uma árvore binária é uma árvore ordenada, na qual cada nó tem 0, 1, ou 2 filhos cada filho corresponde a uma árvore binária

Árvores Binárias

O número de sub-árvores a esquerda e a direita vazias em uma árvore binária com n nós é de n+1 se n = 1 então 2 subárvores vazias

se n = 2 então 3 subárvores vazias

Se vale para n – 1 então, em uma árvore com n nós uma subárvore vazia foi substituída por um vértice

interno e 2 subárvores vazias o número de subárvores vazias é então:

n -1+2 = n +1

Árvores Binárias

Definição de Árvores

uma árvore é um único nó ou um nó raiz conectado a um conjunto de árvores

Definição de Árvores Binárias

uma árvore binária é um nó externo ou um nó raiz (interno) conectado a esquerda e a direita a árvores binárias

Árvore Binária Estrita

todo nó não folha possui filhos a esquerda e a direita Árvore Binária Estrita

Uma árvore binária estrita com n folhas sempre contém 2n-1 nós


B

F G

D E

C

A


B

F

G 1 G 2

G

D E

C

A


Árvore binária estrita com: 1 folha um nó 2 folhas 3 nós hipótese: n folhas 2n-1 nós

Árvore Binária

Nível: A raiz tem nível 0 A raiz de outro nó é o nível do nó pai +1.

A profundidade de uma árvore é o maior nível para todas as folhas Markeson: raiz tem nível 1 Langsan : raiz tem nível 0

Árvore Binária

Árvore binária cheia de nível d: árvore binária estrita com todas as folhas no nível d

Árvore binária completa de nível d: uma árvore binária estrita com todas as folhas no nível d ou no nível d-1

Árvore Binária Completa

D E

B

H I

F G

C

A

Árvore Binária Cheia

H I

D

J K

E

B

L M

F

N O

G

C

A

Exercício 8

Classificar: A) B)

Árvore Binária

Para muitas aplicações, é importante a relação entre altura e número de nós

Árvore Binária de altura máxima

F

E

D

C

B

A

Para árvores com n nós: altura máxima: cada nó

não folha só possui um filho - ziguezague

sua altura é n-1

Árvore Binária - altura mínima

Seja T’ uma árvore binária de altura mínima Se T’ não é completa retira-se uma folha w de seu último

nível e coloca-se como filho de uma folha de nível superior (acima do penúltimo)

Repete-se a operação até não ser possível mais realizá-la A árvore resultante T’’ é completa

Se a altura de T’’ for menor que a de T’ esta não seria mínima.

T’’ não pode ser de altura maior nenhum nó foi retiradoT’ e T’’ possuem a mesma altura

Árvore Binária - altura mínima

Nível 0 – (somente a raiz) contém um nó Nível 1 – contém no máximo 2 nós..... No nível L - pode conter no máximo 2L nós

Árvore binária cheia de altura d tem exatamente 2L

nós em cada nível 0 L d

Árvore Binária

O total de nós n em uma árvore binária cheia (que seria o máximo) de altura d é a soma do número de nós a cada nível d

n = 20 + 21 + 22 + ..... + 2d = 2j

j=0

n = 2d+1 -1 d = log (n+1) –1

pode-se mostrar também por indução! OBS.: número de folhas de uma árvore cheia com n nós

2d = 2log(n+1)-1 = 2log(n+1) = n+1 2 2


H I

D

J K

E

B

L M

F

N O

G

C

A

Árvore Binária Cheia de altura 3 23+1-1 = 15 nós


É a árvore binária com o máximo de nós para uma dada altura, mas a distância da raiz é pequena

Lema:Lema: Seja T uma árvore binária completa com n>0 nós. Então, T possui altura h mínimo. Além disso, h = log n


Seja T uma árvore binária completa com n nós, então sua altura h = log2n

Seja T’ a árvore obtida pela remoção dos k nós do último nível T’ é cheia já que T só tinha folhas no último e no

penúltimo nível (definição de completa) nós de T’

n’ = n - k = 2d +1 -1 , onde d é a altura de T’


h(T’) = d e h(T) = d+1 d = log2(n’+1) -1

h(T) = log2(n’+1) -1 +1 = log2(n’+1)

e k? (no máximo número de folhas da árvore cheia 2) 1 k n’ +1h(T) = log2(n’+1) = log2(n’ + k) = log2(n)

Exercício 8 a

1. Uma árvore cheia tem 1023 nós. Qual sua profundidade e o número de nós terminais?

Resposta: 9 e 512.2. Uma árvore completa tem 37 nós. Qual sua

profundidade e o número de nós terminais?Resposta: 5 e 19.3. Uma árvore completa tem 37 nós terminais.

Qual sua profundidade e número total de nós?Resposta: 6 e 73.

Representando Árvores Binárias

typedef struct {

int info;

tipo_no * esq;

tipo_no * dir;

} tipo_no;

B C

A

A

B

C


Typedef struct {char info;

tipo_no * esq;

tipo_no * dir;

tipo_no * pai;

} tipo_no

B C

A

A

B

C


Na representação nós externos podem ser NULL ponteiro para o próprio

nó

B C

A

A

B

C


a*b + d - e * (f+ g )

a b

*

f g

+ e

*

-

Representando Florestas

Árvores binárias possuem dois ponteiros em cada nó interno, um para cada filho, e portanto sua representação é imediata

O que fazer para árvores gerais ou florestas, com um número arbitrário de filhos por nó, que requerem um número arbitrário de ponteiros

Representação depende da Aplicação


Se não é necessário caminhar para os níveis de baixo da árvore mas só para os de cima Percorre-se a ávores dos nós terminais para os não

terminais e por último a raiz

B C

AB

A

C


typedef struct {

char info;

tipo_no * filho;

tipo_no * irmão;

} tipo_no

A

B C

D ED E

B C

A


Se é necessário caminhar para os níveis mais altos Empregar uma lista encadeada conectando o nó com

seus irmãos e outra com seus filhos Ao invés de empregar um nó dummy para terminar cada

lista pode-se apontar de volta para seu pai permitindo mover para cima ou para baixo Esses ponteiros para pai tem que estar marcados para

poder ser distingui-los dos ponteiros para irmãos Alternativamente pode-se armazenar o nome do pai de

forma que a busca pára quando o nó for revisitado


Essa representação cada nó possui exatamente dois ponteiros 1 para filho e 1 para um irmão

Onde está a diferença entre essa estrutura e uma árvore binária?? não existe

Visite(p) conteúdo do nó apontado por p

Esquerda(p) ponteiro para o filho da esquerda de

Direita(p) ponteiro para o filho da direita de p

Pai(p) ponteiro para o pai de p

Irmão(p) ponteiro para o irmão de p

eh_esq(p) Retorna true se p é filho da esquerda e se filho da direita

eh_dir(p) Retorna true se p é filho da esquerda e se filho da direita

Operações em Árvores Binárias

Operações em Árvores Binárias

p = cria(x) Cria uma AB com apenas um nó com conteúdo xRetorna o ponteiro para a nova árvore.

resp = filho_esq(p,x) Cria um filho à esquerda do nó apontado por p, comconteúdo x.

Retorna false caso já exista um filho esquerdo e truecaso contário.

resp = filho_dir (p,x) Cria um filho à direita do nó apontado por p, comconteúdo x.

Retorna false caso já exista um filho direito e true

Aplicações Com Árvores Binárias

É uma estrutura útil quando uma de duas decisões devem ser tomadas no decorrer do processo. Encontrar todas as duplicatas em uma lista

de números Uma forma de fazer isso é comparar o

número com todos os que o precedemisto não é uma solução eficiente


Solução: empregar uma árvore binária Armazenam-se os números na árvore de forma a:

O 1º número é armazenado na raiz de uma árvore com apenas um nó interno

Cada um dos próximos números na lista é comparado com a raiz:

• caso seja igual é uma duplicata • caso seja menor, é armazenado na sub-árvore da

direita seguindo-se recursivamente o mesmo procedimento

• caso seja maior, é armazenado na sub-árvore da esquerda seguindo-se recursivamente o mesmo procedimento


14, 18, 4, 9, 7, 15, 3, 5, 17, 4, 20, 9, 5

3

5

7

9

4

17

15 20

18

14

Aplicações com Árvores Binárias

Outra aplicação comum é atravessar a árvore binária, visitando cada nó como sistematicamente visitaremos cada nó?

Operação é trivial para listas lineares

Para árvores, existem diferentes formas de proceder os métodos diferem conforme a ordem em que

se visitam os nós

Atravessando Árvores Binárias

Métodos Pré-ordem:visite a raiz, então visite a subárvore da

esquerda, depois a subárvore da direita Em-ordem ou ordem simétrica: visite a subárvore da

esquerda, então visite a raiz, depois a subárvore da direita

Pós-ordem: visite a subárvore da esquerda, então visite a subárvore da direita, depois a raiz

pré-ordem: - * a b * + f g e

em-ordem: a*b - f+g * e

pós-ordem: a b * f g + e * -


a*b + d - (f+ g ) * e

a b

*

f g

+ e

*

-


Implementação simples dos métodos - recursiva Como se visita uma subárvore de cada vez,

seguindo-se a regra recursiva , cada subárvore é visitada começando pela raiz

Pré-ordem

pre_ordem (pt){

if (pt == NULL) return ();

visite(raiz);pre_ordem (pt->esq);pre_ordem (pt-> dir);

}

em-ordem

em_ordem (pt){


em_ordem (pt->esq);visite(raiz);em_ordem (pt-> dir);

}

Pós-ordem

pos_ordem (pt){


pos_ordem (pt->esq);pos_ordem (pt-> dir);visite(raiz);

}

Exercício 9

Representar, através de uma árvore, a seguinte expressão aritmética: [(a+b)(c+d)/e]-[(f+g)h]

Justificar!

A partir dos procedimentos anteriores montar um programa completo para atravessamento em-ordem


Representação em lista sequencial Cada nó pode receber um número de 1 a N Um nó de número i está na posição i da lista Seus filhos da esquerda e da direita nas posições

2i+1 e 2i+2, respectivamente

Não necessita ponteiros Restringe um tamanho para a árvore Também chamada de representação seqüencial

H(8 )

I(9 )

D(4 )

E(5 )

B(2 )

F(6 )

G(7 )

C(3 )

A(1 )

A B C D E F G H I

Árvore Binária quase Completa

Exercícios 10

1. Implementar os procedimentos pré-ordem, em-ordem e pós-ordem de forma não recursiva

2. Calcular a altura de cada nó de uma árvore binária

Em-ordem

p = raiz;do { /* segue pelo ramo da esq. até NULL */ while (p != NULL) {

push(p); p=p->esq;

} /* verifica se já processou toda árvore */ if (pilha_não_vazia()){ p = pop(); visite(p); p = p->dir;

} } while(pilha_não_vazia() || p != NULL);}

H I

D E

B C

A

Árvore Binária de Busca

Construída de tal forma que, para cada nó: Nós com chaves menores estão na sub-árvore

esquerda Nós com chaves maiores (ou iguais) estão na

sub-árvore direita

A inserção dos nós da árvore deve satisfazer a essa propriedade


Para a busca de uma chave v na árvore binária de busca: Primeiro compare com a raiz

Se menor, vá para a sub-árvore esquerdase maior, para a sub-árvore direita

Aplique o método recursivamente

Exercício 10a

Dos exemplos abaixo quais são árvores binárias de busca:

Sim sim não


2

3 5

4

6 9

8

6


A cada passo, garante-se que nenhuma outra parte da árvore contém a chave sendo buscada

O procedimento pára quando O nó com v é encontrado Senão, chega-se a NULL


busca_arvore_nao_recursivo (v, pt){

do { if (v < pt->info)

pt = pt-> esq; else pt = pt-> dir; }while (pt != NULL) && (v != pt->info);

return(pt);}

Inserindo em Árvore Binária de Busca

Para inserir um nó na árvore: fazer uma busca com insucesso alocar um novo nó é necessário saber por qual nó se chegou a NULL

será o pai do novo nó


2

3 5

4

7

6 9

8

6

Inserção Árvore Binária de Busca

insere_árvore (int valor, tipo_nó * pt){ tipo_nó * pai; do{ pai = pt ;

if (valor < pt->chave) pt = pt ->esq ; else pt = pt->esq;

} while(pt != NULL);if (pt == NULL){

pt = aloca();pt ->chave = valor; pt->esq = NULL; pt->dir = NULL;if (v < pai->chave) pai ->esq = pt ;else pai ->dir = pt ;return(pt);

}}

Inserção Árvore Binária de Busca

A árvore está classificada se percorrida da forma correta (pre, pos ou em-ordem?) as chaves aparecem em ordem se lidas da

esquerda para a direita Podemos ordenar uma sequência como se fosse

uma série de inserções o programa tem apenas os ponteiros para se

preocupar

Remoção em Árvore Binária de Busca

Até então, vimos que a implementação da operação de inserção é simples

A remoção de um elemento já é mais complexa remoção de um nó folha

os ponteiros esquerdo e direito do pai são setados para NULL

se possui apenas um filho o ponteiro apropriado do pai passa a apontar para

o filho se o nó possui dois filhos

se um desses dois filhos não possui filhos, use esse nó para substituir o nó removido


Senão: substituir o valor do nó a ser removido substitua este com o elemento cuja chave é

imediatamente maior (ou menor)

é sempre folha? senão for folha – vá repetindo o procedimento algoritmo?


2

3 5

4

8

7 10

9

6

Removendo 5: basta que o ponteiro a direita de 4 aponte para

NULL


2

3

4

8

7 10

9

6

Removendo 5: basta que o ponteiro a direita de 4 aponte para

NULL


Removendo 3: basta substituir o nó 3 pelo nó 2 continua valendo a regra de formação da árvore

2

3 5

4

8

7 10

9

6


Removendo 3: asta substituir o nó 3 pelo nó 2 continua valendo a regra de formação da árvore

2 5

4

8

7 10

9

6


Removendo 4: basta substituir 4 pelo 5 continua valendo a regra de formação da árvore

2

3 5

4

8

7 10

9

6


Removendo 4: Basta substituir 4 pelo 5 continua valendo a regra de formação da árvore

2

3

5

8

7 10

9

6


Removendo 7 (raiz): substituir o 7 pelo imediatamente maior: 8 – como

determinar? resulta na remoção do elemento de chave 8

2

3 5

4

9

8

12

11

10

7




2

3 5

4

9

8

12

11

10

8




2

3 5

4

9

12

11

10

7


A árvore obtida depende da seqüência de inserção de nós Para que a árvore binária de busca seja completa

completa tem altura mínima o conjunto das chaves deve ser reordenado árvore comum - O (n) árvore completa - O (log n)


Uma árvore binária de busca completa

o conjunto das chaves deve ser re-ordenado sejam so e s n+1 duas chaves fictícias e já inseridas a cada passo inserir em T uma nova chave que

seja de índice médio entre i e j - duas chaves já inseridas


Árvore completa: ótima para a busca quando a freqüência de acesso aos nós é igual

Normalmente estas freqüências são diferentes

É interessante construir uma árvore binária que seja a melhor possível no que diz respeito à busca para freqüências conhecidas

Eficiência da Árvore de Busca

Depende da ordem original dos dados Se o array original está ordenado (ascendente ou

descendente), as árvores resultantes só tem filhos a direita ou a esquerda a inserção do 1o. nó - 0 comparações a inserção do 2o. nó - 2 comparações a inserção do 3o. nó - 3 comparações

2 + 3 +....+n = n*(n+1)/2 -1 Complexidade - O(n2) - para inserir n nós


Se a lista original estiver organizada, e se uma árvore completa (parecida com completa) for se formando:

complexidade da inserção = O( n log n )


12, 8, 17, 4, 26 A árvore é balanceada

4

8

2 6

1 7

1 2

Árvores AVL

Baseado em: Material do prof. D. Lobato http://pt.wikipedia.org/wiki/arvore_binaria

Baseado em: Material do prof. D. Lobato http://pt.wikipedia.org/wiki/arvore_binaria

Árvores AVL

Os algoritmos convencionais podem gerar árvores degeneradas ou ótimas Árvores de crescimento irrestrito

Árvores AVL (Adelson-Velskki & Landis) Árvores de busca binária auto-balanceada Nesse tipo de árvore, al alturas das duas sub-árvores a

partir de cada nó difere no máximo em uma unidade. Mesmo depois de inclusões e exclusões o custo se

mantem O (log n) onde n é o numero de nós Inserções e eliminações podem requerer o

rebalanceamento da árvore, exigindo uma ou mais rotações.

AVL é uma ABB com |h| 1

AVL

Observe as árvores abaixo:Todas armazenam os

Mesmos dados.

Qual delas é a melhor?

E a pior?

No pior caso, quantas

Comparações são

Necesssárias para

Encontrar um elemento

Na árvoce a) e na

Árvore b)?

AVL

Balanceamento:Dizemos que uma árvore está balanceada em altura (ou

profundidade) quando, para cada nó, a diferença entre as alturas de suas sub-árvores é igual a -1, 0 ou 1.

AVL

Árvore não AVL

A mesma árvore após balanceamento por altura, agora AVL

AVL

Fator de equilíbrio de um nó Fe(A) = hEsq – hDir Fe(A) = 2 – 3 = -1 Fe(C) = 2 – 1 = 1

AVL Fe(N) {-1, 0, +1}; N Fe()???

AVL

Fator de equilíbrio dos nós Fe(A) = 2 – 3 = -1 Fe(B) = 1 – 1 = 0 Fe(C) = 2 – 1 = 1 Fe(D) = 0 – 0 = 0 Fe(E) = 0 – 0 = 0 Fe(F) = 1 – 1 = 0 Fe(G) = 0 – 0 = 0 Fe(H) = 0 – 0 = 0 Fe(I) = 0 – 0 = 0

AVL

Calcular o fator de equilíbrio dos nós

AVL

Calcular o fator de equilíbrio dos nós Resposta

AVL

Vantagem da árvore balanceada:

Com base na tabela acima, se tivéssemos 1.048.575 elementos, poderíamos armazená-los em uma árvore binária perfeitamente balanceada com 20 níveis. Em outras palavras, poderíamos localizar um elemento qualquer dentro dessa árvore com apenas 20 comparações.

AVL

O que pode acontecer quando um novo nó é inserido numa árvore balanceada ?

Dada uma raiz r com subárvores L (left) e R (right), e supondo que a inserção deve ser feita na sub-árvore da esquerda. Podemos distriguir 3 casos:

Se hL = hR, então L e R ficam com alturas diferentes mas continuam balanceadas.

Se hL < hR, então L e R ficam com alturas iguais e balanceamento foi melhorado.

Se hL > hR, então L fica ainda maior e balanceamento foi violado.

Exemplo

Dada a árvore:– Inserir o nó 9 ou 11

• Inseridos normalmente – Inserir o nó 3 5 ou 7

• Requer rebalanceamento

AVL

Uma árvore AVL é balanceada quando para cada nó da árvore, a diferença entre as alturas das suas sub-árvores (D e E) não é maior que 1.

Onde não inserir nós??? H->(dir|esq) I->(dir|esq)

Nos dois casos Fe(C) = 3-1= 2

Todas as outraslevam algum | Fe |para além de 1 Tente...

AVL

Inserindo em H ou I, dois casos Em H: Fe(F) = 1, Fe(C) = 2, F(A) = -2 Em I: Fe(F) = -1, Fe(C) = 2, F(A) = - 2

Inserir e depois rotacionar visto ser necessário alguns ajustes, tal que: Continue ABB Continue balanceada

AVL

Rotação simples Ocorre devido ao seu desbalanceamento, uma rotação

simples ocorre quando um nó está desbalanceado e seu filho estiver no mesmo sentido da inclinação, formando uma linha reta.

Rotação dupla Ocorre quando um nó estiver desbalanceado e seu

filho estiver inclinado no sentido inverso ao pai, formando um “joelho”.

AVL

Rotação à direita

Numa árvore binária basta empurrar o nodo N para baixo e para a direita. O filho à esquerda de N o substitui, e o filho à direita do filho à esquerda vem a ser o novo filho à esquerda de N. Segue pseudocódigo:

Seja Y o filho à esquerda de X

Torne X o filho à direita de Y

Torne o filho à direita de Y o filho à esquerda de X.

É interessante observar que as rotações duplas nada mais são que duas rotações simples seguidas, independentes se à direita ou à esquerda.

AVL

Rotação à esquerdaEm uma árvore binária, basta empurrar o nó N para baixo e

para a esquerda. O filho à direita de N o substitui, e o filho à esquerda do filho à direita vem a ser o novo filho à direita de N. Segue pseudocódigo:

· Seja Y o filho à direita de X

· Torne X filho à esquerda de Y

· Torne o filho à esquerda de Y o filho à direita de X.

AVL

Exemplo Rotação Simples (à direita) A altura da sub-árvoce de raiz 4 difere de mais de 1

unidade da de chave 7.

Como a altura da sub-árvore à esquerda de 6 difere de 2 em relação à sua sub-árvore direita, rotaciona-se em torno do 4.

AVL

Exemplo Rotação Simples (continuação)Então 4 passa a ser a nova raiz

A sub-árvore com raiz 6 vira filho direito de 4

5 passa a ser filho esquerdo de 6 Balanceada!

AVL – Procedimentos

Rotação a esquerda ou direita

void roda_dir(ARVORE p){ ARVORE q, temp; q = p->esq; temp = q->dir; q->dir = p; p->esq = temp; p = q;}

8

4

2

3

6

10

p

q

temp

Raíz (2|-2) e filho (1|-1) com o mesmo sinalRotação simples do nó com |Fe| = 2 na direção corretaFe(8) = 3-1 = 2 Fe(4)= 2-1 = 1

8

9

14

q

temp

12

temp

q

p


Rotação a esquerda ou direitavoid roda_dir(ARVORE p){ ARVORE q, temp; q = p->esq; temp = q->dir; q->dir = p; p->esq = temp; p = q;}

8

4

2

3

6

10

p

q

temp


Rotação a esquerda ou direitavoid roda_dir(ARVORE p){ ARVORE q, temp; q = p->esq; temp = q->dir; q->dir = p; p->esq = temp; p = q;} 8

4

2

3

6

10

p


Rotação a esquerda ou direita A esquerda é análogo... Tente!

AVL

Exemplo Rotação Simples (à esquerda)

A altura da sub-árvore de raiz 7 difere de mais de 1 unidade da de chave 3.

AVL - Procedimentos

E aí, o que fazer? Rotacionar “4” para a esquerda Rotacionar “8” para a

direita8

4

2 6

10

5

Raíz (2|-2) com um sinal e filho(-1|1) com outroRotação do nó com |Fe| = 1 na direção corretaRotação do nó que tinha |Fe| = 2 na direção opostaFe(8) = 3 – 1 = 2 Fe(4) = 1 – 2 = -1

AVL - Procedimentos


direita

8

6

4

2 105

AVL

Exemplo rotação dupla Rotação dupla: Se um nó

estiver desbalanceado e seu filho estiver inclinado no sentido inverso ao pai.

Nesse caso faz-se duas rotações simples seguidas!

Seu filho, o 6, está no sentido inverso do 7, seu pai.

AVL

Exemplo rotação dupla à direita:

Rotação simples à esquerda

Rotação simples à direita

AVL

Exemplo rotação dupla à direita: 5 será a nova raiz da sub-árvore

de raiz 7 Como a nova raiz passa a ser o

5, o nó 3 passa a não ser mais filho de 7

Além disso, as arestas de 4 e 6 com 5 são desfeitas

AVL

Exemplo rotação dupla à direita (continuação):As sub-árvores de raizes 3 e 7 se ligam a 5

4 se liga a 3 e 6 se liga a 7 Balanceada!

Exercícios 11

Balancear:

Exercícios 11

Inserir: 5 3 7 10 33 15 17 (pag 66)

Excluir: 3 17

Excluir: 10 (considerando a árvore inicial)

Exercícios 11

Na árvore AVL abaixo: inserir 15, 7 e 28 Excluir 4 e 8

8

6

4

2 105

Árvores B e B+

Árvore B ou B-Tree

É um tipo de árvore muito utilizada em banco de dados e sistema de arquivos. Para inserir ou remover variáveis de um nó, o nó não poderá ultrapassar sua

ordem e nem ser menor que sua ordem dividida por dois. Árvores B não precisam ser rebalanceadas como são freqüentemente as árvores

de busca binária com Árvore AVL. Árvores B têm vantagens substanciais em relação a outros tipos de

implementações quanto ao tempo de acesso e pesquisa aos nós. O criador das árvores B, Rudolf Bayer, não definiu claramente de onde veio o B

das árvores B. Ao que parece, o B vem de balanceamento onde todos os nós da árvore estão em

um mesmo nível. Também é possível que o B tenha vindo de seu sobrenome Bayer, ou ainda do

nome da empresa onde trabalhava Boeing, no Boeing Scientific Research Labs.

Estrutura do Nó

Nós em árvores B, geralmente são representados por um conjunto de elementos apontando para seus filhos.

Alguns autores consideram a ordem de uma árvore B como sendo a quantidade de registros que a página pode suportar.

Outros consideram a ordem como a quantidade de campos apontadores.

Todo nó da árvore tem um mínimo de elementos definido pela sua ordem, que é a metade da ordem, arredondando-se para baixo, caso a árvore seja de ordem ímpar, exceto a raiz da árvore, que pode ter um mínimo de um registro. Por exemplo, os nós de uma árvore de ordem 5, devem ter, no

mínimo 5 / 2 registros, ou seja, dois registros. A quantidade de filhos que um nó pode ter é sempre a quantidade de

registros do nó mais 1 (V+1). Por exemplo, se um nó tem 4 registros, este nó terá

obrigatoriamente 5 apontamentos para os nós filhos.

Inserção

Primeiro, pesquise a posição onde este nó será incluído. Então, insira o valor dentro do nó.

Se nenhum nó ficou errado, acima ou abaixo da ordem div 2, o processo é terminado.

Se algum nó ficar acima da ordem, dividimos o nó, o valor central do nó dividido sobe para a posição do pai, continuando assim recursivamente por toda a árvore.

Se o nó estourar na raiz, então é criado um novo nó raiz ((podendo ter um único elemento)).

Exclusão

Primeiro, busque um valor a ser excluído. Então, remova-o de dentro de um nó.

Se nenhum nó teve problema, o processo é terminado. Se algum nó estiver errado, então há duas possibilidades:

Se o nó ao lado do nó errado pode transferir um ou mais de seus nós filho ao nó atual, então o nó atual voltará ao normal. Após ter atualizado os valores da separação do pai e dos dois filhos, o processo é terminado.

Se o nó ao lado do nó errado não tem um filho extra porque está no limite mais baixo, então ambos os nós serão fundidos em um único nó. Continuando até que o nó atual esteja normal.

Exercícios 12

Na árvore B da figura:– Inserir 5 e 6 na árvore da figura

– Remover 2 e 3.

Árvores-B

Objetivo principal Minimizar o número de acessos ao disco para recuperar um

registro

25

10 20 30 40

2 5 7 8

13 14 15 18

22 24 26 27 28

32 35 38

41 42 45 46

Árvores-B

Devido a organização, altura da árvore logmN

Ordem da árvore-B: mNúmero de chaves: N

Altura da árvore AVL melhor caso Aplicações

Sistema de arquivos: ponteiros para clusters

Árvores-B

Como representar em C?#define ORDEM 2#define TAMANHO (ORDEM*2)-1

typedef struct Pagina *PonteiroPagina;typedef struct { int chave; PonteiroPagina p;} item;

typedef struct { int m; // numero de itens na pagina PonteiroPagina p0; item e[TAMANHO];} Pagina;

Busca em árvores-B

Busca binária na página atual Não encontrando

Ki < x < Ki+1 com 1 i < m

Continuar a busca na página pi

Km < x

Continuar a busca na página pm

x < K1

Continuar a busca na página p0

Página atual == NULL não existe

Busca em árvores-B

Implemente uma função de busca em árvore-B com o protótipo Int Pesquisa (int, PonteiroPagina, int *)

Busca em árvore-B

Possível implementação

int Pesquisa(int x, PonteiroPagina pag, int *achou) { int i; *achou = 0 if (pag == NULL) return 0; i = 1; while ((i <= TAMANHO) && (x > pag->e[i-1].chave)) i++; if (x == pag->e[i-1].chave) { *achou = 1; return x; } else if (x < pag->e[i-1].chave) Pesquisa (x, pag->e[i-1].p, achou); else Pesquisa (x, pag->e[i].p, achou);}

Inserção em árvores-B

A criação de uma árvore-B é trivial Inserir é que é o problema...

Respeitar as limitações de ocupação dos nós não-raiz (entre m e 2m)!

Crescimento “das folhas para a raíz” Se folhas não acomodarem, aumentar a altura da árvore e

manter folhas no mesmo nível


Considerar uma árvore-B ordem 2 Inserir as chaves abaixo na ordem dada

20, 40, 10, 30, 15, 35, 7, 26, 18, 22


Inserir as chaves abaixo na ordem dada 20, 40, 10, 30, 15, 35, 7, 26, 18, 22

20



20 40



10 20 40



10 20 30 40

15

10, 15, 20, 30, 40 Mediana é promovida



20

10 15 30 40



20

10 15 30 35 40



20

7 10 15 30 35 40



20

7 10 15 26 30 35 40



20

7 10 18 15 26 30 35 40

22

22, 26, 30, 35, 40 Mediana é promovida



20 30

7 10 15 18 22 26 35 40

Exercícios 13

Na árvore anterior, continuar inserindo chaves 5, 42, 13, 46, 27, 8, 32, 38, 24, 45, 25 Cuidado com as divisões de página!

Remoção em árvores-B

Algumas situações podem ocorrer Chave na página folha

Remover se não violar condições Chave em página intermediária

Trocar a chave pelo seu sucessor in-ordem da D E (maior chave menor que a chave) em uma página folha e remova a chave na folha

Se ocorrer violação (página com menos de m chaves), ajustar Balancear (página vizinha) Intercalação (acaba removendo uma página)


Algumas situações podem ocorrer Ajuste de violação

Troca com intercalação à direita Troca com intercalação à esquerda Balanceamento à direita/esquerda se número de chaves das

páginas mais pai 2m+1 Intercalação com direita/esquerda, se número de chaves das

páginas mais pai 2m


Eliminar chave 24

22 34

6 11 14 19 24 26 38 42 46

5 2m+1 Balanceamento

26, 34, 38, 42, 46 Promove mediana!


Eliminar chave 24

E para eliminar 26???

22 38

6 11 14 19 26 34 42 46

4 2m Intercalação


Eliminar chave 26

E para eliminar 22???

22

6 11 14 19 34 38 42 46

Exercício 14

Considerando inseridas todas as chaves da árvore B do exercício anterior, mostrar as arvores intermediárias das exclusões de 20, 25, 38 e 40.

Árvore B+

Uma árvore B+ é uma variação da árvore B. Representa a ordenação de dados de uma maneira que permita uma

inserção e remoção eficiente de elementos. É um índice dinâmico de multi-níveis com ligações máximas e mínimas no

número de chaves em cada nodo. Os sistemas de arquivos NTFS para o Microsoft Windows, o sistema de

arquivos ReiserFS para Unix, o XFS para IRIX e Linux, e o JFS2 para AIX, OS/2 e Linux, usam este tipo de árvore.

Numa árvore-B+, contrastando com uma árvore-B, todos dos dados são gravados nas folhas.

Os nodos internos contêm apenas chaves e apontadores da árvore. Todas as folhas estão no mesmo nível mais baixo. Os nodos das folhas também estão ligados entre si como uma lista para efetuar consultas facilmente.

Conceitos

O número máximo de apontadores num registro é chamado de ordem da árvore B+.

O número mínimo de chaves por registro é metade do número máximo de chaves. Por exemplo:

Se a ordem de uma árvore B+ for n+1, cada nodo (exceto o da raiz) deverá ter entre (n+1)/2 e n chaves.

Se n for um número primo, o número mínimo de chaves pode ser (n+1)/2 ou (n-1)/2, mas terá de ser o mesmo em toda a árvore.

Um exemplo simples de uma árvore B+ ligando as chaves 1-7 aos valores de dados d1-d7.

Notar a lista ligada (em vermelho) permitindo

uma atualização ordenada rápida.

Conceitos

O número de chaves que poderá ser indexado ao usar a árvore B+ é uma função da ordem da árvore e da sua altura.

Para uma árvore B+ de ordem n com uma altura h: O número máximo de nodos é nh O número mínimo de chaves é 2(n / 2)h − 1.

A árvore B+ foi descrita pela primeira vez em "Rudolf Bayer, Edward M. McCreight: Organization and Maintenance of Large Ordered Indices. Acta Informatica 1: 173-189 (1972)".

Uma extensão de uma árvore B+ é chamada de Árvore B# que usa a estrutura da árvore B+ e adiciona mais restrições.

Exercícios 15

1. Inserir as chaves abaixo em uma árvore B+ na ordem dada 20, 40, 10, 30, 15, 35, 7

2. Excluir 30 e 15

Variantes de árvores-B

Árvores-B* Todas as chaves estão nas folhas, e nós intermediários são,

apenas, índices Folhas encadeadas para permitir acesso seqüencial Usada em bancos de dados para aumentar a concorrência

Inserção em página segura com até 2m registros Remoção em páginas seguras com pelo menos m registros

Árvores Rubro-Negras É um tipo de árvore criada em 1972 com o nome de

árvores binárias simétricas. Assim como as árvores binárias comuns, as árvores rubro-

negras possuem um conjunto de operações (tais como inserção, remoção e busca), porém são geralmente mais eficientes devido ao fato de estarem sempre balanceadas.

Este balanceamento se dá justamente pela característica que dá nome à árvore, que vem de um bit extra em cada nó que determina se este é "vermelho" ou "preto" dentro do conjunto de regras que rege a árvore.

Além deste bit, cada nó também conta com os campos dados do nó, filho esquerdo do nó, filho direito do nó e pai do nó.

Definição do nó

struct node *grandparent(struct node *n){

if ((n != NULL) && (n->parent != NULL))return n->parent->parent;

elsereturn NULL;

} struct node *uncle(struct node *n){

struct node *g = grandparent(n);if (g == NULL)

return NULL; // No grandparent means no uncleif (n->parent == g->left)

return g->right;else

return g->left;}

Regras

Uma árvore rubro-negra estará sempre balanceada pois segue o seguinte conjunto de regras:– cada nó da árvore possui um valor – a cada novo nó inserido na árvore obedecerá o

esquema de menor para o lado esquerdo e maior para o lado direito.

– a cada nó é associada uma cor: vermelha ou preta.

– o nó raiz é sempre preto. – nós vermelhos que não sejam folhas possuem

apenas filhos pretos. – para cada nó, todos os caminhos do nó até

qualquer folha passa pelo mesmo número de nós pretos.

Regras - Inserção

A cada vez que uma operação é realizada na árvore, testa-se o conjunto de propriedades descritos anteriormente e são efetuadas rotações e ajuste de cores até que a árvore satisfaça todas estas regras.

Uma rotação é uma operação realizada na árvore para garantir seu balanceamento. Na rubro-negra pode ser feita a direita e a esquerda, onde são alterados os ponteiros dos nós rotacionados.

Ao inserir um elemento em uma árvore rubro-negra, esta é comparada com os elementos e alocada em sua posição conforme a regra 2. Ao inserir um elemento ele é sempre da cor vermelha (exceto se for o nodo raiz). A seguir a árvore analisa o antecessor da folha. Se este for vermelho será necessário alterar as cores para garantir a regra 5.

Regras - Inserir

Existem três casos para corrigir as cores após uma inserção:

Caso 1: O tio do elemento inserido é VERMELHO. Caso 2: O tio do elemento inserido é PRETO e o

elemento inserido é um filho da direita. Caso 3: O tio do elemento inserido é PRETO e o

elemento inserido é um filho da esquerda.

O nó raiz

Ao inserir o primeiro nó na árvore (raiz) este será preto.

voidinsert_case1(struct node *n){

if (n->parent == NULL)n->color = BLACK;

elseinsert_case2(n);

}

Inserção caso 2


if (n->parent->color == BLACK)return; /* Tree is still valid */

elseinsert_case3(n);

}

Inserção caso 3


struct node *u = uncle(n), *g;

if ((u != NULL) && (u->color == RED)) {n->parent->color = BLACK;u->color = BLACK;g = grandparent(n);g->color = RED;insert_case1(g);

} else {insert_case4(n);

}}

Inserção caso 4


struct node *g = grandparent(n);

if ((n == n->parent->right) && (n->parent == g->left)) {rotate_left(n->parent);n = n->left;

} else if ((n == n->parent->left) && (n->parent == g->right)) {rotate_right(n->parent);n = n->right;

}insert_case5(n);

}

Inserção caso 5


struct node *g = grandparent(n);

n->parent->color = BLACK;g->color = RED;if ((n == n->parent->left) && (n->parent == g->left)) {

rotate_right(g);} else {

/* * Here, (n == n->parent->right) && (n->parent == g->right). */rotate_left(g);

}}

Exemplo

Inserir 11,2,14,1,7,13,15,5,8

Exemplo

Inserir 11,2,14,1,7,13,15,5,8

O nó raiz é sempre preto!

Exemplo

Inserir 11,2,14,1,7,13,15,5,8

Na inserção o nó de menor valor vai para o lado esquerdo e o de maior para o lado direito.

Exemplo

Inserir 11,2,14,1,7,13,15,5,8

Ao inserir um elemento ele é sempre da cor vermelha, exceto o nó raiz.

Exemplo

Inserir 11,2,14,1,7,13,15,5,8

Exemplo

Inserir 11,2,14,1,7,13,15,5,8

Na inserção o nó de menor valor vai para o lado esquerdo e o de maior para o lado direito.

Exemplo

Inserir 11,2,14,1,7,13,15,5,8

Após inserir um elemento da cor vermelha, a árvore analisa o antecessor da folha. Se este for vermelho será necessário alterar as cores para garantir a regra 6 (nós vermelhos que não sejam folhas possuem apenas filhos pretos).

Exemplo

Inserir 11,2,14,1,7,13,15,5,8

14 é o irmão de 2 e é vermelho.O preto pode ser transferido do pai a seus dois filhos vermelhos (o pai, em seguida, toma a cor vermelha), sem afetar a contagem do nodo preto por qualquer caminho.

Exemplo

Inserir 11,2,14,1,7,13,15,5,8

Desde que o pai 11 é a raiz, o processo pode ser interrompido neste ponto porque...

Exemplo

Inserir 11,2,14,1,7,13,15,5,8

A raiz sempre deve ser preta, sem afetar a contagem de nodos pretos em qualquer caminho.

Exemplo

Inserir 11,2,14,1,7,13,15,5,8

Exemplo

Inserir 11,2,14,1,7,13,15,5,8

O irmão 1 de 7 é vermelho, deve-se puxar o preto do 2 para baixo.

Exemplo

Inserir 11,2,14,1,7,13,15,5,8

O preto pode ser transferido de um pai de seus dois filhos vermelhos (o pai, em seguida, toma a cor vermelha), sem afetar o numero de nodos pretos de qualquer caminho. No entanto, uma dupla violação vermelha poderá ser resultante dessa mudança.

Exemplo

Inserir 11,2,14,1,7,13,15,5,8

Exemplo

Inserir 4

Exemplo

Inserir 4

O irmão 8 do 5 é vermelho, puxar o preto para baixo a partir de 7 do conjunto atual de 2

Exemplo

Inserir 4

O preto pode ser transferido de um pai para seus dois filhos vermelhos (o pai, em seguida, toma a cor vermelha), sem afetar a contagem do caminho do nodo preto. No entanto, uma dupla violação vermelha poderá ocorrer. Portanto, definir 2 para a raiz da sub-árvore.

Exemplo

Inserir 4

O pai 11 de 2 é do lado direito e seu filho 7 é vermelho e está à direita: girar no sentido anti-horário em torno de 2, fixando no 7

Exemplo

Inserir 4

Desde que 11 é pai à direita de 2, se o filho vermelho 7 ficou a esquerda, pode-se girar o 11 preto e então mudar de volta para eliminar a dupla violação vermelha (isto é explicado com mais detalhes no Próximo passo).

Exemplo

Inserir 4

Então, nós usamos este passo para configurar essa possibilidade por rotação no sentido anti-horário em torno de 2. O resultado é vermelho 7 à esquerda de 11 e vermelho preto 2, à esquerda do vermelho 7.

Exemplo

Inserir 4

O pai 11, de 7 está do lado direito e seu filho 2 é vermelho à esquerda: girar no sentido horário em torno de 11

Exemplo

Inserir 4

Desde que 11 é preto pai, à direita do vermelho 7 e vermelho 2 é filho e está à sua esquerda, uma rotação no sentido horário por 11 vai subtrair um negro do caminho através da 2. Mas este desequilíbrio pode ser corrigido por troca de cores, de 11 e 7.

Exemplo

Inserir 4

Ao fazê-lo (na próxima etapa), também elimina a dupla violação vermelha.

Exemplo

Inserir 4

Mudança de cores.O 2 é filho vermelho à esquerda de 7 tem um nó preto contar que é muito baixo por 1. Trocando as cores entre os atuais e seu filho negro à direita (11) elimina a conta do déficit e da dupla violação vermelho. O nodo preto à direita do filho atual não é afetado.

Exemplo

Inserir 4

Regras - Remoção

Existem dois tipos de remoção em uma árvore: De acordo com a remoção efetiva, com as

operações de rotação e alteração de cor, remove-se o nodo e estabelece-se as propriedades da árvore.

De acordo com a remoção preguiçosa, marca-se um nodo como removido, mas efetivamente não o retira. Sendo desta maneira nenhuma alteração é efetuada na árvore, porém são necessários novos mecanismos de busca e inserção para que reconheçam o nodo como "ausente".

Exercício 16

Excluir 7

universidade federal de itajubá mestrado em ciências e tecnologia da informação prof. dr....

Documents