Javas inbyggda datastrukturer

Javas inbyggda datastrukturer Java innehåller ett antal inbyggda datastrukturer. De är alla baserade på gränssnitten Collection och Map som finns i java.util. Detta är dokumenterat i Skansholm kapitel 19 ( 15 i gamla upplagan) Collection definierar följande viktigare metoder: add(o) Lägger in objektet o i samlingen. Vissa samlingar kräver unika element och då läggs de bara in en gång. AddAll(s) Lägger in alla element som finns i samlingen s clear() tar bort alla element contains(o) undersöker om objektet o finns i samlingen containsall(s) undersöker om alla objekt i samlingen s finns. equals(s) jämför med samlingen s. Lika om samma antal element och samma element isempty() undersöker om tom iterator() returnerar en Iterator för att genomlöpa samlingen remove(o) tar bort objektet o removeall(s) tar bort alla element som finns i samlingen s retainall(s) tar bort alla element utom de som som finns i samlingen s size() antal element toarray() gör en array med alla element toarray(a) fyll i arrayen a med alla element som har samma typ som elementen i a 1 2 Utgående från detta definierar vi sedan ett antal nya gränssnitt. Detta beror på att vi klassar samlingarna i typerna List och Set. En lista är en ordnad sekvens av element, ett element kan förekomma flera gånger i samlingen. En mängd är en samling som inte behöver vara ordnad och där varje element förekommer högst en gång. Vi har då gränssnitten List och Set. Vidare finns också gränssnittet SortedSet som beskriver sorterade mängder. Det är då byggt på gränssnittet Set. De senare gränssnitten är en utvidgning av de tidigare på så sätt att flera metoder införs. Det finns sedan ett antal implementationer av dessa: Vector, ArrayList, LinkedList, HashSet, TreeSet, en sorts array en lista implementerad i en array en lista med länkade noder en hashtabell ett sorterad träd Vitsen med att ha gränssnitt är av vi själva kan implementera dessa om vi så önskar. Alla dessa har en konstruktor med en Collection som parameter som kan konvertera en existerande samling till en ny sorts samling. Alla implementerar dessutom gränssnittet Serializable vilket betyder att samlingarna kan sparas i en datafil och läsas tillbaka intakt igen. 3 4

Förutom gränssnitten finns också en klasscollections med ett antal statiska metoder som kan vara användbara. min(s), minsta värdet i samlingen (om det finns) max(s), största värdet fill(l,o), lägger o i alla element i listan l ncopies(l,o), skapar en lista med n st kopior av o copy(till, från), kopierar en lista till en annan (som måste finnas och vara tillräckligt stor) sort(l), sorterar en lista Förutom de metoder som finns i gränssnittetcollection definierar gränssnittetlist följande metoder: add(k,o), skjut in objektet o på plats k i listan addall(k,s), alla objekten i s läggs in på plats k i listan get(k), hämta objekt på plats k indexof(o), ger index för objekt o i listan lastindexof(o), som ovan, söker från slutet listiterator(), ger en listiterator remove(k), tar bort element på plats k set(k,o), ersätter element på plats k med o sublist(i,j), ger en dellista med element i till j-1 5 6 Eftersom Vector är en lista kan vi då göra följande: import java.util.*; public class Vtest public static Vector v = new Vector(); public static void main(string [] args) // testa inläggning for (int i=0; i < 10; i++) v.add(new Integer(i)); // add i Collection // kolla for (int i=0; i < v.size(); i++) System.out.print(v.get(i) + " "); // lägg in först for (int i = 0; i < 10; i++) v.add(0,new Integer(i)); // kolla for (int i=0; i < v.size(); i++) System.out.print(v.get(i) + " "); // skapa en ny vektor Vector v2 = new Vector(v.subList(1,5)); for (int i=0; i < v2.size(); i++) System.out.print(v2.get(i) + " "); // ta bort första elementet v.remove(0); for (int i=0; i < v.size(); i++) System.out.print(v.get(i) + " "); // ta bort element 3-6 v.sublist(3, 7).clear(); for (int i=0; i < v.size(); i++) System.out.print(v.get(i) + " "); // lägg in v2 i v v.addall(1,v2); for (int i=0; i < v.size(); i++) System.out.print(v.get(i) + " "); // Gör en lista av vektorn LinkedList l = new LinkedList(v); for (int i=0; i < l.size(); i++) System.out.print(l.get(i) + " "); // min & max System.out.println(Collections.max(l)); System.out.println(Collections.min(l)); // leta System.out.println(v.indexOf(new Integer(2))); System.out.println(v.lastIndexOf(new Integer(2))); 7 8

Utskrift: 0 1 2 3 4 5 6 7 8 9 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 8 7 6 5 7 12 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 8 7 6 1 0 0 1 2 3 4 5 6 7 8 9 8 8 7 6 5 7 6 1 0 0 1 2 3 4 5 6 7 8 9 8 8 7 6 5 7 6 1 0 0 1 2 3 4 5 6 7 8 9 9 0 Eftersom vi kan använda en Iterator så kan också göra på detta viset (sist i förra programmet): for (Iterator i = l.iterator(); i.hasnext();) System.out.print(i.next() + ); ger 8 8 7 6 5 7 6 1 0 0 1 2 3 4 5 6 7 8 9 9 10 Eftersom detta är listor kan vi istället använda en ListIterator. Den är lite duktigare än sin kompis. Innehåller metoderna Kan man testa så här: for (int i=0; i < v.size(); i++) System.out.print(v.get(i) + ); next(), previous(), hasnext(), hasprevious(), nextindex(), previousindex(), add(o), remove(), set(o), ger nästa element ger föregående element kollar om det finns fler element kollar om det finns element framåt ger index för nästa element ger index för föregående element lägg in på aktuell plats ta bort aktuellt elements byt ut aktuellt element ListIterator lt = v.listiterator(); // stega framåt for (int i = 0; i < 5; i++) lt.next(); lt.set(new Integer(-3)); // byt ut // flytta fram 2 steg lt.next(); lt.next(); lt.remove(); // ta bort // backa 3 steg lt.previous(); lt.previous(); lt.previous(); lt.add(new Integer(32)); // lägg in for (int i=0; i < v.size(); i++) System.out.print(v.get(i) + ); 8 8 7 6 5 7 6 1 0 0 1 2 3 4 5 6 7 8 9 8 8 7 32 6-3 7 1 0 0 1 2 3 4 5 6 7 8 9 11 12

Som du såg använde vi en LinkedList i exemplet, det är en dubbellänkad lista som implementerar gränssnittet List. Utöver dessa metoder har vi ytterligare ett antal metoder definierade i en sådan lista. Se Skansholm. Ett binärt sökträd är en mängd (ett Set). Det är dessutom sorterat (SortedSet). En sådan har några fler metoder än de som finns i Collection: first(), minsta elementet last(), största elementet headset(toe), en sorterad delmängd med alla element mindre än toe tailset(frome), en sorterad delmängd med alla element större än eller lika med frome subset(frome, toe), delmängd med element i angivet intervall comparator(), get jämföraren (null om den saknas) 13 14 En sorterad mängd kräver att du kan sortera på något sätt. En del objekt har naturlig ordning som exempelvis String, Integer, Date mfl, men de flesta har ingen naturlig ordning. Då kan man själv implementera Comparable eller alternativt en Comparator. Alla mängder tillåter att man i konstruktorn specificerar en ordnare. En naturlig ordning behöver inte vara en önskvärd ordning. Exempelvis sorteras å, ä och ö fel i klassen String. Det beror på att den sorterar efter amerikanska regler. Vill man ha nån annan ordning så måste man skapa en egen sorterare. Ett exempel på en sorterare är klassen Collator. Den kan sortera strängar efter nationella regler. Den kan också programmeras till att hantera stora/små bokstäver på lite olika sätt. För att få den att sortera efter svenska regler skapar man först ett lokaliseringsobjekt. Sedan skapar man en jämförare med hjälp av detta. Locale l = new Locale( sv, SE ); Collator co = Collator.getInstance(l); Nu kan vi göra TreeSet words = new TreeSet(co); och vi får ett träd som kan sortera strängar efter svenska regler. 15 16

Exempelvis på detta vis: import java.util.*; import java.text.*; import java.io.*; import extra.*; Character.isLetter((char) c)) s = s + (char) r.readchar(); if (s.length() == 0) return null; else return s; public class TextAnalys // detta är ett program. övar lite, testa om ord som // åke, östen och sånt sorteras rätt public static void main(string [] arg) String word; Collator co = Collator.getInstance(new Locale("sv","SE")); co.setstrength(collator.primary); TreeSet words = new TreeSet(co); // ExtendedReader is a Skansholm class // specify sorter ExtendedReader r = ExtendedReader.getFileReader(arg[0]); // read one word at a time add it to the tree while ((word = nextword(r))!= null) words.add(word.touppercase()); // print all words for (Iterator i = words.iterator(); i.hasnext();) Std.out.println(i.next()); public static String nextword(extendedreader r) String s = ""; int c; // skip nonletters while ((c = r.lookahead())!= -1 &&!Character.isLetter((char) c)) c = r.readchar(); // get the letters while ((c = r.lookahead())!= -1 && Detta program läser en fil, tar fram ord och lägger in dem i ett träd, skriver sedan ut dem med en Iterator. Vi kan göra java TextAnalys TextAnalys.java Utskrift: A ADD ALL ARG AT C CHAR CHARACTER CLASS CO COLLATOR DETTA ELSE ETT EXTENDEDREADER EXTRA FOR GET GETFILEREADER GETINSTANCE HASNEXT I IF IMPORT INT IO IS 17 18 ISLETTER IT ITERATOR JAVA LENGTH LETTERS LITE LOCALE LOOKAHEAD MAIN NEW NEXT NEXTWORD NONLETTERS NULL OCH OM ONE ORD OUT PRIMARY PRINT PRINTLN PROGRAM PUBLIC R READ READCHAR RETURN RÄTT S SE SETSTRENGTH SKANSHOLM SKIP SOM SORTER SORTERAS SPECIFY STATIC STD STRING SV SÅNT TESTA TEXT TEXTANALYS THE TIME TO TOUPPERCASE TREE TREESET UTIL WHILE VOID WORD WORDS ÅKE ÄR ÖSTEN ÖVAR Notera att vi får en korrekt sortering! 19 20

Ett HashSet bygger på en hashtabell och är till skillnad från ett TreeSet osorterad. En hashtabell bygger på att vi för varje objekt beräknar en hashnyckel. Den ska helst vara unik för varje objekt som vi vill lägga in i tabellen, men det uppnår vi oftast inte helt. Tanken med detta är att vi har en tabell med exempelvis 100 platser. Då beräknar vi för varje objekt en hashnyckel, ett tal i intervallet 0-99, och lagrar objektet på den plats nyckeln anvisar. Om vi får samma hashnyckel för olika objekt får vi en kollision, det kan t. ex. hanteras så att varje element i tabellen är en länkad lista som innehåller alla element med samma hashnyckel. tabell med kollisioner Detta arrangemang betyder att det blir mycket effektivt att söka i denna tabell eftersom vi idealt bara behöver leta på ett ställe och direkt hittar rätt. För att undvika alltför många kollisioner bör tabellen inte fyllas till mer än 75-80%, dvs man gör den något för stor. 21 22 Ett exelipempel kan se ut på detta vis, där hashnyckeln räknas ut attematiskt av java. import java.util.*; import java.text.*; import java.io.*; import extra.*; public class HashAnalys // detta är ett program. övar lite, testa om ord som // åke, östen och sånt sorteras rätt public static void main(string [] arg) String word; HashSet words = new HashSet(); // ExtendedReader is a Skansholm class ExtendedReader r = ExtendedReader.getFileReader(arg[0]); // read one word at a time add it to the tree while ((word = nextword(r))!= null) words.add(word.touppercase()); // print all words for (Iterator i = words.iterator(); i.hasnext();) Std.out.println(i.next()); public static String nextword(extendedreader r) String s = ""; int c; // skip nonletters while ((c = r.lookahead())!= -1 &&!Character.isLetter((char) c)) c = r.readchar(); // get the letters while ((c = r.lookahead())!= -1 && Character.isLetter((char) c)) s = s + (char) r.readchar(); if (s.length() == 0) return null; else return s; Ger följande utskrift: SETSTRENGTH AT EXTRA TIME TREE ISLETTER NEXTWORD READ SV TOUPPERCASE GET WORD NEXT GETINSTANCE SOM SE GETFILEREADER ALL ITERATOR OCH ÅKE ARG OUT SPECIFY NONLETTERS TEXT THE UTIL DETTA CHARACTER PRINTLN TESTA STD TREESET CLASS COLLATOR EXTENDEDREADER WHILE ONE CHAR SKIP FOR 23 24

SKANSHOLM S VOID ADD RETURN PUBLIC R ELSE ÖSTEN JAVA INT LENGTH I WORDS NULL C LETTERS A PRINT IMPORT LITE LOOKAHEAD CO IT TEXTANALYS MAIN IS IO ETT ÄR OM IF SORTERAS HASNEXT ORD READCHAR SÅNT NEW STRING SORTER RÄTT ÖVAR PRIMARY PROGRAM LOCALE TO STATIC Avbildningstabeller En avbildningstabell är en struktur där vi har ett par, nyckel och värde, där vi kommer åt värdet med hjälp av en nyckel. Varje nyckel avbildas på exakt ett värdeobjekt och kan bara förekomma en gång i tabellen. Flera olika nycklar kan avbildas till samma objekt. 25 26 Java implementerar detta genom gränssnittet Map. Det innehåller metoderna: put(nyckel, värde), lägger in en avbildning av tabellen, Om den finns tidigare så ersätts den. putall(tab), lägger in tabellen tab i aktuell tabell remove(nyckel), tar bort avbildningen för nyckeln clear(), tar bort allt i tabellen get(nyckel), returnerar värde motsvarande nyckeln containskey(n), undersöker om n finns i tabellen containsvalue(v), undersöker om någon nyckel avbildas på v isempty(), kollar om tom size(), ger antalet avbildningar equals(tab), undersöker om tab och aktuell tab är lika keyset(), ger en mängd med alla nycklar values(), ger en samling (Collection) med alla värden entryset(), ger en mängd med alla avbildningar, med element av typ Map.Entry med metoderna getkey, getvalue och setvalue Avbildningar implementeras med klassen HashMap. Den fungerar som HashSet men med explicita nyckelvärdepar. För sorterade avbildningar används klassen TreeMap som implementerar gränssnittet SortedMap vilket är en subgränssnitt till Map. Vi kan exempelvis skapa en avbildning från ord till frekvens i en text, vi tar fram orden och räknar hur många gånger de finns. Det kan se ut så här: 27 28

import java.util.*; import java.text.*; import java.io.*; import extra.*; public class TextAnalys2 // detta är ett program. övar lite, testa om ord som // åke, östen och sånt sorteras rätt public static void main(string [] arg) String word; Collator co = Collator.getInstance(new Locale("sv","SE")); co.setstrength(collator.primary); TreeMap words = new TreeMap(co); // specify sorter // ExtendedReader is a Skansholm class ExtendedReader r = ExtendedReader.getFileReader(arg[0]); // read one word at a time add it to the tree while ((word = nextword(r))!= null) word = word.touppercase(); Integer number = (Integer) words.get(word); if (number == null) number = new Integer(0); words.put(word, new Integer(number.intValue() + 1)); Set mapping = words.entryset(); // print all words for (Iterator i = mapping.iterator(); i.hasnext();) Map.Entry e = (Map.Entry) i.next(); Std.out.println(e.getKey() + " " + e.getvalue()); public static String nextword(extendedreader r) String s = ""; int c; // skip nonletters while ((c = r.lookahead())!= -1 &&!Character.isLetter((char) c)) c = r.readchar(); // get the letters while ((c = r.lookahead())!= -1 && Character.isLetter((char) c)) s = s + (char) r.readchar(); if (s.length() == 0) return null; else return s; java TextAnalys2 TextAnalys.java A 2 ADD 2 ALL 1 ARG 2 AT 1 C 6 CHAR 3 CHARACTER 2 CLASS 2 CO 3 COLLATOR 3 DETTA 1 ELSE 1 ETT 1 EXTENDEDREADER 4 EXTRA 1 FOR 1 GET 1 GETFILEREADER 1 GETINSTANCE 1 HASNEXT 1 I 3 IF 1 IMPORT 4 INT 1 IO 1 IS 1 ISLETTER 2 IT 1 ITERATOR 2 JAVA 3 LENGTH 1 LETTERS 1 LITE 1 LOCALE 1 LOOKAHEAD 2 29 30 MAIN 1 NEW 2 NEXT 1 NEXTWORD 2 NONLETTERS 1 NULL 2 OCH 1 OM 1 ONE 1 ORD 1 OUT 1 PRIMARY 1 PRINT 1 PRINTLN 1 PROGRAM 1 PUBLIC 3 R 7 READ 1 READCHAR 2 RETURN 2 RÄTT 1 S 5 SE 1 SETSTRENGTH 1 SKANSHOLM 1 SKIP 1 SOM 1 SORTER 1 SORTERAS 1 SPECIFY 1 STATIC 2 STD 1 STRING 4 SV 1 SÅNT 1 TESTA 1 TEXT 1 TEXTANALYS 1 THE 2 TIME 1 TO 1 TOUPPERCASE 1 TREE 1 TREESET 2 UTIL 1 WHILE 3 VOID 1 WORD 4 WORDS 4 ÅKE 1 ÄR 1 ÖSTEN 1 ÖVAR 1 31 32

Sortering & Sökning Sortering och sökning är två viktiga tillämpningar av programmering. Vi ska begrunda några olika metoder för detta. Sortering kan göras på flera olika sätt. Vi talar om sortering in-situ vilket betyder att en osorterad datamängd skall förvandlas till en sorterad i samma utrymme. Typiska algoritmer för detta är urval, instick, bubbel och quicksort. Dessa metoder kan lätt användas till att producera en ny sorterad mängd från en osorterad mängd. En tredje variant är att slå samman två eller flera sorterade mängder (lagrade i minnet eller i filer) till en ny sorterad mängd. Detta kallar vi samsortering (merge sort) 33 34 Det viktiga med sorteringsmetoder är deras effektivitet. Enkla metoder som t. ex. urvalssortering går igenom en datamängd med n element n gånger. Det leder till algoritmer som är n*n proportionella. Det tar mycket tid att sortera stora datamängder. Det finns bättre metoder som istället är n*log(n) proportionella. För stora datamängder blir detta viktigt. Om vi har 100.000 element så får vi ~10000000000 operationer med bubble ~2000000 operationer för quicksort 35 36

Grunder för bubbelsortering är att låta tal bubbla upp till sin position. Detta gör man genom att gå igenom data och swappa två intilligande värden som är felsorterade. Efter ett sådant pass har ett värde hamnat på rätt plats. Efter att ha repeterat detta n gånger blir mängden sorterad. En bubbelsorteringsfunktion som sorterar en array kan se ut så här: //-----------------------------------------------// function: swap //----------------------------------------------- public void swap( int [] data, int i, int j) // swap the values at positions i and j Det går att detektera om vi blir klara tidigare. Bubbelsortering är bra om vi har nästan sorterade mängder. int temp = data[i]; data[i] = data[j]; data[j] = temp; 37 38 //----------------------------------------------- //function: bubblesort //----------------------------------------------- public void bubblesort(int[] data) // sort the argument vektor in // ascending order for (int top = data.length - 1; top > 0; top--) // find the largest element in position // 0..top, place in data[top] for (int i = 0; i < top; i++) if (data[i+1] < data[i]) swap(data, i+1, i); Det viktiga i urvalssortering är att leta upp det största elementet i mängden och lägga det på rätt plats. Detta repeteras sedan för återstående data tills vi gått igenom mängden n gånger. Detta påverkas inte på något sätt av ordningen i datamängden. Kod för urvalssortering kan se ut som: public void selectionsort(int[] data) // sort, in place. the argument vektor // into ascending order for (int top = data.length-1; top > 0; top--) // find the position of the largest element int largeposition = 0; for (int j = 1; j <= top; j++) // data[largeposition] is // largest element in 0..j-1 if (data[largeposition] < data[j]) largeposition = j; // data[largeposition] is largest // element in 0..j if (top!= largeposition) swap(data, top, largeposition); 39 40

Instickssortering baseras på iden att mängden är uppdelad i en sorterad del och en osorterad del. Från början är den sorterade delen tom. Vi överför sedan ett värde i taget från den osorterade mängden till den sorterade mängden i rätt position. Koden för detta: public void insertionsort(int [] data) // sort, in place. the argument // vektor into ascending order int n = data.length; for (int top = 1; top < n; top++) // data[0..top-1] is ordered // goal: place element data[top] // in the proper position for (int j=top-1; j>=0 && data[j+1]<data[j]; j--) swap(data, j, j+1); 41 42 Problemet med alla dessa metoder är att de är n*n proportionella. Bra sorteringsmetoder är n*log(n) proportionella istället. Exempel på en sådan metod är quicksort. quicksort bygger på valet av ett Pivotelement och sedan på partitionering kring detta pivotelement. Antag att vi har elementen 2 97 17 37 12 46 10 55 80 42 39 Antag att vi väljer talet 37 som pivotelement. Vi börjar sedan med att swappa det första element (2) med talet (37). Sedan har vi två pekare, low och high, low initieras till 1 (andra elementet) och high till 10 (sista elementet). Sedan stegas low uppåt ett steg i taget tills ett tal större än pivotelementet hittas och high ned ett steg nedåt i taget, tills ett tal mindre än pivotelementet hittas. Värdena vid low och high swappas då och stegningen fortsätter till high passerar low. 43 44

På detta sätt får vi två grupper av värden, en med värden större än pivotelementet och en med värden mindre än pivotelementen. Till sist läggs pivotelementet tillbaka mellan dessa grupper. Repetera sedan detta för de två delarna med två nya pivotelement. I vårt fall får vi: Först läggs elementet 37 i första positionen. Sedan jämförs 97 med 37 och 39 med 37. Båda är större än 37. Stega ned high, byt ut 39 mot 42. Fortsätt och stega high tills vi hittar 10. Swappa 10 och 97. Stega low till 17. Stega vidare till 2 sedan vidare till 12, vidare till 46. High stegas sedan till 46 och vidare till 12 Eftersom high nu passerat low är vi klara och swappar 12 (pekas ut av high) med 37. Ger oss 12 10 17 2 37 46 97 55 80 42 39 45 46 Vi gör sedan om detta med talen 12-2 och med talen 46-39. Om dessa två delmängder är n/2 stora så behövs det log(n) delningar. Varje delning kräver n operationer, totalt n*log(n). Beror dock mycket på valet av pivotelement. Vi kan få n*n operationer om vi har ett dåligt val av pivotelement. Koden för quicksort ser ut som: //-----------------------------------------------// partition and quicksort //----------------------------------------------- public int partition(int [] v, int low, int high, int pivotindex) // move the pivot value to the bottom // of the vektor if (pivotindex!= low) swap(v, low, pivotindex); pivotindex = low; low++; // v[i] for i less than low are less than // or equal to pivot v[i] for i greater than // high are greater than pivot // move elements into place while (low <= high) if (v[low] <= v[pivotindex]) low++; else if (v[high] > v[pivotindex]) high--; else swap(v, low, high); // put pivot back between two groups if (high!= pivotindex) swap(v, pivotindex, high); return high; // return the border between high and low 47 48

public void quicksort(int [] v, int low, int high) // no need to sort a vektor // of zero or one elements if (low >= high) return; // select the pivot value int pivotindex = (low + high) / 2; // partition the vektor pivotindex = partition(v, low, high, pivotindex); // sort the two sub arrays if (low < pivotindex) quicksort(v, low, pivotindex - 1); if (pivotindex < high) quicksort(v, pivotindex + 1, high); En liten test av olika sorteringsmetoder gav detta Tider i millisekunder, spalterna anger 100, 1000 resp 10000 slumpmässigt valda reella tal. Tiderna för 100 tal är mycket oexakta eftersom klockan inte pålitligt kan mäta så korta tider. Quick <10 150 1750 Urval ~40 2410 244750 Instick ~40 3470 363960 Bubbel ~50 4710 482230 Jag testade även 100000 tal men efter 2 timmar tröttnade jag på att vänta. public void quicksort(int [] v) quicksort(v, 0, v.length - 1); 49 50 Samsortering görs ofta i samband med register då man vill åstadkomma ett nytt register som också är sorterat. Vi kan inte utan svårighet sortera en fil. En fil kan inte byggas ut mitt i utan bara i slutet. Samsortering kan vi dock göra från två eller flera filer till en ny fil. Det är principiellt ganska enkelt, Sökning kan göras i en osorterad mängd eller i en sorterad mängd. I en osorterad mängd kan vi inte hitta ett visst element med mindre än n/2 sökningar i genomsnitt. Den enklaste metoden kallar vi linjärsökning och den går ut på att jämföra elementen ett i taget tills vi hittar det rätta Hämta ett element från varje datakälla, Undersök vilket av dessa som skall läggas i resultatfilen. Gör detta och hämta ett nytt värde från denna källa. Repetera detta tills det är klart. Svårigheten är att filerna är olika långa och man måste reducera antalet datakällor vartefter de tar slut. Inte principiellt svårt men kan leda till en hel del kod. 51 52

En bättre metod är då binärsökning som bygger på att datamängden är sorterad. Vi jämför då vår nyckel med det mittersta elementet. Om detta stämmer är vi klara, annars kan vi kasta bort hälften av talen och göra om sökningen i den del som blev kvar. Blir ju beroende av log(n). Å andra sidan tar n*log(n) att sortera värdena. Det hela blir en avvägning mellan antalet sökningar och sorteringstider. Om vi antar att vi gör k st sökningar kan man ganska lätt beräkna lönsamheten i sortering genom n*log(n) + k*log(n) < k*n/2 Ger k>40 med 10 tal men k>1 för 1000 tal. Binärsökning ser ut på detta sätt: //----------------------------------------------- // function: binarysearch //----------------------------------------------- public boolean binarysearch(int [] data, int ele) // perform binary search on a vektor int low = 0; int high = data.length-1; while (low < high) // data[0..low-1] are all less than ele // data[high..max] are all // greater than ele int mid = (low + high) / 2; if (data[mid] == ele) return true; else if (data[mid] < ele) low = mid + 1; else high = mid; return false; 53 54