BCC101 – Matemática Discreta Lecture 15 - CS 1813 Discrete Math, University of Oklahoma 4/18/2017 BCC101 – Matemática Discreta Indução / Recursão Indução Estrutural

Sequências, Listas, Strings Sequências ou listas são fundamentais em computação. Toda estrutura discreta pode ser descrita como uma sequência de caracteres: Números decimais : 1010230824879 Números binários : 0111010101010111 Textos. Por exemplo, este documento Programas de computador Padrões da natureza DNA Proteinas Linguagens de programação

Sequências, Listas, Strings Notação: [a] representa o tipo (ou conjunto) das listas de elementos de um dado tipo a. Ex: [2,5,23] :: [Int] [‘a’, ‘b’, ‘c’, ’d’] :: [Char] [(2,’a’), (9,’d’)] :: [(Int,Char)] [[‘a’, ‘b’], [‘c’], []] :: [[Char]]

Sequências, Listas, Strings DEF: O tipo [a] pode ser definido recursivamente do seguinte modo: [] :: [a] se x :: a e xs::[a] então (x:xs) :: [a] Ex: [1,2,3] = 1:[2,3] = 1:(2:[3]) = 1:(2:(3:[]))

Funções sobre listas - length A função length :: [a] -> Int computa o comprimento (ou número de elementos) de uma lista Ex: length [1,6,10,3,9] = 5 length [‘u’,’m’] = 2 length [[‘a’, ‘b’], [‘c’], []] = 3 Q: Defina length recursivamente

Funções sobre listas - length R: Base: length [] = 0 Recursão: length (x:xs) = 1 + length(xs)

Funções sobre listas – sum e product sum :: [Int] -> Int computa a soma de todos os valores da lista. Ex: sum [10,7,8] = 25 Q: Defina sum recursivamente product :: [Int] -> Int computa o produto de todos os valores da lista. product [10,7,8] = 150 Q: Defina product recursivamente

Funções sobre listas – sum, product R: sum [] = 0 sum (x:xs) = x + length(xs) product [] = 1 product (x:xs) = x * length(xs)

Funções sobre listas – concat (++) :: [a] -> [a] -> [a] computa a concatenação das duas listas dadas como argumento. Ex: [3,7] ++ [10,7,8] = [3,7,10,7,8] Q: Defina (++) recursivamente

Funções sobre listas – concat R: [] ++ ys = ys (x:xs) ++ ys = x : (xs ++ ys) Q: Prove, por indução, que length(xs++ys) = length(xs) + length(ys)

Funções sobre listas – reverse reverse :: [a] -> [a] retorna o reverso da lista dada. Ex: reverse [10,7,8] = [8,7,10] Q: Defina recursivamente reverse

Funções sobre listas – reverse reverse [] = [] reverse (x:xs) = reverse xs ++ [x] reverse xs = reverse’ xs [] reverse’ [] ys = ys reverse’ (x:xs) ys = reverse’ xs (x:ys) Q: Prove, por indução, que reverse(reverse xs) = xs

Funções sobre listas – maximum maximum :: [Int] -> Int computa o máximo dentre os valores da lista. maximum [10,7,8] = 10 Q: Defina recursivamente maximum

Funções sobre listas – maximum maximum [x] = x maximum (x:xs) = max(x,maximum(xs)) max (x,y) = if x >= y then x else y Q: Prove, por indução, que para toda lista xs e todo elemento x de xs, maximum(xs) ≥ x Use como hipótese que max(x,y) ≥ x ∧ max(x,y) ≥ x

Celebridade Uma celebridade em um grupo de n pessoas é alguém que não conhece ninguém mas é conhecido por todas as demais pessoas. O problema aqui é determinar quem é a celebridade, fazendo apenas perguntas com resposta SIM ou NÃO. Supondo que todo grupo de n>0 pessoas possui uma celebridade, qual é a maneira mais eficiente de determinar quem é a celebridade?

Celebridade Suponha que o grupo de n pessoas é representado como uma lista. Suponha que x `knows` y retorna true se x conhece y, ou false caso contrário celebridade [x] = x celebridade [x,y] = if x `knows` y then y else x celebridade [x,y:xs] = if x `knows` y then celebridade(y:xs) else celebridade (x:ys)

Ordenação Diversas aplicações em computação requerem ordenação de uma sequência de dados. Função de ordenação de listas: sort :: [a] -> [a] Existem diversos métodos para ordenação de listas. Vamos ver a definição recursiva de alguns deles.

Ordenação por inserção insort :: [a] -> [a] insort [] = [] insort (x:xs) = insert x (insort xs) insert :: a -> [a] -> [a] insert y [] = [y] insert y (x:xs) = if y<x then (y:x:xs) else x:(insert y xs)

Ordenação por seleção selsort :: [a] -> [a] selsort [] = [] selsort xs = min : selsort ys where (min,ys) = getmin xs splitmin :: [a] -> (a,[a]) getmin [x] = (x,[]) getmin (x:xs) = if x<min then (x,(min:ys)) else (min, (x:ys))

Quicksort qsort :: [a] -> [a] qsort [] = [] qsort (x:xs) = qsort les ++ [x] ++ qsort gts where les = [y | y <- xs, y < x] gts = [y | y <- xs, y > x]

Árvores Árvore diagrama ou grafo sem ciclos. estrutura de dados na qual diretamente abaixo de cada elemento estão associados um ou mais elementos.

Árvores definição indutiva: um nodo, juntamente com uma sequência de árvores Terminologia subárvore — um nodo, juntamente com sua sequência de árvores raiz — o nodo que, com suas subárvores, constitui a árvore toda nodo interior — nodo com um sequência não vazia de subárvores folha — nodo que tem uma sequência vazia de subárvores ramo — linha conectando um nodo a suas subárvores (no diagrama) árvore binária — árvore na qual cada nodo tem no máximo 2 subárvores

Para que servem árvores Aplicações computacionais que usam árvores Bancos de dados, compiladores, jogos, sistemas especialistas, processadores de texto, sistemas operacionais, … Árvores de Pesquisa Estruturas que facilitam a recuperação de dados Cada nodo armazena uma chave para recuperação de um dado associado à chave Uma chave é um elemento de algum tipo ordenável Subárvores são organizadas de maneira a tornar a pesquisa mais rápida Busca ingênua: procurar sequencialmente toda a árvore Tempo de pesquisa proporcional ao número de items Árvore de pesquisa — tempo de busca proporcional a log(n), onde n = número de items

Árvore de Pesquisa Binária – diagrama 5120 PDA Cam 9605 Palm Pilot 4403 HotSync 4878 Palm Games 7268 Zip Drive 8444 Audio System 6876 Intellimouse 3663 Net Hub 6419 128MB RAM 1425 56K Modem 2088 LaserJet 1143 InkJet Chave – ordered Data – anything Cada nodo armazena chave/dado Subárvore esquerda contém todas as chaves menores Subárvore direita contém todas as chaves maiores Folhas apenas marcam os limites da árvore: nenhuma chave/dado Para encontrar um item comece pela raiz pesquise à esq., se menor pesquise à dir., se maior 12 items: 4 passos, no maximo

Árvore de Pesquisa Binária Leaf – construtor de folha data SearchTree key dat = Leaf | Node key dat (SearchTree key dat) (SearchTree key dat) Node – construtor de árvore não vazia chave dado subárvore esq (chaves menores) subárvore direita (chves maiores) Parâmetros de tipo — key, dat key — pode ser, por exemplo, Int (ordenável) dat — pode ser qualquer tipo Exemplo s :: SearchTree Int (String, Float) s é uma SearchTree tipo de key – Int (ex: catalogo ordenado numericamente) tipo de dat – par contendo um string String (descrição de um produto description) e um Float (preço)

Obtendo um dado da Árvore de Pesquisa Encontrado ou Não Encontrado A chave procurada pode ou não ocorrer na árvore de pesquisa O que fazer se ela não ocorre Retornar algum indicador de não ocorrência Usar o tipo Maybe para isso data Maybe a = Just a | Nothing Exemplo, item encontrado Just (2088, “LaserJet”) Indica não encontrado

Obtendo um dado da Árvore de Pesquisa getItem :: Ord key => SearchTree key dat -> key -> Maybe (key, dat) getItem (Node key dat smaller bigger) searchKey= if searchKey  key then (getItem smaller searchKey) else if searchKey  key then (getItem bigger searchKey) else (Just(key, dat)) getItem Leaf searchKey = Nothing