Et SML-program til sortering af linier i en tekstfil

Transkript

1 Et SML-program til sorterg af lier i en tekstfil Hans Hüttel 10. januar 2002 Indhold 1 Om denne tekst 2 2 Interface 2 3 At dlæse strenge fra en fil og danne en liste af dem Funktionsdefitioner Test af denne del af programmet Sorterg af en liste af strenge Prcippet i udvælgelsessorterg Hjælpefunktionerne Test af denne del af programmet Til mdsteelement Til fjern Hele sortergsdelen af programmet Test af sorter At udskrive en liste af strenge til en fil Test af denne del af programmet Funktionen sorterfil 8 7 Dialogfunktionen 8 8 At lave programmet fritstående 9 9 En anden måde at sortere på Prcippet bag flettesorterg Flettesorterg i SML Fletng af sorterede lister Selve sortergsfunktionen

2 Funktion Type Formål laes_fra_stroem TextIO.stream -> strg list At danne en liste af strenge ud fra en putstrøm lav_liste strg -> strg list At danne en liste af strenge ud fra en fil med et givet navn sorter strg list -> strg list At sortere en liste af strenge sorterfil strg -> unit At producere en ny, sorteret fil ud fra en fil med et givet navn dialog unit -> unit At bede brugeren om navn på fil der skal sorteres og give en meddelelse på skærmen 1 Om denne tekst Tabel 1: Interface for sortergsprogram I denne tekst beskriver jeg et lille fritstående SML-program der kan sortere lierne i en tekstfil. Teksten beskriver hvordan programmet bliver opbygget og udviklet. Vi ser desuden en del eksempler på rekursive funktioner over lister, put og output til filer og dialog med brugeren. Afsnit 9 beskriver en alternativ sortergsalgoritme som vi kunne have anvendt. 2 Interface Vores program skal defere tre hovedfunktioner, laes_fra_stroem, lav_liste og sorter. Disse er beskrevet i Tabel 1. Funktionen sorterfil anvender de to foregående funktioner, laes_fra_stroem og lav_liste. Denne funktion har en sideeffekt idet den skriver strenge på en fil. Denne funktion er med andre ord en uegentlig funktion og dens resultattype er derfor unit. Derudover skal programmet have en dialogfunktion dialog der beder brugeren om navnet på den fil der skal sorteres og kalder sorterfil. 2

3 3 At dlæse strenge fra en fil og danne en liste af dem Lad os først beskrive to funktioner der tilsammen gør det muligt at dlæse strenge fra en fil og danne en liste af dem. 3.1 Funktionsdefitioner Filer beskrives i SML som strømme. Vores første funktion dlæser en strøm lie for lie og placerer lierne i en liste. Hvis vi er ved slutngen af strømmen skal vi som svar give den tomme liste og derefter lukke strømmen. Hvis vi ikke er ved slutngen af strømmen skal vi læse den første lie vi ser. Kald denne lie for l. Vi placerer l forrest i den liste vi får ved at læse strengene fra den resterende strøm. Denne funktion er rekursiv; det sted i beskrivelsen som svarer til det rekursive kald er markeret med skråskrift ovenfor. fun laes_fra_stroem stroem = if TextIO.endOfStream stroem then [] before TextIO.closeIn stroem else let val lie = TextIO.putLe stroem lie::(laes_fra_stroem stroem) Bemærk at vi anvender before her for at angive at resultatværdien er [], ikke resultatet af dernæst at lukke datastrømmen. Vor næste funktion anvender laes_fra_stroem; denne funktion tager et filnavn og åbner en strøm for denne fil. Herefter kalder vi laes_fra_stroem på den nye strøm. Funktionsdefitionen ses herunder: fun lav_liste fil = let val dstroem = TextIO.openIn fil laes_fra_stroem dstroem end laes_fra_stroem er en hjælpefunktion der kun skal anvendes af lav_liste og derfor gør vi laes_fra_stroem lokal med en local-erklærg. Den endelige defition kommer til at se sådan ud: local 3

4 fun laes_fra_stroem stroem = if TextIO.endOfStream stroem then [] before TextIO.closeIn stroem else let val lie = TextIO.putLe stroem lie::(laes_fra_stroem stroem) fun lav_liste fil = let val dstroem = TextIO.openIn fil laes_fra_stroem dstroem end 3.2 Test af denne del af programmet Vi tester denne del af programmet ved at kalde lav_liste på en fil og se hvilken liste man får som resultat. 4 Sorterg af en liste af strenge Vi sorterer en liste ved udvælgelsessorterg. Ideen i udvælgelsessorterg er enkel og kan anvendes uanset hvad vi sorterer. 4.1 Prcippet i udvælgelsessorterg Lad os antage at vi skal sortere en liste l. Hvis l er tom skal vi ikke gøre noget Hvis l ikke er tom skal vi fde det mdste element i l og sætte l forrest i den liste vi får ved at sortere de resterende elementer. Denne funktion er rekursiv; det sted i beskrivelsen som svarer til det rekursive kald er markeret med skråskrift ovenfor. Lad os antage at vi allerede havde en funktion mdsteelement der kunne fde det mdste element i en liste og en funktion fjern der kunne give os en liste hvor vi havde fjernet et element. Disse funktioner skulle have typerne mdsteelement : a list -> a fjern : a * a list -> a list Disse funktioner er polymorfe funktioner over lister hvor elementerne skal have en sammenligngstype. Da kunne vi skrive vores sortergsfunktion således: 4

5 fun sorter [] = [] sorter liste = let val m = mdsteelement liste val resten = fjern (m, liste) m::(sorter resten) 4.2 Hjælpefunktionerne Nu er der kun tilbage at defere mdsteelement og fjern. Lad os tage mdsteelement først. Denne funktion skal kun give en værdi hvis vi anvender den på en liste der ikke er tom. Derfor erklærer vi en exception tomliste som skal hejses i det modsatte tilfælde. Ideen er denne: Hvis l kun består af elementet x, er svaret x Hvis l har elementet x som hoved og halen af l hedder l 1, da skal vi fde den mdste værdi i l 1 og sammenligne den med x. Svaret er her den mdste af de to værdier. Denne funktion er altså også rekursiv; det sted i beskrivelsen som svarer til det rekursive kald er markeret med skråskrift ovenfor. Herunder ses funktionsdefitionen. Vi bruger en hjælpefunktion som vi kalder m. exception tomliste; fun mdsteelement [] = raise tomliste mdsteelement [x] = x mdsteelement (x::l1) = m (x, (mdsteelement l1) ); Det eneste sted i programmet hvor vi eksplicit skal gøre opmærksom på at vi sammenligner strenge er i defitionen af m. Denne funktion bruger funktionen Strg.compare. Denne funktion har typen strg*strg -> Order. Order er typen hvis elementer er LESS, EQUAL og GREATER. Se [HR99, App. D]. fun m (x,y) = if Strg.compare(x,y)=LESS then x else y; fjern-funktionen skal gøre følgende: Lad os antage at vi vil fjerne elementet x fra en liste l. Hvis l er tom, er der tet at fjerne. Resultatet er den tomme liste. 5

6 Hvis l har elementet y som hoved og elementerne l 1 som hale, da skal vi sammenligne x og y. Hvis x = y, er resultatet l 1. Ellers beholder vi y og sætter dette element forrest i listen vi får ved at fjerne x fra l 1. Denne funktion er altså også rekursiv; det sted i beskrivelsen som svarer til det rekursive kald er markeret med skråskrift ovenfor. Herunder ses funktionsdefitionen: fun fjern (x,[]) = [] fjern (x,(y::s)) = if x=y then s else y::(fjern (x,s)); 4.3 Test af denne del af programmet Denne del af programmet anvender flere funktioner. Derfor er det nødvendigt at teste alle hjælpefunktionerne for sig. Nogle gode testdata er: Til mdsteelement Her er der tre klausuler i defitionen så vi skal prøve funktionen af på en tom liste, en liste med eet element og en liste med flere elementer. Disse kunne være f.eks. mdsteelement [] mdsteelement ["hund"] mdsteelement ["hund","kat","hest"] Til fjern I første klausul optræder den tomme liste. I anden klausul er der to grene, da der er et if-then-else-udtryk. Her skal vi kunne prøve funktionen af med et par (e, l) hvor e er et element i listen l og med et par (e, l) hvor e ikke er et element i listen l. Vores testcases kunne derfor være f.eks. fjern ("hest",[]) fjern ("hest",["hund","kat","hest"]) fjern ("gris",["hund","kat","hest"]) 4.4 Hele sortergsdelen af programmet Vi kan nu sætte det hele sammen. Funktionerne m og mdsteelement skal kun bruges af sorter, og derfor pakker vi dem d i en local-erklærg. exception tomliste; 6

7 local fun m (x,y) = if Strg.compare(x,y)=LESS then x else y; fun mdsteelement [] = raise tomliste mdsteelement [x] = x mdsteelement (x::l1) = m (x, (mdsteelement l1) ); fun fjern (x,[]) = [] fjern (x,(y::s)) = if x=y then s else y::(fjern (x,s)); fun sorter [] = [] sorter liste = let val m = mdsteelement liste val resten = fjern (m, liste) m::(sorter resten) Fordi vores funktion sorter kalder mdsteelement som kalder m, og fordi m sammenligner strenge, konkluderer ML-systemet at funktionen sorter må have typen strg list -> strg list Test af sorter I første klausul optræder den tomme liste. I anden klausul optræder en vilkårlig liste. Derfor vil gode testcases her være f.eks. sorter [] sorter ["hund","kat","hest"] 5 At udskrive en liste af strenge til en fil Vores funktion skriv_fil skal udskrive dholdet af en liste af strenge til en fil. Denne funktion tager en liste og navnet på en fil. Herefter bliver der åbnet en strøm af type outstream som associeres med den pågældende fil. Selve udskrivngen på denne outputstrøm klares af en hjælpefunktion som vi giver navnet skriv_paa_stroem. skriv_paa_stroem er en funktion over lister af strenge. Hvis listen l er tom, skal vi blot lukke vores outputstrøm. 7

8 Hvis listen l ikke er tom, har den et hoved som vi kalder x og en hale som vi kalder s. Vi skriver strengen x på outputstrømmen og derefter skriver vi listen s ud på vores outputstrøm. Denne funktion er altså også rekursiv; det sted i beskrivelsen som svarer til det rekursive kald er markeret med skråskrift ovenfor. Nedenfor er programteksten for de to funktioner. fun skriv_paa_stroem (stroem,[]) = TextIO.closeOut stroem skriv_paa_stroem (stroem,(x::s)) = (TextIO.output(stroem,x); skriv_paa_stroem (stroem,s)); fun skriv_fil (liste,fil) = let val udstroem = TextIO.openOut fil skriv_paa_stroem (udstroem,liste) 5.1 Test af denne del af programmet For at teste denne del af programmet skal vi prøve at kalde skriv_fil med en liste af strenge og et filnavn. Herefter skal vi se om de pågældende strenge er blevet skrevet i filen. Dette kan vi gøre ved f.eks. at prøve at åbne filen i Emacs. 6 Funktionen sorterfil Vi kan nu lave en funktion der sorterer en fil. Den kalder blot lav_liste og sorter: fun sorterfil f = let val liste = lav_liste f val sorteretliste = sorter liste val nyfil = skriv_fil (sorteretliste,(f^".sort")) nyfil En mere koncis formulerg kunne være at sætte funktionerne sammen: fun sorterfil f = skriv_fil (sorter (lav_liste f)); 7 Dialogfunktionen Vi skal bruge funktioner fra TextIO-modulet mange gange og det er besværligt at skulle skrive TextIO mange steder. Øverst i programmet åbner vi derfor TextIO med 8

9 open TextIO; Vi laver en lille hjælpefunktion, annoncer, der kan udskrive en streng til outputstrømmen stdout og derefter tømme stdout-bufferen så strengen kommer ud på skærmen med det samme. Da enhver dtastet streng slutter med et lieskift-tegn, laver vi endnu en lille hjælpefunktion, dropsidste, der fjerner dette tegn. Selve dialog-funktionen gør nu følgende: Den skriver et spørgsmål ud på skærmen Den modtager navnet på en fil fra brugeren Den sorterer filen med det pågældende navn ved at kalde sorterfil Den skriver en meddelelse ud til brugeren Nu skal vi blot til allersidst i vores program erklære en værdi, _, der kalder dialog-funktionen. Tilsammen har vi: fun annoncer s = (output(stdout,s); flushout(stdout)); fun dropsidste s = Strg.substrg(s,0,(size s)-1); fun dialog () = let val spoergsmaal = annoncer "Indtast filnavn: " val filnavn = dropsidste (putle(stdin)) sorterfil filnavn; annoncer ("Filen er sorteret som "^filnavn^".sort") val _ = dialog (); 8 At lave programmet fritstående Vi kan nu lave programmet fritstående. Vi skal blot fjerne vores kald af load og kalde mosmlc. Lad os sige at vores program hedder sorterg.sml og at vores fritstående program skal hedde frisort. Da skriver vi blot mosmlc -o frisort sorterg.sml For at kalde det fritstående program skal vi skrive dets navn frisort i en dolomit-shell. 9

10 9 En anden måde at sortere på Der fdes en masse forskellige sortergsstrategier. Den strategi som vi så i det foregående var udvælgelsessorterg. I dette sidste afsnit vil jeg beskrive et alternativ, nemlig flettesorterg. Denne sortergsmetode dukkede op i det allerførste, gådefulde SML-program ved 1. kursusgang. En grund til at bruge flettesorterg i stedet for udvælgelsessorterg er at flettesorterg er hurtigere end udvælgelsessorterg. Det er nemlig muligt at bevise følgende (vi skal ikke gøre det her): Hvis man skal sortere en liste med n elementer skal udvælgelsessorterg foretage op til n 2 sammenlignger af enkelte elementer, mens flettesorterg kan nøjes med n log n sammenlignger. Hvis man skal sortere en stor liste bliver denne forskel dramatisk. Udvælgelsessorterg skal bruge sammenlignger, mens flettesorterg kan nøjes med ca Prcippet bag flettesorterg Lad os betragte en liste af strenge: ["hund","kat","abe","gris","mus","zebra"] Lad os dele denne liste op i to dele: ["hund","kat","abe"] ["gris","mus","zebra"] og sortere dem hver for sig på samme måde som vi nu vil beskrive. Resultatet bliver ["abe","hund","kat"] ["gris","mus","zebra"] Nu skal vi blot flette de to sorterede lister sammen til en ny liste der også skal være sorteret. Hvordan gør vi det? Lad os antage at vi skal flette ["abe","hund","kat" og ["gris","mus","zebra"]. Første element i den første liste, ["abe","hund","kat"], er "abe". Første element i ["gris","mus","zebra"] er "gris". Så hovedet i den flettede liste bliver "abe". Halen i den flettede liste bliver den liste vi får ved at flette ["hund","kat"] og ["gris","mus","zebra"]. Hvis vi skal flette en liste l med en tom liste vil resultatet blot blive l. 9.2 Flettesorterg i SML Vi kan nu beskrive flettesorterg i SML. 10

11 9.2.1 Fletng af sorterede lister Når vi skal defere en funktion der kan flette to sorterede lister, tager vi udgangspunkt i ideerne fra forrige afsnit. Vi sammenligner to sorterede lister ved hele tiden at sammenligne de to forreste elementer og sætte det mdste af dem forrest. Herefter kalder vi flettefunktionen rekursivt på de resterende lister. Vi får følgende: fun flet ([],l) = l flet (l,[]) = l flet ( (x::xs),(y::ys) ) = case Strg.compare (x,y) of LESS => (x::(flet (xs,(y::ys)))) GREATER => y::(flet (x::xs,ys)) EQUAL => x::y::(flet (xs,ys)); Selve sortergsfunktionen Når vi skal sortere en tom liste eller en liste med kun eet element er der ikke meget at lave. Hvert af disse tilfælde giver en klausul i sorter-funktionen der er helt ligetil. Det teressante tilfælde er det tredie, nemlig når listen består af mere end eet element. Vi deler vores liste over i to halvdele og kalder sorter rekursivt på de to halvdele. De to sorterede lister vi får ud af det, skal vi så flette med flet. Hvordan gør vi alt dette? Først beregner vi længden af vores liste og bruger derefter funktionerne List.take og List.drop (se [HR99, appendix D.4]) til at udvælge de to halvdele af listen. Herefter kalder vi sorterfunktionen rekursivt på de to halvdele og fletter resultaterne. sorter-funktionen kommer til at se således ud: fun sorter [] = [] sorter [x] = [x] sorter l = let val lgd = (length l) div 2 val foerste = List.take(l,lgd) val sidste = List.drop(l,lgd) flet( sorter(foerste),sorter(sidste)) Litteratur [HR99] M. Hansen og H. Rischel. Introduction to Programmg Usg SML, Addison-Wesley