Föreläsning 9: Prioritetskö, trappa (heap), heapsort, Reguljära uttryck

Transkript

1 Föreläsning 9: Prioritetskö, trappa (heap), heapsort, Reguljära uttryck Prioritetskö, Trappa (heap) Heapsort Bästaförstsökning Implementation Reguljära uttryck Prioritetskö När man poppar en stack får man ut det senast inpushade. När man tar ut något ur en vanlig kö får man tvärtom ut det som legat längst tid i kön. Man skulle kunna se det som att det som stoppas in tidsstämplas och att det påstämplade talet ger prioriteten för uthämtning. I en prioritetskö stämplas en prioritet på varje objekt som stoppas in och vid uthämtning får man objektet med högst prioritet. En abstrakt prioritetskö kan ha följande anrop. put(x); Stoppa in x med påstämplad prioritet p. x=get(); Hämta det som har högst prioritet. isempty(); Undersök om prioritetskön är tom. isfull(); Undersök om prioritetskön är full. Om det man vill stoppa in i prioritetskön är ett tal kan man använda talet självt som prioritet och bara skriva put(x). Hur den då skiljer sej från en stack och från en vanlig kö ser man av följande exempel. pq.put(1); pq.put(3); pq.put(2); x = pq.get(); // x blir 3 En kö hade skickat tillbaka det först instoppade talet 1; en stack hade skickat tillbaka det senast instoppade talet, 2; prioritetskön skickar tillbaka det bästa talet, 3. I denna prioritetskö betraktar vi största talet som bäst - vi har en så kallad maxprioritetskö. Det finns förstås också minprioritetsköer, där det minsta talet betraktas som bäst. Prioritetsköer har många användningar. Man kan tänka sej en auktion där budgivarna stoppar in sina bud i en maxprioritetskö och auktionsförrättaren efter "första, andra, tredje" gör pq.get() för att få reda på det vinnande budet. För att han ska veta vem som lagt detta bud behöver förstås fler uppgifter lagras. 1(8)

2 Trappa pq.put(person); // person är ett objekt med bud, budgivarens // namn och adress m.m. winner = pq.get(); //budgivaren med högst bud Den bästa implementationen av en prioritetskö är en trappa, (eng heap), som är en hakvektor trappsteg tolkad som binärträd. Roten är trappsteg[1] (vi använder inte trappsteg[0]), dess båda söner är trappsteg[2] och trappsteg[3] osv. Allmänt gäller att trappsteg[i] har sönerna trappsteg[2*i] och trappsteg[2*i+1]. Trappvillkoret är att pappa är bäst, dvs varje tal ligger på två sämre tal. Ett nytt tal läggs alltid in sist i trappan. Om trappvillkoret inte blir uppfyllt, dvs om det är större än sin far, byter far och son plats och så fortgår det tills villkoret uppfyllts. Det här kallas upptrappning och kan i värsta fall föra det nya talet hela vägen upp till toppen, alltså trappsteg[1]. Man plockar alltid ut det översta talet ur trappan och fyller igen tomrummet med det sista talet i trappan. Då är inte trappvillkoret uppfyllt, så man får byta talet och dess störste son. Denna nedtrappning upprepas till villkoret åter gäller. Både put och get har komplexitet log N om trappan har N element. Nackdelen med trappan är man måste bestämma hakvektorns storlek från början. Heapsort Om man stoppar in N tal i en trappa och sedan hämtar ut dom ett efter ett får man dom sorterade. Komplexiteten för denna heapsort blir O(N log N), alltså av lika god storleksordning som quicksort. Visserligen är quicksort lite snabbare, men heapsort har inte quicksorts dåliga värstafallsbeteende, och så kan ju en heap användas till andra saker än sortering också. class Heapsort{ Mio mio = new Mio(); public static void main(string[] args){ Heap heap = new Heap(16); System.out.println("Skriv några ord (retur avslutar)"); while (!mio.eoln()) heap.put(mio.getword()); while (!heap.isempty()) System.out.println(heap.get()); 2(8)

3 Bästaförstsökning Labb 4 behandlar problemet att finna kortaste vägen från FAN till GUD. Man har då ett problemträd med FAN som stamfar, på nivån därunder sönerna MAN, FIN, FAT osv, på nästa nivå fans sonsöner osv. Om man lägger sönerna i en kö kommer man att gå igenom problemträdet nivå för nivå, alltså breddenförst. Om man byter kön mot en stack blir sökningen djupetförst. Med en prioritetskö får man bästaförstsökning, dvs den mest lovande sonen prioriteras och får föda söner. Exempel 1: Sök billigaste transport från Teknis till Honolulu. All världens resprislistor finns tillgängliga. Problemträdets poster innehåller en plats, ett pris och en faderspekare. Överst i trädet står Teknis med priset noll. Sönerna är alla platser man kan komma till med en transport och priset, till exempel T-centralen, Man söker en Honolulupost i problemträdet. Med breddenförstsökning får man den resa som har så få transportsteg som möjligt. Med bästaförstsökning får man den billigaste resan. Exempel 2: Sök effektivaste processen för att framställa en önskad substans från en given substans. All världens kemiska reaktioner finns tillgängliga med uppgift om utbytet i procent. Problemträdets poster innehåller substansnamn och procenttal. Överst i trädet står utgångssubstansen med procenttalet 100. Sönerna är alla substanser man kan framställa med en reaktion och utbytet, till exempel C2H5OH, 96%. Med en maxprioritetskö får man fram den effektivaste process som leder till målet. Implementation Här följer en rudimentär implementation av en heap med Comparable-element. Vad händer om man försöker stoppa in ett element i en redan full Heap? Eller plocka ut något ur en tom Heap? Ge förslag på hur man ska hantera dessa fall. class Heap { /** En heap implementerad med en trappa (hakvektor tolkad som binärträd) */ private int size; /* Aktuell storlek */ private int maxsize; /* Maximal storlek */ private Comparable[] heap; /* Trappan - en hakvektor där heapens element lagras */ /** Konstruktor - ange trappans maxstorlek */ public Heap(int maxsize) { this.size=0; this.maxsize=maxsize; heap = new Comparable[maxsize+1]; /** Returnerar true om inga element finns i heapen */ public boolean isempty() return size==0; /** Returnerar true om inga fler element får plats i heapen */ public boolean isfull() return size==maxsize; 3(8)

4 /** Lägger in ett nytt element i heapen */ public void put(comparable data){ if (!isfull()) { size=size+1; heap[size]=data; int i=size; while (i>1 && heap[i/2].compareto(heap[i])<0) { byt(i/2, i); i=i/2; /** Plockar ut det största (med compareto) elementet ur heapen */ public Comparable get(){ if (!isempty()){ Comparable data=heap[1]; heap[1]=heap[size]; size=size-1; int i=1; do { int max=maxindex(i); if (heap[i].compareto(heap[max])<0) byt(i,max); i=max; while (i<=size/2); return data; else return null; /** Hjälpmetod, byter plats på element a och b */ private void byt(int a, int b) { Comparable tmp=heap[a]; heap[a]=heap[b]; heap[b]=tmp; /** Hjälpmetod, returnerar index för största sonen */ private int maxindex(int i){ if (2*i+1>size) return 2*i; if (heap[2*i].compareto(heap[2*i+1])>0) return 2*i; else return 2*i+1; Reguljära uttryck Reguljära uttryck används när man vill söka efter en viss text i en textmassa. Ett reguljärt uttryck består av tecken och metatecken som tillsammans utgör ett sökmönster. Ett exempel på en vanlig användning av reguljära uttryck är filöppningsdialogen i en ordbehandlare. I Figur 1 visas en filöppningsdialog i ordbehandlaren Microsoft Word. I fältet Files of type räknas ett antal reguljära uttryck upp: *.doc, *.dot, *.htm osv. I dialogfönstret visas enbart filer vars filnamn matchar något av dessa reguljära uttryck. Exempelvis matchar filen Ett_word_dokument.doc sökmönstret *.doc. 4(8)

5 Figur 1 Filöppningsdialog i Word, wordfiler Övriga filer i den öppnade mappen visas inte. För att se övriga filer i mappen måste ett annat sökmönster användas. Se Figur 2. Figur 2 Filöppningsdialog i Word, alla filer 5(8)

6 Olika syntaxer för reguljära uttryck Det reguljära uttrycket *.doc i Figur 1 består av ett metatecken * samt fyra vanliga tecken.doc. Med metatecken avses att tecknet inte matchar sig självt utan skall tolkas särskilt. I det här fallet kommer * att matcha en teckenföljd. Det reguljära uttrycket kommer således att matcha filnamn bestående av en teckenföljd, vilken som helst, avslutat med ändelsen.doc. Exempel: Ett_word_dokument.doc Ett_till_dokument.doc Ett_.doc_dokument.doc I andra sammanhang, t.ex. när man använder programmeringsverktyg som java, lex, eller perl, har metatecknet * en liknande men annan tolkning. Javas klass Pattern tolkar * som inga eller flera av föregående och kan appliceras på ett enskilt tecken eller ett helt reguljärt uttryck. Reguljära uttryck i java Sedan JDK 1.4 stöder java programmering med reguljära uttryck. Nedan följer ett utdrag ur dokumentationen för klassen Pattern: ( ) A regular expression, specified as a string, must first be compiled into an instance of this class. The resulting pattern can then be used to create a Matcher object that can match arbitrary character sequences against the regular expression. All of the state involved in performing a match resides in the matcher, so many matchers can share the same pattern. A typical invocation sequence is thus Pattern p = Pattern.compile("a*b"); Matcher m = p.matcher("aaaaab"); boolean b = m.matches(); A matches method is defined by this class as a convenience for when a regular expression is used just once. This method compiles an expression and matches an input sequence against it in a single invocation. The statement boolean b = Pattern.matches("a*b", "aaaaab"); is equivalent to the three statements above, though for repeated matches it is less efficient since it does not allow the compiled pattern to be reused. ( ) Character classes [abc] a, b, or c (simple class) [^abc] Any character except a, b, or c (negation) [a-za-z] a through z or A through Z, inclusive (range) Greedy quantifiers X? X, once or not at all X* X, zero or more times X+ X, one or more times ( ) 6(8)

7 Predefined character classes. Any character (may or may not match line terminators alba: d.v.s. retur, EOF) \d A digit: [0-9] \D A non-digit: [^0-9] \s A whitespace character: [ \t\n\x0b\f\r] \S A non-whitespace character: [^\s] \w A word character: [a-za-z_0-9] \W A non-word character: [^\w] ( ) Praktiska exempel I klassen String finns två användbara metoder som använder reguljära uttryck. matches Metoden matches testar om en sträng matchar mot ett reguljärt uttryck. Med hjälp av det kan man tillåta användare att mata in extra mellanslag m.m. class Regex { public static void main(string[] args) { if (" Alexander ".matches(" *Alexander *") ) System.out.println ("\" Alexander \" matches \" *Alexander *\""); if (" alexander ".matches(" *[A a]lexander *") ) System.out.println ("\" Alexander \" matches \" *[A a]lexander *\""); if ("12/3-03".matches("\\d?\\d/\\d?\\d *- *\\d\\d")) System.out.println ("12/3-03\" matches \"\\d?\\d/\\d?\\d *- *\\d\\d\""); ger utskriften " Alexander " matches " *Alexander *" " alexander " matches " *[A a]lexander *" "12/3-03" matches "\d?\d/\d?\d *- *\d\d" 7(8)

8 split En annan praktiskt metod är split som kan dela upp en sträng i flera delsträngar. Notera att tecknet (eller det reguljära uttrycket) man delar med avseende på, försvinner. String mening = "Jag heter Olle"; String [] ord = mening.split(" "); for (int i = 0; i < ord.length; i++) { System.out.println(ord[i]); Jag ger resultatet heter Olle men hade det stått String [] ord = mening.split("e"); blir resultatet Jag h t r Oll 8(8)