V15 ALP1 Abstrakte Datentypen 2013 - inf.fu-berlin.de · Abstrakt Datentypen ALP I: Margarita...

ALP IAlgebraische Datentypen

undAbstrakte Datentypen

Prof. Dr. Margarita Esponda

SS 2013

Funktionale Programmierung

Abstrakt Datentypen

ALP I: Margarita Esponda, 12. Vorlesung, 26.11.2012

Algebraischen Datentypen für BäumeBeispiel:

data SBTree = L | N SBTree SBTree

L N LL

Abstrakt Datentypen

Einfache binäre Bäume

data SBTree = L | N SBTree SBTree deriving Show

type Depth = Integer

genSBTree :: Depth -> SBTree

genSBTree 0 = L

genSBTree (n+1) = N (genSBTree n) (genSBTree n)

genSBTree 3 ⇒

Ein balancierter Baum

mit der eingegebenen

Tiefe wird erstellt.

L LL L L L L L

N N N N

Abstrakt Datentypen

nodes :: SBTree -> Integernodes L = 1nodes (N leftT rightT) = 1 + nodes leftT + nodes rightT

nodes (genSBTree 3) ⇒ 15

Berechnung aller Knoten des Baumes

L LL L L L L L

N N N N

Abstrakt Datentypen

depth :: SBTree -> Integerdepth L = 0depth (N lt rt) = (max (depth lt) (depth rt)) + 1

Tiefe des Baumes

depth N (N (N L L) L) (N L L) ⇒ 3

Abstrakt Datentypen

joinTrees :: SBTree -> SBTree -> SBTreejoinTrees leftTree rightTree = N leftTree rightTree

joinTrees leftT rightT ⇒ N leftT rightT

leftT rightT

NleftT rightT

Abstrakt Datentypen

balanced :: SBTree -> Boolbalanced L = Truebalanced (N lt rt) = (balanced lt) && (balanced rt) && depth lt == depth rt

balanciert balanciert nicht balanciert

Abstrakt Datentypen

Beispiel:

data Tree = Leaf Int | Node Int Tree Tree | Nil

13 34 63 95

Algebraischer Datentyp für Binäre Suchbäume

Die gespeicherte Information

ist sortiert.

Operationen für Binäre Suchbäume

data BSTree a = Nil | Node a (BSTree a) (BSTree a) deriving ( Show, Eq )

-- findet das kleinste Element

smallest:: (Ord a) => BSTree a -> asmallest (Node x Nil _) = x

smallest (Node x leftTree _) = smallest leftTree

13 34 63 95

Algebraische Datentypen für Binäre Suchbäume

Algebraischer Datentyp für Binäre Suchbäume

data BSTree a = Nil | Node a (BSTree a) (BSTree a)

deriving ( Show, Eq )

-- findet das größte Element

biggest:: (Ord a) => BSTree a -> a

biggest(Node x _ Nil) = x

biggest(Node x _ rightTree) = biggest rightTree

-- spiegelt einen Baum

mirror:: (Ord a) => BSTree a -> BSTree a

mirror Nil = Nil

mirror (Node x xl xr) = Node x (mirror xr) (mirror xl)

ALP I: Margarita Esponda, 12. Vorlesung, 26.11.2012 23

Traversierung binärer Bäume

Preorder: Wurzel – linker Unterbaum – rechter Unterbaum

Inorder: linker Unterbaum - Wurzel – rechter Unterbaum

Postorder: linker Unterbaum – rechter Unterbaum - Wurzel

Levelorder: von oben nach unten in jeder Ebene von links

nach rechts

Baumtraversierung bedeutet, alle Knoten des Baumes in einer bestimmten Reihenfolge zu besuchen.

Traversierung binärer BäumeInorder Linker Unterbaum - Wurzel - Rechter Unterbaum

B E G J

JHG IB D FCA E

Traversierung von Binärbäumen

-- verwandelt einen sortierten Baum in eine sortierte Liste

inOrder :: (Ord a) => BSTree a -> [a]

inOrder Nil = []

inOrder (Node x ltree rtree) = inOrder ltree ++ x : inOrder rtree

-- verwandelt einen Baum in eine ListepreOrder :: (Ord a) => BSTree a -> [a]preOrder Nil = []preOrder (Node x ltree rtree) = x : preOrder ltree ++ preOrder rtree

B E G J

JGI HD A EBF C

Algebraische Datentypen

Binärbäume

Baumstrukturen

AVL-Bäume

Red-Black-Bäume

B-Bäume

ausgeglichene Bäume

einfachste

Beispiele:

Die wichtigste Voraussetzung für die effiziente Verwaltung von

Datenmengen mit Hilfe von Bäumen ist, dass die Bäume balanciert

Suchen

search :: (Ord a) => a -> BSTree a -> Bool

search _ Nil = False

search k (Node x ltree rtree) | k==x = True

| k<x = search k ltree

| otherwise = search k rtree

3 9 15

Nil Nil Nil Nil Nil Nil

3 9 15

Nil Nil Nil Nil Nil Nil

Einfügen11

3 9 15 23

Nil Nil Nil NilNil Nil

NilNilNil Nil

3 9 15 23

Nil NilNil Nil

NilNilNil Nil

Nil Nil

Einfügen

insert :: (Ord a) => a -> BSTree a -> BSTree a

insert a Nil = Node a Nil Nil

insert a (Node x ltree rtree)

| a<x = Node x (insert a ltree) rtree

| otherwise = Node x ltree (insert a rtree)

-- findet das kleinste Element

smallest (Node x Nil _) = x

smallest (Node x leftTree _) = smallest leftTree

-- findet das größte Element

biggest(Node x _ Nil) = x

biggest(Node x _ rightTree) = biggest rightTree

Minimum und Maximum

13 34 63 95

Der ersteKnoten, derkeine linkenKinder mehrhat, beinhaltetdas kleinsteElement.

MaximumMinimum

Löschen

list2Tree [] = Nil

list2Tree (x:xs) = insert x (list2Tree xs)

remove _ [] = []

remove y (x:xs) | y==x = xs

| otherwise = x:(remove y xs)

delete a Nil = Nil

delete a tree = list2Tree(remove a (preOrder tree))

mit "Brute force"

Nachfolger

13 34 63 95

17 468

Minimum

1. Fall

Es gibt einen rechten Unterbaum.

Nachfolger53

13 34 63 95

17 468

2. Fall

Maximum

Es gibt keinenrechten Unterbaum.

Wie können wir nach oben laufen?

Delete-Operation ( Löschen )

1. Fall

Löschen eines Knotens ohne Kinder

2. Fall

Löschen eines Knotens mit nur einem Kind

13 34 63 95

LöschenLöschen eines Knotens mit zwei Kindern3. Fall

13 34 63 95

17 468

13 34 63 95

17 468 32

Der Nachfolger von 27 ist das Minimum des rechten Unterbaumes.

Der Knoten, den man löschen möchte, wird durch seinen Nachfolger ersetzt.

Das Minimum ist entweder ein Blatt oder hat maximal ein rechtes Kind.

LöschenLöschen eines Knotens mit zwei Kindern

13 34 63 95

17 468

Wir brauchen eine join-Funktion, die aus zwei Kinder-Bäumen einen baut.

13 34 63

17 468

Löschen

delete :: (Ord a) => a-> BSTree a-> BSTree a

delete x Nil = Nil

delete x (Node y ltree rtree)

| x < y = Node y (delete x ltree) rtree

| x == y = join ltree rtree

| x > y = Node y ltree (delete x rtree)

……

etwas besser

Join-Funktion

join :: (Ord a) => BSTree a-> BSTree a-> BSTree a

join xtree Nil = xtree

join xtree ytree = Node e xtree ntree

(e, ntree) = splitMin ytree

-- splitMin :: BSTree a -> (a, BSTree a)

splitMin (Node x Nil tree) = (x, tree)

splitMin (Node x ltree rtree) = (f, Node x ntree rtree)

(f, ntree) = splitMin ltree

Probleme mit einfachen binären Suchbäumen

balancierter Binärbaumnicht

balancierter Binärbaum

13 34 63 95

17 46 13930

-- für arithmetische Ausdrücke

data Expr = Lit Int | Add Expr Expr | Sub Expr Expr | Mult Expr Expr

eval :: Expr -> Int

eval (Lit n) = n

eval (Add x y) = eval x + eval y

eval (Sub x y) = eval x - eval y

eval (Mult x y) = eval x * eval y

eval (Mult (Add (Lit 3) (Lit 4)) (Lit 3)) => 21

Haskell Typsystem

Monomorphe Funktionen Der Datentyp wird genau durch die Signatur bestimmt

Beispiel:

asciiCode :: Char -> Int

Polymorphe Funktionen Typvariablen in der Signatur lassen beliebige Datentypen zu

Beispiel:

length :: [a] -> [a]

Einschränkung von Typen

Mit Hilfe von vordefinierten Typ-Klassen können polymorphe

Funktionen mit Einschränkung definiert werden

Beispiel: equalList :: Eq a => [a]->[a]->Bool

nur für Datentypen mit Gleichheitsoperator

add2List:: Num a => [a] -> a -> [a]

add2List xs y = map (+y) xs

nur numerische Typen mit definierten

arithmetischen Operationen

Verwendung eines Kontextes

Einige vordefinierte Typ-Klassen

Show, Readanzeigbar oder lesbar

(a → String), (String → a) show, read

Eq vergleichbar (==), (/=)

Ord sortierbar compare, (<), (>), (<=), (>=), min, max, ..

Enum aufzählbar succ, pred, [..]

Num allgemeine Zahlen (+), (-), (*), negate, abs

Integral ganzzahlig mod, div, quot, rem

Fractional Kehrwert-Funktion (/), recip,...

Klassenname Eigenschaften Funktionen

Typ-Anpassung

Explizites Type-Casting muss stattfinden

fromIntegral (mod 3 2) + 1.5

In Haskell ist Typ-Anpassung für numerische Werte wie in

anderen Programmiersprachen nicht erlaubt.

Beispiel: mod 3 2 + 1.5

Fehler:<interactive>:1:10: Ambiguous type variable `t' in the constraints: `Fractional t' arising from the literal `1.5' at <interactive>:1:10-12 `Integral t' arising from a use of `mod' at <interactive>:1:0-6 Probable fix: add a type signature that fixes these type variable(s)

Typ-KlassenTypen werden durch die Operationen, die auf ihren Werten definiert werden sollen, beschrieben.

Class Num a where

(+) :: a -> a -> a

(*) :: a -> a -> a

(-) :: a -> a -> a

Typklassen sind abstrakte

Schnittstellen, weil keine

Implementierung vorgegeben

Instanzen von Typ-Klassen

instance Num Int

x+y = primAdd x y

neg x = primNegateInt x

Mit einer Instanz-Deklaration definieren wir, welche Typen zu

welchen Typ-Klassen gehören.

Vordefinierte primitive Funktionen

instance Eq Char where

x == y = ord x == ord y

Der Instanz-Typ einer Klasse muss die vorgeschriebenen Operationen einer Typ-Klasse implementieren.

Implementierung: instance (Eq a) => Eq [a] where

(==) [] [] = True

(==) [] (x:xs) = False

(==) (x:ys) [] = False

(==) (x:xs) (y:ys) = x == y && xs == ys

data Menge a = Menge [a]

instance (Eq a) => Eq (Menge a) where

Menge xs == Menge ys = subset xs ys && subset ys xs

subset :: Eq a => a -> a -> Bool

subset xs ys = all (’elem’ ys) xs

instance (Ord a) => Ord (Menge a) where

Menge xs <= Menge ys = subset xs ys

Subklassen

class (Eq a, Show a) => Num a where

(+), (-), (*) :: a -> a -> a

negate :: a -> a

abs, signum :: a -> a

fromInteger :: Integer -> a

-- Minimal complete definition:

-- All, except negate or (-)

x - y = x + negate y -- Default-Definitionen

negate x = 0 - x

Klassen dürfen andere Klassen umfassen

Mehrere Oberklassenclass Enum a where

fromEnum :: a -> Int

toEnum :: Int -> a

class Num a where

(+) :: a -> a -> a

neg :: a -> a

class (Enum a, Num a) => Integral a where

quot, rem, div, mod :: a -> a -> a

quotRem, divMod :: a -> a -> (a, a)

even, odd :: a -> Bool

toInteger :: a -> Integer

toInt :: a -> Int

Integral erbt die Operationen von Enum und Num und fügt noch weitere Operationen hinzu. Ausprägungen von Integral müssen folglich auch Ausprägungen von Enum und Num sein.

Klassenhierarchie

Eq Show

FloatingIntegral

FractionalRealEnum

NumOrd

Standard

Klassenhierarchie

Prelude

Abstrakte Datentypen

Konkrete Datentypen• konkrete Darstellung der Information

innerhalb einer Sprache

• Listen, Bäume usw.

DatentypenAbstrakte Datentypen• definiert durch die Operationen

unabhängig von einer konkreten

Darstellung des Datentyps.

Abstrakte Datentypen

-sind Datentypen, die durch die auf ihren Werten

erlaubten Operationen definiert sind und dessen

Implementierung den Nutzern des Typs

verborgen (Datenkapselung) ist

- in Haskell werden abstrakte Datentypen mit

Hilfe des Modul-Konzepts implementiert

Module in Haskell

Ein Haskell-Modul ist eine Datei mit folgender Struktur:

module <Name> (<Exportliste>) where

• Nur die Datentypen und Funktionen, die in

<Exportliste> angegeben werden, sind nach außen

sichtbar.

• Wenn <Exportliste> weggelassen wird, sind alle

Definitionen automatisch nach außen sichtbar.

Module in Haskell

module Stapel

(Stapel, push, pop, top, createStack, isEmpty, show)

createStack :: Stapel a

isEmpty :: Stapel a -> Bool

push :: a-> Stapel a -> Stapel a

pop :: Stapel a -> Stapel a

top :: Stapel a -> a

data Stapel a = Empty | S a (Stapel a)

Module in Haskellmodule Stapel . . . . . . createStack = Empty

isEmpty Empty = True isEmpty _ = False

push x s = S x s

pop Empty = error "pop from an empty stack ..." pop (S _ s) = s

top Empty = error "top from an empty stack ..." top (S x _) = x

module Menge (Menge, emptySet, isEmpty, inSet, insertSet, list2Set,

subSet, (\\), (|||), (&&&), powerSet )

data Menge a = Menge [a]

instance Eq a => Eq (Menge a) where

(==) s1 s2 = subSet set1 set2 && subSet s2 s1

instance (Show a) => Show (Menge a) where

Abstrakte Datentyp für Mengen

module Menge . . . .

emptySet :: (Menge [Int])

isEmpty :: Eq a => Menge a -> Bool

inSet :: Eq a => a -> Menge a -> Bool

(|||) :: Eq a => Menge a -> Menge a -> Menge a

(\\) :: Eq a => Menge a -> Menge a -> Menge a

(&&&) :: Eq a => Menge a -> Menge a -> Menge a

subSet :: Eq a => Menge a -> Menge a -> Bool

powerSet :: Eq a => Menge a -> Menge (Menge a)

emptySet = Menge []

isEmpty (Menge []) = True

isEmpty _ = False

inSet x (Menge ys) = elem x ys

-- Vereinigung von zwei Mengen

(|||) (Menge (x:xs)) m = insertSet x ((Menge xs) ||| m)

(|||) (Menge []) m = m

-- Differenzmenge

(\\) (Menge xs) m = Menge [x|x<-xs, not(inSet x m)]

-- Schnittmenge

(&&&) (Menge xs) m = Menge [x|x<-xs, (inSet x m)]

subSet (Menge []) _ = TruesubSet _ (Menge []) = FalsesubSet (Menge (x:xs)) m = (inSet x m) && (subSet (Menge xs) m)

powerSet (Menge xs) = Menge powerMenge where powerMenge = map Menge (powerList xs)

powerList :: [a] -> [[a]]powerList [] = [[]]powerList (x:xs) = (powerList xs) ++ (map (x:) (powerList xs))

V15 ALP1 Abstrakte Datentypen 2013 - inf.fu-berlin.de · Abstrakt Datentypen ALP I: Margarita...

Documents

Transcript of V15 ALP1 Abstrakte Datentypen 2013 - inf.fu-berlin.de · Abstrakt Datentypen ALP I: Margarita...

ORACLE und IBM DB2 Datentypen - twiedmann.de · ORACLE und IBM DB2 Datentypen 2/27 Thomas Wiedmann n+1 Jahre Problemlösungen in der Softwareentwicklung Seit „vielen“ Jahren Projekte

Algorithmen und Programmieren II Konzepte imperativer und ...¼hrung_ALP2.pdf · ALP II: Margarita Esponda, 1. Vorlesung, 12.4.2012 Inhalt 3 1. Konzepte imperativer Programmierung

Agenda für heute, 8. Juni, 2006 Strukturierte Variablen: RecordsStrukturierte Variablen: Records Kombiniertes Strukturieren Bitmap-Dateien Datentypen:

Kapitel 3: Variablen, Datentypen und Operatoren (Teil 1) · Programmieren in C 3. Variablen, Datentypen und Operatoren Bernd Schürmann Datentypen § Initialisierung von Variablen

Datentypen in der Programmiersprache C - Schwerpunkt ...+c_ws0809.17-11-2008... · Ganzzahl Datentypen 2-er Komplement-Repräsentation von vorzeichenbehafteten Ganzzahlen • Feststellung:

Besser PHP programmieren - Amazon S3...Datentypen in PHP 27 1 2 3 4 5 6 7 8 9 2 Datentypen und -konvertierung If it doesn't fit, use a bigger hammer. – Miles O’Brian, Star Trek

1 Kapitel 5: Von Datenstrukturen zu Abstrakten Datentypen 5.1 Zur Erinnerung: Datenstrukturen in Pascal Listenverarbeitung in Pascal 5.2 Abstrakte Datentypen.

Elementare Datentypen - Uni Bremenroefer/pi1help/2.pdf · Einführung in die Programmierung mit Java 38 Universität Bremen Ganzzahlige Datentypen Zahlensysteme Dezimal, es gibt die

Agenda für heute, 9. Juni, 2005 Direkte FilezugriffeDirekte Filezugriffe Textfiles Bitmap-Dateien Datentypen: Mengen.

Modulkatalog Bachelor Maschinenbau - tu-berlin.de · Struktogramme. Programmiersprache: wahlweise FORTRAN95 oder C ( Datentypen, Kontrollstrukturen, Funktionen, Felder, Dateioperationen)

V3 ALP1 Tupel List 2013 - inf.fu-berlin.de · absC ( real, img ) = sqrt( real*real + img*img ) Prof. Dr. Margarita Esponda ... Der Stammbaum einer Drohne 8 13 Drohne Mutter 1 Großeltern

Datentypen in Python - Beuth Hochschule für Technik Berlinpublic.beuth-hochschule.de/.../WeisPythonDatentypen.pdf · DatentypenZahlenStringsTupelListenDictonariesMengenDateien Datentypen

Algorithmen und Programmieren II Einführung in Python (Teil 3)w3.inf.fu-berlin.de/lehre/SS12/ALP2/slides/V4_Python_Funktionen_AL… · ALP II: Margarita Esponda, 3. Vorlesung, 19.4.2012-Funktionen,

Agenda für heute, 12. Mai, 2005 ProzedurenProzeduren Funktionsprozeduren Prozedurparameter Lokale und globale Variablen Datentypen: Ordinaltypen.

Anweisungen und Datentypen Folie 1 Uwe Lämmel Einführung in die Programmierung Anweisungen und Datentypen Uwe Lämmel Fakultät für Wirtschaftswissenschaften.

Abstrakte Datentypen - informatik.hu-berlin.de · PI2 Sommer-Semester 2007 Hans-Dieter Burkhard 1 Abstrakte Datentypen Implementation Prototypen Spezifikation Formale Beschreibungen

Datentypen & Aufzählungen in Faktor-IPS · 2009. 9. 30. · Einleitung Datentypen & Aufzählungen in Faktor-IPS Jan Ortmann (Dokumentversion 137) Einleitung Dieser Artikel erläutert

Algorithmen und Programmieren II Einführung in Python … · Funktionen in Python ALP II: Margarita Esponda, 3. Vorlesung, 19.4.2012 3 Funktionen Funktionen sind das wichtigste Konzept

Dynamische Datentypen Destruktor, Copy-Konstruktor, Zuweisungsoperator, Dynamischer Datentyp, Vektoren.

1 Kapitel 2: Grundelemente von Programmiersprachen 2.1 Syntaktische Elemente 2.2 Typsysteme 2.2.1 Einfache Datentypen 2.2.2 Zusammengesetzte Datentypen.

V3 ALP1 Tupel List 2013 - inf.fu-berlin.de · absC ( real, img ) = sqrt( realreal + imgimg ) Prof. Dr. Margarita Esponda ... Der Stammbaum einer Drohne 8 13 Drohne Mutter 1 Großeltern