FONAMENTS DE PROGRAMACIÓ IIDolors Ayala VallespíNúria Pla Gar iaAntoni Soto RieraMar Vigo AngladaJosep Vilaplana Pastó

Fonaments de programa io III.S.B.N.-10: 84-96616-00-2Aquesta obra està subje ta a una lli èn ia Re oneixement-Compartir Igual 3.0 Espanya de CreativeCommons. Per veure'n una òpia, visiteu http:// reative ommons.org/li enses/by-sa/3.0/es/deed. a o envieuuna arta a Creative Commons, 171 Se ond Street, Suite 300, San Fran is o, California 94105, USA.

Índex1 Esquemes algorísmi s 11.1 Introdu ió . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.2 Abstra ió i seqüèn ies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.3 Esquema de re orregut . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51.4 Esquema de er a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71.5 Esquema de er a en taules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101.6 Bibliogra�a rela ionada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112 Anàlisi des endent 132.1 Introdu ió . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132.2 Con eptes bàsi s del mètode de disseny des endent . . . . . . . . . . . . . . . . 132.3 Exemple per una introdu ió prà ti a del mètode . . . . . . . . . . . . . . . . . 152.3.1 Enun iat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152.3.2 Solu ió . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152.3.3 Abstra ió de dades d'empleat . . . . . . . . . . . . . . . . . . . . . . . 152.3.4 Abstra ió empleat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182.3.5 Nivell nom . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202.3.6 Nivell hores treballades . . . . . . . . . . . . . . . . . . . . . . . . . . . 212.4 Més sobre el disseny des endent . . . . . . . . . . . . . . . . . . . . . . . . . . . 222.5 Problema exemple 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232.6 Problema exemple 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272.7 Bibliogra�a rela ionada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293 Fitxers seqüen ials de text 313.1 Introdu ió . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313.2 Arquite tura d'un omputador . . . . . . . . . . . . . . . . . . . . . . . . . . . 313.2.1 Les parts prin ipals d'un omputador . . . . . . . . . . . . . . . . . . . . 313.2.2 La CPU . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323.2.3 La memòria prin ipal . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333.2.4 Magatzem se undari de memòria . . . . . . . . . . . . . . . . . . . . . . 363.3 La jerarquia de les abstra ions en un omputador . . . . . . . . . . . . . . . . 393.4 Classi� a ió dels �txers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 413.5 Tra tament algorísmi dels FST . . . . . . . . . . . . . . . . . . . . . . . . . . . 423.5.1 Referèn ia a �txer. Con epte de binding . . . . . . . . . . . . . . . . . . 423.5.2 Opera ions sobre �txers de text . . . . . . . . . . . . . . . . . . . . . . . 423.5.3 Exemple d'apli a ió . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44iii

iv ÍNDEX3.6 Fusió entre �txers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 483.6.1 Introdu ió . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 483.6.2 Exemple de fusió entre dos �txers . . . . . . . . . . . . . . . . . . . . . . 483.6.3 Mètode de Feigen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 503.6.4 Disseny de l'algorisme orresponent al mètode de Feigen . . . . . . . . . 503.7 Bibliogra�a rela ionada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 524 Complexitat Algorísmi a 534.1 Introdu ió . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 534.2 Anàlisi d'algorismes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 534.3 Exemple: Algorismes d'avalua ió de polinomis . . . . . . . . . . . . . . . . . . . 544.4 Càl ul de la fun ió de ost . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 564.4.1 Cost d'avaluar una expressió . . . . . . . . . . . . . . . . . . . . . . . . 564.4.2 Cost d'exe utar una assigna ió . . . . . . . . . . . . . . . . . . . . . . . 574.4.3 Cost d'exe utar el retorn d'una fun ió . . . . . . . . . . . . . . . . . . . 574.4.4 Cost d'exe utar una rida a una a ió . . . . . . . . . . . . . . . . . . . 574.4.5 Cost d'una omposi ió seqüen ial . . . . . . . . . . . . . . . . . . . . . . 584.4.6 Cost d'una omposi ió alternativa . . . . . . . . . . . . . . . . . . . . . 584.4.7 Cost d'una omposi ió iterativa . . . . . . . . . . . . . . . . . . . . . . . 584.5 Con lusions sobre l'anàlisi d'algorismes . . . . . . . . . . . . . . . . . . . . . . . 594.6 Mesures Asimptòtiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 594.6.1 Propietats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 594.6.2 Exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 614.7 Càl ul de ost asimptòti de la omposi ió d'algorismes . . . . . . . . . . . . . . 624.7.1 Cost asimptòti d'avaluar una expressió . . . . . . . . . . . . . . . . . . 624.7.2 Cost asimptòti d'una assigna ió . . . . . . . . . . . . . . . . . . . . . . 644.7.3 Cost asimptòti del retorn d'una fun ió . . . . . . . . . . . . . . . . . . 644.7.4 Cost asimptòti d'una rida a una a ió . . . . . . . . . . . . . . . . . . 644.7.5 Cost asimptòti d'una omposi ió seqüen ial . . . . . . . . . . . . . . . . 644.7.6 Cost asimptòti d'una omposi ió alternativa . . . . . . . . . . . . . . . 644.7.7 Cost asimptòti d'una omposi ió iterativa . . . . . . . . . . . . . . . . . 654.8 Bibliogra�a rela ionada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 655 Cer a i Ordena ió 675.1 Introdu ió . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 675.2 Espe i� a ió d'estats d'una taula en el ontext d'ordena ió . . . . . . . . . . . . 675.3 Cer a d'un element en una taula ordenada . . . . . . . . . . . . . . . . . . . . . 685.3.1 Cer a lineal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 695.3.2 Cer a lineal millorada per a taules ordenades . . . . . . . . . . . . . . . 705.3.3 Cer a di otòmi a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 715.4 Ordena ió . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 785.4.1 Mètode de sele ió . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 795.5 Bibliogra�a rela ionada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83

ÍNDEX v6 Introdu ió a les estru tures de dades 856.1 Introdu ió . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 856.1.1 Espe i� a ió del tipus Ve tor . . . . . . . . . . . . . . . . . . . . . . . . 866.1.2 Implementa ió V1: ve tor estàti amb dimensió variable . . . . . . . . . 876.2 Matrius. Espe i� a ió i implementa ió . . . . . . . . . . . . . . . . . . . . . . . 886.2.1 Espe i� a ió del tipus Matriu . . . . . . . . . . . . . . . . . . . . . . . . 886.2.2 Exemple d'ús d'aquesta espe i� a ió . . . . . . . . . . . . . . . . . . . . 886.2.3 Implementa ió M1: matriu estàti a amb dimensió variable . . . . . . . . 896.3 Matrius disperses . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 916.3.1 Implementa ió M2: matriu estàti a amb dimensió variable dispersa . . . 916.3.2 Considera ions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 966.4 Taula de freqüèn ies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 986.4.1 Espe i� a ió d'una taula de freqüèn ies . . . . . . . . . . . . . . . . . . 996.4.2 Exemple d'ús d'aquesta espe i� a ió . . . . . . . . . . . . . . . . . . . . 996.4.3 Implementa ió TF1: taula estàti a de freqüèn ies de dimensió �xa . . . 1006.4.4 Implementa ió TF2: taula estàti a de freqüèn ies de dimensió variable . 1026.4.5 Un altre exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1046.5 Bibliogra�a rela ionada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1057 Apuntadors i memòria dinàmi a 1077.1 Apuntadors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1077.1.1 Introdu ió . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1077.1.2 Apuntadors i arguments de fun ions . . . . . . . . . . . . . . . . . . . . 1097.2 Gestió dinàmi a de memòria . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1127.2.1 Reserva i alliberament de memòria . . . . . . . . . . . . . . . . . . . . . 1127.2.2 Memòria dinàmi a per a diversos tipus . . . . . . . . . . . . . . . . . . . 1127.2.3 Errors freqüents en l'ús d'apuntadors . . . . . . . . . . . . . . . . . . . . 1157.3 Apuntadors d'apuntadors. Taules d'apuntadors . . . . . . . . . . . . . . . . . . 1157.4 Ve tors i matrius semidinàmi s . . . . . . . . . . . . . . . . . . . . . . . . . . . 1177.4.1 Espe i� a ió de les noves opera ions del tipus Matriu . . . . . . . . . . 1177.4.2 Implementa ió M4. Primera implementa ió d'una matriu semidinàmi a 1187.4.3 Implementa ió M5. Segona implementa ió d'una matriu semidinàmi a . 1187.5 Bibliogra�a rela ionada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1208 Apli a ions al àl ul numèri 1218.1 Resolu ió de sistemes d'equa ions lineals. Introdu ió . . . . . . . . . . . . . . . 1218.1.1 Càl ul numèri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1218.1.2 Errors de trun ament i d'arrodoniment . . . . . . . . . . . . . . . . . . . 1218.1.3 Resolu ió de sistemes d'equa ions lineals . . . . . . . . . . . . . . . . . . 1228.2 Mètode de Gauss . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1228.2.1 Introdu ió . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1228.2.2 Pro és d'elimina ió gaussiana . . . . . . . . . . . . . . . . . . . . . . . . 1228.2.3 Estratègies de pivot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1238.2.4 Algorismes orresponents al mètode de Gauss . . . . . . . . . . . . . . . 1248.2.5 Subprograma de resolu ió d'un sistema amb pivotatge par ial . . . . . . 1248.2.6 Subprograma d'elimina ió gaussiana amb pivotatge par ial . . . . . . . . 1268.2.7 Subprograma de resolu ió d'un sistema amb pivotatge total . . . . . . . 127

vi ÍNDEX8.2.8 Subprograma d'elimina ió gaussiana amb pivotatge total . . . . . . . . . 1308.3 Mètodes iteratius . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1318.3.1 Introdu ió . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1318.3.2 Algorismes orresponents als mètodes iteratius . . . . . . . . . . . . . . 1328.3.3 Subprograma que implementa el mètode iteratiu . . . . . . . . . . . . . 1328.3.4 Altres subprogrames rela ionats . . . . . . . . . . . . . . . . . . . . . . . 1348.3.5 Implementa ions amb gestió dinàmi a de memòria . . . . . . . . . . . . 1358.4 Bibliogra�a rela ionada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1389 Problemes Resolts 13910 Enun iats de problemes 157

Capítol 1Esquemes algorísmi s1.1 Introdu ióL'obje tiu de l'assignatura Fonaments d'Informàti a és ini iar-se en la onstru ió d'algorismesper resoldre problemes. En el desenvolupament d'un programa hi ha tres fases que s'hande seguir: primerament espe i� ar, després dissenyar, i després implementar. Espe i� ar onsisteix a dir què fa un programa, sense donar ap detall sobre óm ho fa. Dissenyar, en anvi, onsisteix a dir óm s'a onsegueix que es resolgui el problema proposat. Implementarés realitzar el disseny a un sistema on ret de omputador.Espe i� ar un problema és donar una des rip ió pre isa del problema, tant de les dadesi les ondi ions que s'han de omplir om dels resultats esperats.• Pre ondi ió: Condi ions que han de omplir les dades per assegurar que els resultatssiguin orre tes.• Post ondi ió: Condi ions que han de satisfer els resultats esperats.Moltes de les espe i� a ions es donen en llenguatge natural, però no per aquest motiu hande ser menys rigoroses.Els algorismes treballen amb obje tes, els quals són modi� ats i manipulats per les a ions.Hi ha a ions elementals a partir de les quals es onstrueixen a ions més omplexes.També hi ha obje tes de tipus elemental a partir dels quals es onstruiran els altres obje tesmés omplexos.La metodologia de la programa ió aporta una sèrie de tè niques que permeten desenvoluparaquestes a ions més omplexes a partir de les més simples, així om onstruir i treballar ambobje tes més omplexos a partir dels més simples. Aquestes tè niques permeten dur a termeaquestes tasques de forma orre ta, òmoda i entenedora.En el as de les a ions, la tè ni a més simple vista �ns ara és l'ús de les estru turesalgorísmiques per onstruir a ions no elementals:• Des omposi ió seqüen ial.• Des omposi ió alternativa: Anàlisi per asos.• Des omposi ió iterativa: Una a ió s'ha de repetir un ert nombre de vegades.En aquest urs es repassaran i veuran altres tè niques om són:1

2 CAPÍTOL 1. ESQUEMES ALGORÍSMICS• disseny mitjançant seqüèn ies• disseny des endentPel que fa als obje tes, �ns ara també s'han vist els onstru tors de tipus següents:• Taula: Unió d'obje tes homogènis (del mateix tipus).• Tuple: Unió d'obje tes heterogenis.Com a tè niques noves, es veurà om de�nir nous tipus de dades, espe i� ant les opera- ions que s'hi poden fer. Es treballarà l'espe i� a ió d'un tipus de dades, les seves possiblesimplementa ions i el seu ús des de determinats algorismes.1.2 Abstra ió i seqüèn iesL'abstra ió és un me anisme de la ment humana que permet estudiar i omprendre fenòmensque impliquen gran quantitat de detalls. L'abstra ió té dos aspe tes omplementaris:• Es destaquen els aspe tes que ens resulten més rellevants dels obje tes que s'estudien.• S'ignoren els detalls que són irrellevants de l'obje te en el nivell d'abstra ió en quès'està treballant. Entenem que potser són irrellevants en aquest nivell d'abstra ió peròque, en un altre nivell d'abstra ió, potser alguns detalls passaran a ser rellevants.L'abstra ió permet estudiar fenòmens omplexos seguint un mètode jeràrqui , és a dir,per nivells de detall su essius. La majoria de vegades se segueix una dire ió des endent, desde nivells de menys detalls �ns als de més detalls o més espe í� s.La programa ió és un exemple lar de l'abstra ió om a me anisme per disminuir la omplexitat dels problemes que ens proposem resoldre. Podríem dir que la història de laprograma ió és un amí ap a un grau ada op més alt d'abstra ió.Els passos que s'han de seguir a partir d'un problema �ns que es té un programa que resolaquest problema ne essiten, en general, un grau elevat d'abstra ió. Això és degut a què hemd'expressar la solu ió d'un problema real en un llenguatge de programa ió.Aquesta idea d'abstra ió, desta ant erta informa ió i o ultant-ne una altra, es realitza,dins de la programa ió, tant quant a a ions i fun ions om pel que fa a les dades. Perexemple, l'abstra ió fun ional rea a ions i fun ions de manera que es desta a què fa unafun ió i s'ignora om ho fa. Un exemple onegut d'apli a ió a les dades d'aquestes idees és la rea ió de tipus de�nits pel programador, que permeten la de�ni ió de dades més pròximes alproblema que es vol resoldre.El mètode que més s'utilitza en el disseny de programes no massa grans és l'anomenatdisseny des endent, que és un mètode jeràrqui en dire ió des endent. Aquest on epte estornarà a veure durant aquest urs amb més profunditat.Un altre exemple onegut on s'apli a l'abstra ió quant a les dades és el on epte deseqüèn ia.

1.2. ABSTRACCIÓ I SEQÜÈNCIES 3Seqüèn iesUna seqüèn ia és un on epte que permet entendre un onjunt de dades, és a dir, una seqüèn iaés una forma d'estru turar la informa ió que s'obté a partir de l'abstra ió del on epte dellista d'informa ió.Aquesta forma d'estru turar la informa ió està rela ionada amb el disseny d'algorismesiteratius. Generalment, una estru tura iterativa impli arà el tra tament d'una seqüèn ia.De�ni ióUna seqüèn ia és una llista �nita d'elements tal que:• És possible identi� ar un primer element.• Hi ha un element �nal o bé es pot ara teritzar el �nal de seqüèn ia.• Per a tot element, diferent del darrer, n'hi ha un de següent.El primer element possibilitarà l'a és a la resta de la seqüèn ia. Per a ada seqüèn iahi ha un me anisme que permet obtenir un nou element (el següent) a partir d'un elementdonat. És possible saber si una seqüèn ia s'ha a abat o no. S'utilitzarà, generalment, unamar a o sentinella. Habitualment les seqüèn ies són homogènies (tots els seus elements sóndel mateix tipus). Els elements de les seqüèn ies poden ser des d'obje tes de tipus elementals( om enters o arà ters) �ns a obje tes de tipus molt més omplexos.ExempleAlgorisme que al uli la suma dels n primers naturals.algorisme Sumavari, total: enterfvari:=1 { A és al primer element}total:=0 { Ini ialitza ió del tra tament}mentre i ≤ n fer { La ondi ió d'últim element és que sigui el n}total := total + i { Tra tament de ada element}i:= i+1 { A és al següent element}fmentrefalgorismeEn general, quan utilitzem una estru tura iterativa haurem de ara teritzar una seqüèn- ia que serà manipulada per aquesta estru tura. Cara teritzar una seqüèn ia vol dir indi ar:• Quin és el primer element de la seqüèn ia.• Com obtenir el següent element.• Com saber que s'ha a abat la seqüèn ia.Nota: El �nal d'una seqüèn ia es pot determinar de diferents maneres:

4 CAPÍTOL 1. ESQUEMES ALGORÍSMICS• Podem onèixer quin és el darrer element de la seqüèn ia. Aquest element, om que ésun element de la seqüèn ia, al tra tar-lo.• La seqüèn ia pot a abar en un element espe ial, que onsiderarem que no és de laseqüèn ia i anomenarem mar a o sentinella. L'element sentinella no s'ha de tra tar.• Podem onèixer quans elements té la seqüèn ia.Estat d'una seqüèn iaUn altre on epte que al tenir en ompte és el d'estat d'una seqüèn ia. L'estat d'una seqüèn ia

S es determina per:• La part esquerra de S, pe(S), que és la part a què ja hem a edit.• L'element en urs, en_ urs(S), que és l'element què estem a edint.• La part dreta de S, pd(S), que és la part de la seqüèn ia a la qual en ara hem d'a edir.

S

pe (S) pd (S)

en_curs (S)Figura 1.1: Estat d'una seqüèn ia.Per treballar amb una seqüèn ia dins d'un algorisme, al de larar una variable del tipusadequat per a un element de la seqüèn ia. Aquesta variable anirà ontenint su essivamenttots els elements de la seqüèn ia.Opera ions sobre una seqüèn iaLes opera ions sobre seqüèn ies, utilitzant aquesta nota ió, es poden des riure de forma ge-nèri a de la manera següent:Ini ialitza ió. Prepara la seqüèn ia perquè omen i a ser tra tada. El resultat d'aquestaopera ió seràpe(S) = ∅, en_ urs(S) = ∅ i pd(S) =S.ObtenirElement. Obten ió del següent element del que es té ara en urs. Si l'estat de laseqüèn ia erape(S) = α , en_ urs(S) = a i pd(S) = xβ,el resultat d'aquesta opera ió seràpe(S) = αa , en_ urs(S) = x i pd(S) = β.FiSeqüèn ia. És un predi at que és ert quan l'estat de la seqüèn ia es tal que pd(S) = ∅.Aquest predi at generalment s'implementa om una expressió o una fun ió booleana.

1.3. ESQUEMA DE RECORREGUT 5En els algorismes que es dissenyen usant el mètode de les seqüèn ies, hi apareixen lesa ions que permeten a edir al primer element i als elements següents. L'a ió per a ediral primer element orrespon a l'apli a ió de les dues opera ions genèriques Ini ialitza iói ObtenirElement; aquesta a ió es representa om ObtenirPrimer (S, x). L'a ió pera edir a l'element següent orrespon a l'apli a ió de l'opera ió genèri a ObtenirElement ies representa om ObtenirSeguent(S, x). També s'utilitzarà la fun ió per dete tar el �nal dela seqüèn ia: FiSequencia(S, x).Programa ió amb esquemesMolts problemes es resolen fent servir la mateixa estratègia. Algunes d'aquestes estratègies sónprou importants perquè siguin estudiades per elles mateixes. Aquestes estratègies s'anomenenesquemes. En aquest urs es re ordaran dos esquemes ja oneguts, l'esquema de re orregut il'esquema de er a, però hi ha d'altres esquemes.La utilitza ió d'un esquema en la resolu ió d'un problema on ret requereix un elevat graud'abstra ió.1.3 Esquema de re orregutL'esquema de re orregut engloba tots els algorismes que han de generar i tra tar sempre totsels elements de la seqüèn ia.L'esquema general de re orregut és:IniciT ractament(T )ObtenirPrimer(S, x)mentre ¬FiSequencia(S, x) fer

Tractar(T, x)ObtenirSeguent(S, x)fmentre

Tractar(T, x)Les a ions ObtenirPrimer (S, x), ObtenirSeguent (S, x) i la fun ió FiSequen ia (S, x)s'obtenen fà ilment de la ara teritza ió de la seqüèn ia.L'a ió Tra tar (T,x) després del mentre s'ha de fer quan FiSequen ia (S, x) indi a quex és el darrer element de la seqüèn ia. I no s'ha de fer quan FiSequen ia (S, x) indi a que xés l'element sentinella. En aquest as Tra tar (T,x)= ∅.Aquesta a ió, Tra tar (T,x), pot ser omplexa (poden haver-hi diversos tra taments) i, amés, els tra taments poden ser diferents segons els elements de la seqüèn ia.Quan es oneix a priori el nombre exa te d'elements de la seqüèn ia, long, es pot usarl'estru tura repetitiva per:IniciT ractament(T )i := 1mentre ¬(i > long) fer

ObtenirElement(S, x)

6 CAPÍTOL 1. ESQUEMES ALGORÍSMICSTractar(T, x)i := i + 1fmentreA ontinua ió es resol el problema 4.4 de [10℄.Enun iatAigües avall d'As ó, a la riba de l'Ebre, hi ha un aparell que mesura la intensitat de laradia ió emesa per les aigües del riu. Aquest aparell envia el valor mesurat ada δ minutsa un omputador dedi at i �nalitza la seqüèn ia amb una mesura espe ial de valor -1.0. El omputador imprimeix a ada interval de temps δ les dades següents:• el valor de la mesura,• el valor de la mitjana de totes les dades rebudes �ns al moment i• el arà ter '*', om a indi atiu de perill, si la distàn ia entre la mesura i la mitjanasupera un llindar pre�xat, LLINDAR.S'ha de dissenyar l'algorisme que de�neix el omportament d'aquest omputador. Podeusuposar que existeix el subprograma següent:

{Obté Mesura}a ió ObteMesura(sor m : real)Resolu ióCara teritza ió de la seqüèn ia: Els elements de la seqüèn ia són reals orresponents aintensitats de radia ions. Les a ions ObtenirPrimer (S, x) i ObtenirSegüent (S, x) onsisteixenen simples le tures que provenen de l'aparell de mesura i que s'obtindran amb el subprogramadonat. El �nal de la seqüèn ia el dóna un element sentinella de valor -1.0.Tra tament: Cal fer tres tra taments als elements de la seqüèn ia. El primer onsisteixa es riure el mateix valor llegit. El segon és el àl ul de la mitjana i omportarà omptar isumar els valors (tra taments que requereixen la orresponent ini ialitza ió). El ter er, queés el missatge d'avís en as que se superi el llindar, ne essitarà una estru tura ondi ional.algorisme Asco onstLLINDAR : real = 50{milisiever}f onstvarmesura, suma,mitjana : realn : enterfvar

{Ini ialitza ió dels tra taments que ho requereixen}n := 0suma := 0{Obtenir primer element}

1.4. ESQUEMA DE CERCA 7ObteMesura(mesura)mentre mesura 6= −1.0 fer{Tra taments}EscriureReal(mesura)n := n + 1suma := suma + mesuramitjana := suma/EnterAReal(n)EscriureReal(mitjana)si abs(mesura−mitjana) > LLINDAR → EscriureCaracter(`*')⊓⊔ abs(mesura−mitjana) <= LLINDAR →fsi{Obtenir següent element}ObteMesura(mesura)fmentrefalgorismeNOTES• Cal tenir lar quines variables s'han d'ini ialitzar a 0 i quines no i on s'ha de fer aquestaini ialitza ió. Les variables n i suma són variables asso iades a pro essos a umulatiusi, per això, són les úniques que s'han d'ini ailitzar a 0; el llo on s'ha de fer és el que orrespon a l'ini i de tra tament.• La variable mitjana no està asso iada a ap pro és a umulatiu: ni s'ha d'ini ialitzar a

0 ni s'ha de al ular en fun ió del valor a la itera ió anterior.1.4 Esquema de er aL'obje tiu de l'esquema de er a és saber si hi ha un element de la seqüèn ia que estem tra tantque satisfa i una determinada propietat.L'esquema de er a engloba els algorismes en què no al generar i tra tar tots els elementsde la seqüèn ia.L'esquema de er a ha de permetre sortir del bu le de repeti ions no només quan s'arribaal �nal de la seqüèn ia sinó també quan es troba un element que ompleix la propietat ques'està er ant.Es presenten dos esquemes: un que usa dire tament aquesta propietat de er a i un altreque fa servir una variable booleana.L'esquema dire te és el següent:ObtenirPrimer(S, x)mentre ¬FiSequencia(S, x) ∧ ¬PropietatCerca(x) fer

ObtenirSeguent(S, x)fmentreEl predi at que es ompleix al �nal de l'estru tura mentre és:

8 CAPÍTOL 1. ESQUEMES ALGORÍSMICS{ ¬FiSeqüèn ia (S, x) =⇒ PropietatCer a (x) ∧( ∀i; xi ∈ pe(S) ; ¬ PropietatCer a (xi) ) }En aquest esquema, quan x és el sentinella, la fun ió PropietatCer a s'avalua per a aquestsentinella, i això, en alguns asos, pot provo ar un error.L'esquema amb variable booleana, que es mostra a ontinua ió, evita l'apli a ió de lapropietat de er a a elements que no són de la seqüèn ia.ficerca := falsObtenirPrimer(S, x)mentre ¬FiSequencia(S, x) ∧ ¬ficerca fersi PropietatCerca(x) → ficerca := ert⊓⊔ ¬PropietatCerca(x) → ObtenirSeguent(S, x)fsifmentreEl predi at que es ompleix al �nal de l'estru tura mentre és:{ � er a =⇒ PropietatCer a (x) ∧ ( ∀i; xi ∈ pe(S) ; ¬PropietatCer a (xi) ) }Per tant, quan l'a abament de la seqüèn ia és donat pel sentinella, és re omanable usarl'esquema amb variable booleana.Quan l'a abament de la seqüèn ia és donat pel darrer element, aquest problema no espresenta i, per tant, es pot usar qualsevol dels dos esquemes vistos. Ara bé, om en el as delsesquemes de re orregut, en sortir de l'estru tura mentre aldrà omprovar si la propietat de er a es ompleix per al darrer element.A ontinua ió es resol el problema 4.13 de [10℄.Enun iatDonat un polígon om una seqüèn ia de vèrtexs a abada amb el vèrtex ini ial, onstruïuun algorisme que pugui esbrinar si és un polígon regular o no. Els vèrtexs són determinats peruna seqüèn ia de parells de reals que l'usuari introdueix pel te lat. El resultat, al es riure'lper la sortida estàndard. Considereu que om a mínim hi ha tres vèrtexs.Resolu ióUn polígon és regular si totes les seves arestes tenen la mateixa longitud. Per tant, l'es-tratègia a seguir en aquest problema serà partir de la longitud d'una aresta de referèn ia, quepot ser la primera, i anar omparant les longituds de la resta d'arestes amb la de referèn ia�ns a trobar-ne una que sigui diferent o �ns a arribar al �nal del polígon.Cara teritza ió de la seqüèn ia: Els elements de la seqüèn ia seran les arestes del polígonamb les seves longituds, des de la segona �ns a la darrera. Les arestes són de�nides mitjançantels seus dos vèrtexs ini ial i �nal, i la seva longitud es pot al ular a partir de la fórmula dela distàn ia eu lidiana.Se suposa que els vèrtexs són donats en l'ordre del seguiment del ontorn, de manera queel vèrtex �nal d'una aresta és el vèrtex ini ial de l'aresta següent. També se suposa que hiha un mínim de tres vèrtexs (ja que no es pretén tra tar els asos degenerats de polígons demenys de tres vèrtexs).Primer aldrà obtenir la longitud de l'aresta ini ial de referèn ia. Aquesta primera arestas'obté llegint els dos primers vèrtexs del CSE.

1.4. ESQUEMA DE CERCA 9A ontinua ió s'obtindran les arestes següents. Cada aresta de les següents tindrà om avèrtex ini ial el vèrtex �nal de l'aresta anterior; el seu vèrtex �nal aldrà llegir-lo del CSE. Lalongitud s'haurà de al ular.Fi de seqüèn ia: La ondi ió que ens dóna l'enun iat ens permet dete tar quan obtenimla darrera aresta. Caldrà guardar el vèrtex ini ial en una variable auxiliar.La sortida al CSS serà un arà ter R o I, depenent del resultat.Usarem el tipus Punt per representar els vèrtexs del polígon.Com que la ondi ió de � de seqüèn ia és donada pel darrer element, es pot apli ar qualsevoldels dos esquemes de er a. Apli arem el dire te. En sortir de l'estru tura mentre aldrà omprovar la propietat de er a per al darrer element.algorisme PoligonRegulartipusPuntftipusvarpi, pf, paux : Puntlongref, longitud : realfvar

{Obtenir la primera aresta de referèn ia i la seva longitud}pi := LlegirPunt()pf := LlegirPunt()longref := Distancia(pi, pf){Guardar el primer punt a una variable auxiliar}paux := pi{Obtenir primer element: segona aresta}pi := pfpf := LlegirPunt()longitud := Distancia(pi, pf){pro és de er a}mentre ¬PuntsIguals(pf, paux) ∧ longitud = longref fer{Obtenir següent aresta}pi := pfpf := LlegirPunt()longitud := Distancia(pi, pf)fmentresi longitud = longref → EscriureCaracter(`R')

⊓⊔ longitud 6= longref → EscriureCaracter(`I')fsifalgorismeA ontinua ió es de�neix el tipus Punt i s'implementen els subprogrames que hi treballen.tipusPunt = tupla

x, y : real

10 CAPÍTOL 1. ESQUEMES ALGORÍSMICSftuplaftipusfun ió LlegirPunt() retorna Puntvar p : Punt fvarLlegirReal(p.x)LlegirReal(p.y)retorna p�un iófun ió PuntsIguals(ent p1, p2 : Punt) retorna booleàretorna (p1.x = p2.x ∧ p1.y = p2.y)�un iófun ió Distancia(ent p1, p2 : Punt) retorna realretorna (arrelq(quadrat(p1.x− p2.x) + quadrat(p1.y − p2.y)))�un ióUna variant d'aquest problema seria aquella en què les dades són donades de la manerasegüent: primer un enter indi ant el nombre de vèrtexs i, tot seguit, els vèrtexs sense repetirel primer.1.5 Esquema de er a en taulesTenim la de�ni ió de tipus següent:tipusTau = taula [1..10] de enterftipusQuan treballem amb la seqüèn ia d'elements d'aquesta taula, per determinar quan s'a abala seqüèn ia, podem usar el riteri del sentinella (els elements de la seqüèn ia Si són els que ompleixen i ≤ 10) o bé el riteri del darrer element (i = 10).Si apliquem el riteri del sentinella, tal om s'ha vist a l'apartat anterior, també és re o-manable usar l'esquema amb variable booleana:vart : Taui : enterfvar

ficerca := falsi := 1

1.6. BIBLIOGRAFIA RELACIONADA 11mentre i ≤ 10 ∧ ¬ficerca fersi PropietatCerca(t[i]) → ficerca := ert⊓⊔ ¬PropietatCerca(x) → i := i + 1fsifmentreAl �nal, la variable � er a indi a el resultat de la er a.Si apliquem el riteri del darrer element, podem apli ar qualsevol esquema. Vegem l'es-quema dire te:vart : Taui : enterfvar

i := 1mentre i < 10 ∧ ¬PropietatCerca(t[i]) feri := i + 1fmentreAl �nal, al avaluar PropietatCer a (t[i℄) per onèixer el resultat de la er a.El que NO es pot apli ar és l'esquema dire te amb sentinella.vart : Taui : enterfvar

i := 1mentre i ≤ 10 ∧ ¬PropietatCerca(t[i]) feri := i + 1fmentreja que podríem intentar a edir al omponent t[11℄, que és una posi ió de memòria no de la-rada, i, per tant, estaríem ometent un error.1.6 Bibliogra�a rela ionadaAquest repàs es pot ampliar amb el llibre [11℄

12 CAPÍTOL 1. ESQUEMES ALGORÍSMICS

Capítol 2Anàlisi des endent2.1 Introdu ióEn aquest apítol ampliarem la part metodològi a de la programa ió. Fins ara oneixemuna nota ió algorísmi a que ens permet expressar de forma lara i no ambigüa els algorismesque volem proposar. També hem aprés a dissenyar els nostres primers algorismes utilitzantunes pautes metodològiques basades en l'apli a ió d'esquemes a problemes de tra tamentseqüen ial. L'ús d'aquests esquemes ens ha ajudat a evitar possibles errors i també a formularalgorismes intel·ligibles.Tot i això, els problemes en que hem apli at aquestes tè niques són relativament senzills, enel sentit en que els seus enun iats fan referèn ia a obje tes que són dire tament representablesamb els tipus elementals de la nota ió algorísmi a, i el que al fer amb els obje tes és fà ilmentexpressable amb un petit onjunt d'a ions elementals de l'algorisme a proposar.Els enun iats per apli a ions més reals són més omplexos. Els enun iats omplexos fanreferèn ia a obje tes que no tenen una orrespondèn ia dire te amb els tipus elementals de lanota ió algorísmi a. A més, el tra tament d'aquests obje tes pot no ser elemental i pot portara un nombre de sentèn ies i de lara ions ex essivament gran si expressem tot el que al fer om una omposi ió seqüen ial d'assigna ions, itera ions, i/o alternatives. El resultat és unalgorisme de moltes pàgines difí il de seguir, i per tant de saber si fun iona. Està tan ple dedetalls (alguns ops repetits) que el fan prà ti ament il·legible.Re ordeu que hem de dissenyar algorismes orre tes i raonablement e� ients, però també al que aquests siguin a la vegada llegibles ja que sovint al mantenir-los o ampliar-los. Perfer-ho ens al aprendre dos nous on eptes:• L'abstra ió• El mètode d'anàlisi i disseny des endentAtés que la legibilitat de l'algorisme és força important, els dos nous on eptes haurande quedar re�e tits en el propi disseny de l'algorisme i per aquest motiu, no sols parlem delmètode d'anàlisi des endent, sino també de disseny des endent.2.2 Con eptes bàsi s del mètode de disseny des endentPer abstra ió entenem el pro és de simpli� ar una realitat reduïnt-la només a aquells aspe tesque tenen una espe ial rellevàn ia pel que estem pensant o fent. Com ja s'ha esmentat a13

14 CAPÍTOL 2. ANÀLISI DESCENDENTEnunciat

deProblemaComplexe

Identificació delsnivells d’abstracció

Disseny del subproblema

principal

Enunciat/dissenysubproblema 3.1

Enunciat/dissenysubproblema 3.2

Enunciat/dissenysubproblema 3.3

Enunciat/dissenysubproblema 3.M

Nivellabstracció 3

Nivellelemental

subproblema 2.1Enunciat/dissenysubproblema 2.2

Enunciat/dissenysubproblema 2.3

Enunciat/dissenysubproblema 2.N

Enunciat/disseny

Nivellabstracció 1

Nivellabstracció 2

?????????

Figura 2.1: disseny des endentl'anterior apítol, l'abstra ió ja l'hem usat quan hem parlat del model de seqüèn ia, elsesquemes (algorismes abstra tes), et .La idea bàsi a del disseny des endent és la de des omposar un problema omplex en un onjunt de subproblemes independents més senzills de resoldre, i la solu ió d'aquests porta a lasolu ió global del problema. En la �gura 2.1 s'il·lustra la des omposi ió del problema prin ipalen diversos subproblemes, que a més separem en nivells. Cada nivell inferior és més proper alnivell elemental de la nota ió que el seu inmediat superior. En ada nivell de des omposi ióes treballa una o més abstra ions sense pensar en om es resoldran els seus detalls. En el seunivell inmediat inferior es tindrà en ompte els detalls que no s'han tingut en ompte en elsnivells superiors.El nom de des endent ve del fet que es parteix del nivell superior i es va baixant a nivellsinferiors de forma gradual. Fer-ho al revés porta a perdues de temps. No es pot saber quène essitem dissenyar si abans no hem resolt els nivells superiors. O dit d'una altra forma, ésdifí il imaginar quins subproblemes al enun iar si en ara no hem intentat resoldre el problemageneral.No tota des omposi ió d'un problema en subproblemes és bona per desenvolupar un bondisseny. La des omposi ió s'hauria de basar en algun riteri adient. Aquest riteri surt del'ele ió d'unes abstra ions onvenients i naturals al problema. Es tra ta de pensar el pro-bleme en termes naturals de l'enun iat, en omptes de fer-ho en termes dels elements bàsi sde l'algorísmi a.La millor forma de seguir introduïnt el mètode és veient om s'apli a. Per això farem unexemple, del qual no ens hem de quedar amb la solu ió algorísmi a �nal, sino veure óm es varesolvent. En la resolu ió seguirem des rivint el mètode.

2.3. EXEMPLE PER UNA INTRODUCCIÓ PRÀCTICA DEL MÈTODE 152.3 Exemple per una introdu ió prà ti a del mètodeImagineu que tenim el següent enun iat:2.3.1 Enun iatL'empresa CONTROL S.A. vol onèixer quin dels seus empleats ha treballat més hores al llarg d'unperíode de temps. Per això, ens demana un algorisme que a partir de les dades introduïdes per unoperador ens tregui pel anal estàndard de sortida el nom de l'empleat amb més hores treballades, iquantes hores de més ha fet respe te la mitjana d'hores treballades per tots els empleats.Un operador introduirà les dades en un omputador posant per ada empleat, el seu nom ( om amolt 30 arà ters), seguit d'una seqüèn ia de dades provinents d'un rellotge de ontrol de presèn iaque indi a les seves entrades i sortides a l'empresa. La seqüèn ia del rellotge està organitzada enagrupa ions de tres en tres enters. Cada triplet d'enters indi a hores, minuts i segons. L'operadorintrodueix triplets un darrere l'altre �ns arribar al triplet (-1,0,0) que es onsidera la mar a de �nal.La seqüèn ia de triplets al onsiderar-la om la història d'hores d'entrada i sortida d'un ert empleatde l'empresa. L'empleat amb nom 'FI' a abarà l'entrada de dades de tots els empleats.Notes:• La seqüèn ia estarà ben formada: Pot ser buida pel fet de que nomes surt el nom 'FI' o be lesseqüèn ies de rellotge poden ser buides (-1 0 0): l'empleat no ha treballat en aquest període.Si hi ha un triplet vàlid om a hora d'entrada tindrà a ontinua ió una hora de sortida vàlida.• Cal tenir en ompte que pot haver una jornada laboral entre dos dies.• En el as po probable (es ompten els segons) de oin idèn ia d'hores, l'empleat afortunat seràel primer.2.3.2 Solu ióSi analitzem la seqüèn ia d'entrada de l'enun iat, aquesta tindria la següent forma:

ne1h11m11s11 . . . h1jm1js1j . . . h1n1m1n1

s1n1hfmfsf . . .

neihi1mi1si1 . . . hijmijsij . . . hinimini

sinihfmfsf . . .

nenhn1mn1sn1 . . . hnjmnjsnj . . . hnnnmnnnsnnnhfmfsf . . . nfon les nei són a la vegada seqüèn ia de arà ters a abades amb un espai (nom de l'empleat),i les hij, mij, sij (hores, minuts i segons) són enters (sequèn ia de arà ters dìgits), hf , mf ,sf es refereix a la tripleta (-1, 0, 0) que fa de sentinella, els subindexs ni

al nombre de tripletesque li segueix a ada nom nei. Com es pot veure, és força ompli at plantejarse el problemaen aquests termes, ja que es pot rear ert grau de onfusió degut a la quantitat de detallsque al tenir en ompte.2.3.3 Abstra ió de dades d'empleatMés fà il es presenta el plantejament ini ial del problema si fem la següent abstra ió: Laseqüèn ia d'entrada és una seqüèn ia d'empleats ei:e1e2 . . . en, efOn ef és l'empleat sentinella (el que té per nom 'FI'), i n és el nombre d'empleats presentsa la seqüèn ia.Fixeu-vos que l'abstra ió d'Empleat (dades d'empleat, per ser més pre ís) la deduïm delsobje tes pròpis de l'enun iat a resoldre. Això ens passarà sovint.

16 CAPÍTOL 2. ANÀLISI DESCENDENTTot i que podem veure que ei ≡ neihi1mi1si1 . . . hijmijsij . . . hinimini

sinihfmfsf , de po ens servirà l'abstra ió feta en aquesta primera etapa del plantejament i disseny, si ens �xemen óm resoldrem els seus detalls ara amagats per l'abstra ió.La seqüèn ia d'empleats (e1e2 . . . en, ef ) permet fer un plantejament al nostre abast: Elproblema s'assembla a altres problemes més senzills i oneguts que ja hem resolt altres ve-gades (seqüèn ia de arà ters, et ). Només al apli ar la metodologia apresa per resoldre elsproblemes ja oneguts.Comen em per espe i� ar el problema:algorisme controlHorari{Pre: Pel CSE tenim la seqüèn ia S ≡ e1e2 . . . en, ef on ei són dades d'empleatsd'una empresa.}{Post: : Si S no és buida, pel CSS tenim nem h1 h2 on nem és el nom delprimer empleat ek present a S tal que les seves hores treballades (h1) són méso igual que la de qualsevol ei, 1 ≤ i ≤ n. h2 = h1 − hm on hm és la mitjanad'hores treballades per ei, 1 ≤ i ≤ n. Si S és buïda, el programa no es riu resal CSS.}Comen em el plantejament pensant om obtindrem els elements de la seqüèn ia, identi�- ant om s'a edeix al seu primer element, al següent, i es re oneix el darrer. Normalment,en altres problemes més senzills, aquesta identi� a ió resultava en un seguit d'instru ionselementals de la nota ió. Com que la idea del nostre plantejament és no entrar en detallsde l'abstra ió onvinguda en aquesta etapa del plantejament i disseny, ne essitarem inventara ions, fun ions i tipus que ens ho permetrà fer.Comen em don s, suposant que tenim un tipus tEmpleat:

• Per a obtenir el primer element invo arem una a ió que anomenarem llegirEmpleat.• L'a ió anterior la farem servir per obtenir el següent empleat.• El darrer element es re oneixerà invo ant la fun ió empleatSentinella.Ara pensem en el tra tament. Es tra ta de saber quin empleat ha treballat més hores.Per fer-ho, aldrà fer un re orregut per tots els empleats de la seqüèn ia, i omprovar quind'aquests és el primer que supera les hores dels altres. Per saber la mitjana d'hores, aldrà onsultar també les hores de tots els empleats, i amb el nombre d'empleats deduïr la mitjana.Per ada empleat a umulem les seves hores en una variable (sumaHores). Per tant, hemde idit apli ar l'esquema de re orregut sobre la seqüèn ia, i a ontinua ió tenim el següentesborrany amb parts que en ara falten per omplir:algorisme controlHorarivar e : tEmpleat

. . .fvartra tament ini ialllegirEmpleat(e);mentre ¬empleatSentinella(e) fertra tar element

llegirEmpleat(e)fmentre;tra tament finalfalgorisme

2.3. EXEMPLE PER UNA INTRODUCCIÓ PRÀCTICA DEL MÈTODE 17El tra tament per ada empleat serà onsultar el seu nombre d'hores treballades ambla d'un altre empleat previ que es onsidera el millor. Si l'empleat a tual supera al millor,substituïm el millor per l'a tual. Aquesta idea suposa que ja hi ha un empleat previ, i pertant, aldrà ini ialitzar l'empleat millor.El tra tament ini ial haurà de rear l'empleat millor ini ial que pot ser el primer de laseqüèn ia però s'ens pot ompli ar el disseny pel fet de que la seqüèn ia pot ser buïda. Unaaltra forma de fer-ho seria rear un empleat ini ial � ti i que no perjudiqui el nostre obje tiude trobar el millor. Per exemple, un que ha treballat -1 hores, serà fà ilment superable. Perla mitjana, aldrà ini ialitzar sumaHores a zero.El tra tament �nal, en el as que la seqüèn ia no hagi resultat buïda, onsistirà en es riureel nom i hores de l'empleat millor, al ular la mitjana i trobar la diferèn ia. L'algorisme queda:algorisme controlHorarivar e, eMillor : tEmpleatsumaHores : real;nEmpleats : enter;fvar

nEmpleats := 0;sumaHores := 0.0;creaEmpleatF ictici(eMillor);llegirEmpleat(e);mentre ¬empleatSentinella(e) fersi hores(e) > hores(eMillor) → eMillor := e⊓⊔ hores(e) ≤ hores(eMillor) →fsi;sumaHores := sumaHores + hores(e);nEmpleats := nEmpleats + 1;llegirEmpleat(e)fmentre;si nEmpleats 6= 0 →

escriureEmpleat(eMillor);EscriureReal(hores(eMillor) − (sumaHores/enterAReal(nEmpleats)))

⊓⊔ nEmpleats = 0 →fsifalgorismePodeu notar que amb nEmpleats podem saber si la seqüèn ia ha estat buïda.Fixeu-vos que en ap as s'ha suposat res sobre el tipus tEmpleat. A més podem veri� arla orre tesa de l'algorisme proposat si espe i�quem què fan les a ions i fun ions inventades:a ió creaEmpleatF ictici(sor e : tEmpleat){Pre: ert }{Post: e representa l'empleat � ti i}a ió llegirEmpleat(sor e : tEmpleat){Pre: s ≡ e1 . . . enef , pe(s) = α i α = e1 . . . ei−1, pd(s) = ei·β, i β = ei+1 . . . ef ,1 ≤ i ≤ f }{Post: e representa ei, i pe(S) = α · ei i pd(S) = β}

18 CAPÍTOL 2. ANÀLISI DESCENDENTfun ió empleatSentinella(ent e : tEmpleat) retorna booleà{Pre: e = E}{Post: empleatSentinella(e) és ert si E és l'empleat sentinella. Fals en as ontrari.}a ió escriureEmpleat(ent e : tEmpleat){Pre: e = E}{Post: Pel CSS surt N i H , on N és el nom de l'empleat E i H són les horestreballades d'E.}fun ió hores(ent e : tEmpleat) retorna real{Pre: e = E}{Post: hores(e) és el nombre d'hores treballades per l'empleat E}D'aquesta forma a onseguim:1. Resoldre una part del disseny de forma independent de om es resoldran la resta de partsen ara per fer.2. Cada inven ió d'a ions, fun ions, i tipus porta a la des omposi ió del problema prin ipalen subproblemes independents: L'espe i� a ió de les a ions i fun ions proposades sónenun iats pre isos dels subproblemes a resoldre més endavant.3. Còm es resolen aquests subproblemes (a ions, fun ions) més endavant no importa siles solu ions d'aquests subproblemes satisfan els seus enun iats (espe i� a ió): No alexaminar les seves solu ions per determinar si la solu ió a la què �ns ara hem arribat és orre te.4. No al que les a ions i fun ions que queden siguin dissenyades per la mateixa personaque ha proposat la solu ió a tual. Una altra persona només ha de seguir l'espe i� a iódonada sense onèixer la solu ió �ns ara realitzada.5. La independèn ia dels subproblemes s'ha a onseguit grà ies al fet que no hem entrat entots els detalls espe í� s que s'amagan darrera de l'abstra ió onvinguda (tEmpleat,en el nostre as)Fetes aquestes observa ions, passem a dissenyar els següents nivells d'abstra ió.2.3.4 Abstra ió empleatPer dissenyar les a ions i fun ions que queden per fer, al agrupar-les d'a ord al tipus prin ipalamb el què treballen. En el nostre as, totes es refereixen al tipus tEmpleat. Atès que hemd'expressar òm ho han de fer, abans aldrà on retar que és el tipus tEmpleat. Per fer-ho,hem d'examinar el onjunt d'a ions i fun ions que treballen sobre el tipus.Aquestes a ions es poden agrupar en:1. Constru tores: onstrueixen el tipus, és a dir, dóna valor al tipus (ini ialitza ions, mo-di� a ions, et ). En el nostre as de treball tenim:• a ió creaEmpleatF ictici(sor e : tEmpleat)

• a ió llegirEmpleat(sor e : tEmpleat)

2.3. EXEMPLE PER UNA INTRODUCCIÓ PRÀCTICA DEL MÈTODE 192. Consultores: onsulten l'estat del tipus. En el nostre as de treball tenim:• fun ió empleatSentinella(ent e : tEmpleat) retorna booleà• a ió escriureEmpleat(ent e : tEmpleat)

• fun ió hores(ent e : tEmpleat) retorna realLes onsultores donen pistes de què al guardar en el tipus. En el nostre as, la post ondi iód'escriureEmpleat obliga a guardar les hores treballades per l'empleat, i el seu nom. La fun ióhores on�rma que al guardar les hores treballades. Si té el nom de 'FI' podem saber que estra ta de l'empleat sentinella. Així don s, si de�nim tEmpleat omtipus

tEmpleat = tuplanom : tNom;hores : real;ftuplaaquest serà su� ient. Noteu que hem fet una altra abstra ió: tNom. Per tant, en aquestnivell d'abstra ió no ens preo uparem dels detalls del tNom proposant aquelles a ions i/ofun ions que ens alen per treballar en aquesta nova abstra ió.La solu ió d'aquest nivell d'abstra ió és:a ió creaEmpleatF ictici(sor e : tEmpleat)

e.hores := −1.0fa ióa ió llegirEmpleat(sor e : tEmpleat)obtenirNom(e.nom)si nomFI(nom) → obtenirHores(e.hores)⊓⊔ ¬nomFI(nom) →fsifa iófun ió empleatSentinella(ent e : tEmpleat) retorna booleàretorna nomFI(e.nom)�un ióa ió escriureEmpleat(ent e : tEmpleat)escriureNom(e.nom);EscriureReal(e.hores)fa iófun ió hores(ent e : tEmpleat) retorna realretorna e.hores�un ióPer a abar el disseny ens aldrà resoldre els següents enun iats:

20 CAPÍTOL 2. ANÀLISI DESCENDENTa ió llegirNom(sor nom : tNom);{Pre: A l'entrada es té una seqüèn ia de ara terss. La part dreta de s, PD, no és buida i la part esquerra des és PE, i Pi és un nom i és el primer element de PD}{Post: nom representa Pi, i Pi estàa ontinua ió de PE a la part esquerra de s}a ió escriureNom(ent nom : tNom);{Pre: nom=NOM}{Post: A la sortida es té una seqüèn ia de arà ters orresponents als que que hi ha a nom, seguit d'un arà terespai.}fun ió nomFI(nom : tNom) retorna booleà;{Pre: nom=NOM}{Post: nomFI(nom) és ert si NOM és `FI'. En as ontrari és fals}que tra ta el tipus tNom, ia ió obtenirHores(sor h : real){Pre: pe(s) = α · nei i Hi = hi1mi1si1 . . . hijmijsij . . . hini

minisini

hfmfsf ipd(s) = Hi · γ}{Post: pe(s) = α · nei ·Hi, pd(s) = γ, i h =

∑ni

j=1(hij + mij/60 + sij/3600)}

2.3.5 Nivell nom onst MaxCaracters = 30 f onst;tipustauCar = taula [1..MaxCaracters]de arà ter;tNom = tupla

long : enter;c : tauCarftuplaftipusa ió llegirNom(sor n : tNom);var c : arà ter; i : enter; fvar

i := 0; c := llegirCaracter();mentre c = ` ' fer c := llegirCaracter() fmentre;mentre c 6= ` ' feri := i + 1; n.c[i] := c;c := llegirCaracter()fmentre;

n.long := i;fa ió

2.3. EXEMPLE PER UNA INTRODUCCIÓ PRÀCTICA DEL MÈTODE 21a ió escriureNom(ent n : tNom);vari : enter;fvar

i := 1;mentre i ≤ n.long ferEscriuCaracter(n.c[i]);i := i + 1;fmentre;

escriureCaracter(` ')fa iófun ió nomFI(nom : tNom) retorna booleà;retorna (nom.long = 2) ∧ (nom.c[1] = `F') ∧ (nom.c[2] = `I')�un ió;2.3.6 Nivell hores treballadesL'obten ió de les hores treballades durant el període d'estudi de l'empleat s'obtindrà tra tantla seqüèn ia de dades del rellotge que li segueix al nom de l'empleat. Una manera senzilla i onvenient de plantejar-ho és veure la seqüèn ia d'entrada om una seqüèn ia d'hores realit-zades a ada jornada laboral. Si així fos, la solu ió onsistiria en sumar les hores treballades(Jk) en ada jornada laboral i present a la seqüèn ia J1J2 . . . JmJf .Com que el nombre de hores de la jornada laboral és un real, no farem ap de�ni ió detipus per l'abstra ió utilitzada però si farem noves a ions i fun ions que ens ajudaran are�e tir l'abstra ió feta. La solu ió resultant d'apli ar la metodologia dels esquemes és:a ió llegirHores(sor horesTreballades : real);var j : real; fvarhoresTreballades := 0.0;llegirHoresJornada(j);mentre ¬horesJornadaSentinella(j) fer

horesTreballades := horesTreballades + j;llegirHoresJornada(j);fmentrefa ióEl nombre d'hores d'una jornada laboral està representada en la seqüèn ia original peruna hora d'entrada i una hora de sortida expressades ambdues per hora, minuts i segons:

hi1mi1si1hi2mi2si2︸ ︷︷ ︸

J1

. . . hijmijsijhi(j+1)mi(j+1)si(j+1)︸ ︷︷ ︸

Jk

. . . hi(ni−1)mi(ni−1)si(ni−1)hinimini

sini︸ ︷︷ ︸

Jm

hfmfsfEn el disseny de llegirHoresJornada onsiderarem que els instants d'entrada i sortidavan en hores de imals en omptes de hora, minuts i segons.

22 CAPÍTOL 2. ANÀLISI DESCENDENTa ió llegirHoresJornada(sor j : real)var horaE, horaS : real fvarllegirNoHores(horaE);si horaE 6= −1.0 →

llegirNoHores(horaS);si horaE ≤ horaS → j := horaS − horaE⊓⊔ horaE > horaS → j := horaS + 24.0− horaEfsi

⊓⊔ horaE = −1.0 → j = −1.0fsifa ióCom podeu observar, s'ha tingut en ompte la possibilitat de fer una jornada laboral entredos dies naturals.fun ió horesJornadaSentinella(ent j : real) retorna booleàretorna j = −1.0�un ióLa darrera abstra ió (hores de imals) només té una a ió que exposem a ontinua ió:a ió llegirNoHores(sor t : real) retorna realvar h,m, s : enter fvarLlegirEnter(h); LlegirEnter(m); LlegirEnter(s);t := EnterAReal(h) + EnterAReal(m)/60.0 + EnterAReal(s)/3600.0fa ió2.4 Més sobre el disseny des endentQuan de idim les abstra ions a fer, les podem orientar a:

• Obje tes del problema no elementals. De�nirem un tipus apropiat a l'obje te iasso iarem mitjançant a ions i/o fun ions, les opera ions que podrà tenir.• Tra tament del problema (fun ional). El tra tament del problema onvé formular-loen vàries etapes fun ionals.En l'exemple anterior les abstra ions han sigut dades de l'empleat, nom de l'empleat,hores treballades, hores jornada laboral, i hores de imals. Totes les abstra ions són obje tesnaturals de l'enun iat. Per ada abstra ió, hem agrupat el seu onjunt d'a ions i fun ions.En algunes d'elles s'han de�nit els tipus. Podem dir, don s, que hem orientat el disseny enbase als obje tes de l'enun iat.La possibilitat que ofereix la nota ió algorísmi a de de�nir noves a ions, noves fun ions ila ontru ió de nous tipus és la que ens permet re�e tir en el disseny l'anàlisi i des omposi ióefe tuats. Obtenim una altra visió sobre la utilitat d'aquestes eines:• Quan utilitzem una a ió o una fun ió en el disseny expressem en l'algorisme QUÈ alfer en aquell punt.• Quan dissenyem el os d'una a ió o una fun ió expressem COM fer el QUÈ ha de fer(el QUÈ es l'espe i� a ió de l'a ió i/o fun ió) .

2.5. PROBLEMA EXEMPLE 1 23Amb les a ions i fun ions separem els subproblemes, i els paràmetres dels subprogra-mes ens permeten omuni ar les dades que alen i els resultats assolits entre adas un delssubproblemes. Amb la onstru ió de nous tipus podem representar obje tes omplexos.La millor manera de poder assimilar la metodologia proposada és treballant diversos exer- i is.2.5 Problema exemple 1Problema 6.2 de [10℄.Enun iatConstruïu un algorisme que al uli quantes vegades es repeteix la primera paraula d'unafrase a abada en '.'. Considereu que la frase arriba pel anal d'entrada estàndar.Notes:• Abans de les paraules hi pot haver arà ters separadors.• Entre paraules hi ha, almenys, un arà ter separador.• Cada paraula està separada per un o més arà ters separadors (espai en blan , ',', ';' i':').• A la frase hi ha, almenys, dues paraules.• La última paraula porta el punt immediatament després del seu darrer arà ter.Resolu ióEn aquest problema es treballarà amb una seqüèn ia que és la seqüèn ia donada de pa-raules. Com que volem saber quants ops apareix la primera paraula, apli arem l'esquema dere orregut sobre aquesta seqüèn ia.Així don s, onvé remar ar que es tra ta d'un problema on apliquem l'esquema de re- orregut a unes dades que hem estru turat en forma de seqüèn ia i que és la seqüèn iade paraules. Observem que les paraules no són de tipus elementals i que, de fet, el que ensarriba dire tament del CSE són arà ters, els quals s'estru turen en forma de paraules.Un op hem determinat quina és la seqüèn ia a què apli arem l'esquema de re orregut,passarem a ara teritzar la seqüèn ia seguint els passos que hem vist:Ini ialitza ió: Prepara la seqüèn ia perquè omen i a ser tra tada. En aquest as, no alfer res, ja que es tra ta d'anar llegint del te lat.ObtenirElement: Obten ió del següent element del que es té ara en urs. En aquest as on ret, hem d'anar llegint les paraules del CSE i, per tant, l'obten ió del següent element ésllegir la següent paraula del CSE. Per a això utilitzarem la fun ió LlegirParaula.L'espe i� a ió d'aquesta fun ió és la següent:

{Pre : CSE = s1 . . . sn p cS , on si són separadors,p és una paraula, i c és un separador o bé '.'}fun ió LlegirParaula() retorna Paraula

{Post: CSE = S ∧ LlegirParaula() = p}

24 CAPÍTOL 2. ANÀLISI DESCENDENTDarrerElement: És, en general, una fun ió booleana que ens retorna ert quan arribemal darrer element de la seqüèn ia. En aquest problema, la fun ió booleana que ens servirà perdeterminar si hem arribat al �nal o no serà la fun ió booleana que té om a paràmetre unaparaula i que anomenem DarreraParaula.L'espe i� a ió d'aquesta fun ió és la següent:{Pre : cert}fun ió DarreraParaula(ent p : Paraula) retorna booleà{Post: DarreraParaula(p)⇔ p és una paraula que a aba en un punt}La seqüèn ia que estem tra tant a aba amb un darrer element que també ha de ser tra tat;és a dir, el darrer element de la seqüèn ia no és un sentinella, sinó un element més de laseqüèn ia.El tra tament que ha de rebre ada element de la seqüèn ia és mirar si és igual o no quela primera paraula de la frase. Si les paraules són iguals s'haurà d'in rementar el omptadord'una unitat. Per fer-ho ne essitarem una fun ió que ens permeti saber si dues paraules sóniguals. L'espe i� a ió d'aquesta fun ió és la següent:{Pre : cert}fun ió ParaulesIguals(ent p, q : Paraula) retorna booleà{Post: ParaulesIguals(p, q)⇔ p = q}Tenint en ompte aquesta ara teritza ió de la seqüèn ia, l'esquema que hem d'apli ar iel tra tament que ha de rebre ada element de la seqüèn ia, així om les onsidera ions fetes,l'algorisme prin ipal ens queda:tipus

Paraulaftipusalgorisme RepeticionsParaulavarpi, pactual : Paraulacompta : enterfvar

{Posem el omptador a 0}compta := 0pi := LlegirParaula()pactual := LlegirParaula()mentre ¬DarreraParaula(pactual) fer{Tra tament de ada element}si ParaulesIguals(pactual, pi) → compta := compta + 1⊓⊔ ¬ParaulesIguals(pactual, pi) →fsi{A edim al següent element}pactual := LlegirParaula()fmentre

2.5. PROBLEMA EXEMPLE 1 25{Tra tament de la darrera paraula}si ParaulesIguals(pactual, pi) → compta := compta + 1⊓⊔ ¬ParaulesIguals(pactual, pi) →fsiEscriureEnter(compta)falgorismeAquest algorisme és el primer nivell de la resolu ió del nostre problema. Treballa ambobje tes de tipus Paraula, que no ha estat de�nit en ara. A més, utilitza subprogrames queno han estat dissenyats en ara. Això no és ap problema per anar avançant en la resolu iódel problema.Els subprogrames que hem de dissenyar són els que s'han espe i� at abans.Observem que tots els subprogrames treballen amb obje tes de tipus Paraula, i, per tant,podem on loure que el primer nivell d'aquest algorisme treballa amb aquest tipus i que no al onèixer om està de�nit ni dissenyat.Per resoldre el segon nivell de resolu ió, en primer llo hem de de�nir el tipus Paraula.Per fer-ho hem de tenir en ompte quines a ions i fun ions s'han de dissenyar amb el tipusParaula. D'una Paraula, ne essitem saber si és o no la darrera, és a dir si a aba o no en unpunt, i ne essitem saber si dues paraules són iguals o no, és a dir si tenen o no els mateixos arà ters. A més, haurem de saber obtenir una Paraula a partir de la informa ió que ensarriba del CSE.Per aquest motiu de�nim el tipus Paraula així: guardarem els arà ters que la formen, unenter que ens diu quants arà ters té la paraula i un booleà on emmagatzemarem informa iósobre si aquesta paraula és la darrera o no.tipusParaula = tupla

numcar : entermot : TauCardarrera : booleàftupla

TauCar = taula [0, 19] de arà terftipusAra, un op hem de�nit el tipus Paraula, ja podem passar al disseny de les a ions ifun ions que ens falten, tenint en ompte les espe i� a ions que hem donat.Començarem per la més senzilla, que és DarreraParaula:fun ió DarreraParaula(ent p : Paraula) retorna booleàretorna p.darrera�un ióTot seguit passem a dissenyar l'a ió ParaulesIguals. L'estratègia que seguirem per dis-senyar aquest algorisme és anar mirant els arà ters de ada una de les dues paraules queformen els paràmetres d'entrada i que orresponen a la mateixa posi ió �ns arribar a trobaruna parella de arà ters diferents. Per tant, apli arem un esquema de er a a una seqüèn iade parelles de arà ters que formen, respe tivament, les dues paraules que són els paràmetres

26 CAPÍTOL 2. ANÀLISI DESCENDENTd'entrada. La ondi ió de er a que estem bus ant és trobar una parella formada per dos a-rà ters diferents. Ara bé, notem que, si dues paraules no tenen el mateix nombre de arà ters,segur que no són iguals; per tant, en primer llo mirarem si les dues paraules donades tenen ono la mateixa longitud. En el as que les dues paraules tinguin la mateixa longitud, apli areml'esquema de er a utilitzant la versió amb booleà a � d'evitar l'a és a posi ions de taules de arà ters que no tinguin sentit. En aquest as, de la seqüèn ia de parelles de arà ters queestem tra tant, oneixem el nombre d'elements que té: és igual a la longitud de les paraulesdonades.La seqüèn ia està formada pels arà ters de ada una de les dues paraules donades i orresponents a la mateixa posi ió. Per tant, l'algorisme ParaulesIguals és el següent:fun ió ParaulesIguals(ent p, q : Paraula) retorna booleàvarcarp, carq : arà terncarp, ncarq, i : enteriguals : booleàfvar

ncarp := p.numcarncarq := q.numcarsi ncarp 6= ncarq → iguals := fals⊓⊔ ncarp = ncarq →

{Apli arem l'esquema de er a}i := 0iguals := ertmentre i < ncarp ∧ iguals fersi ¬IgualsLletres(p.mot[i], q.mot[i]) → iguals := fals⊓⊔ IgualsLletres(p.mot[i], q.mot[i]) → i := i + 1fsifmentrefsiretorna iguals�un ióLa darrera fun ió que ens queda per dissenyar és LlegirParaula. L'espe i� a ió d'aquestaa ió ens diu que, a partir de la informa ió que ens arriba del CSE, hem d'omplir els amps del'obje te de tipus paraula que representa la paraula en urs. Observem que una paraula estàformada per un onjunt de arà ters, i que sabem on a aba una paraula perquè ens trobemun arà ter separador, sigui un espai en blan , una oma o bé un punt. En aquest darrer as,ens indi arà que la paraula és l'última; altrament, la paraula no serà la darrera.L'estratègia que seguirem per dissenyar aquesta fun ió és l'apli a ió d'un esquema dere orregut apli at a la seqüèn ia de arà ters que ens arriben del CSE �ns a trobar un arà terseparador o un punt. Els elements de la seqüèn ia s'aniran guardant en una taula i s'aniran omptant, a � de onèixer la longitud de la paraula que estem llegint.

2.6. PROBLEMA EXEMPLE 2 27fun ió LlegirParaula() retorna Paraulavarp : Paraulacarcurs : arà terfvar

LlegirCaracter(carcurs)mentre Separador(carcurs) ferLlegirCaracter(carcurs)fmentre{Ini ialitzem el número de arà ters}p.numcar := 0mentre ¬Separador(carcurs) fer

p.mot[p.numcar] := carcursp.numcar := p.numcar + 1LlegirCaracter(carcurs)fmentre

p.darrera := EsPunt(carcurs)retorna p�un ióAquestes fun ions treballen amb el disseny del tipus paraula; de fet, ja utilitzen els arà tersdels que està formada la paraula. Notem la diferèn ia entre el tipus d'obje tes amb els quees treballa en el primer nivell (paraules) dels que s'utilitzen en el segon nivell del disseny del'algorisme ( arà ters).En un ter er nivell de l'anàlisi des endent, aldria dissenyar les fun ions booleanes següentsque treballen amb el tipus arà ter. Es deixem om a exer i i.fun ió IgualsLletres(ent l1, l2 : arà ter) retorna booleàfun ió Separador(ent c : arà ter) retorna booleàfun ió EsPunt(ent c : arà ter) retorna booleàLa fun ió IgualsLletres ha de tenir en ompte la possibilitat de que les lletres siguin ma-jús ules o minús ules i també que puguin estar a entuades.2.6 Problema exemple 2Aquest exemple és el 4.13, ja vist al apítol anterior. Aquí es resoldrà fent tres nivells d'anàlisides endent.L'algorisme prin ipal, que orrespon al primer nivell d'anàlisi des endent, farà una er a dela seqüèn ia d'entrada omprovant que totes les arestes del polígon tenen la mateixa longitud.Com que les arestes estan formades per dos vèrtexs onse utius d'un polígon, es tra taràd'una er a amb una �nestra de dos elements. L'algorisme del primer nivell, després del'anàlisi i plantejament efe tuat (re oneixement de l'a és al primer, següent, darrer elementde la seqüèn ia, identi� a ió de l'esquema i tra tament) farà servir el tipus Aresta mitjançantunes opera ions de�nides sobre aquest tipus:

28 CAPÍTOL 2. ANÀLISI DESCENDENT{Pre : CSE = p1p2S}fun ió ObtenirPrimeraAresta() retorna Aresta{Post: CSE = S ∧ ObtenirPrimeraAresta() = p1p2}

{Pre : a = p1p2 ∧ CSE = p3S}fun ió ObtenirAresta(ent a : Aresta) retorna Aresta{Post: ObtenirAresta(a) = p2p3 ∧ CSE = S}

{Pre : a = p1p2 ∧ ar = p3p4}fun ió DarreraAresta(ent a, ar : Aresta) retorna booleà{Post: DarreraAresta(a, ar)⇔ p2 = p3}

{Pre : ar = p1p2 ∧ ar = p3p4}fun ió MateixaLongitud(ent a, ar : Aresta) retorna booleà{Post: MateixaLongitud(a, ar)⇔ ‖p1p2‖ = ‖p3p4‖}algorisme PoligonRegulartipus Aresta ftipusvar a, ar : Aresta fvar{Obtenir la primera aresta de referèn ia}ar := ObtenirPrimeraAresta(){Obtenir primer element: segona aresta}a := ObtenirAresta(ar){pro és de er a}mentre ¬DarreraAresta(a, ar) ∧ MateixaLongitud(a, ar) fer

a := ObtenirAresta(a) {Obtenir següent aresta}fmentresi MateixaLongitud(a, ar) → EscriureCaracter(`R')⊓⊔ ¬MateixaLongitud(a, ar) → EscriureCaracter(`I')fsifalgorismeEn el segon nivell d'anàlisi des endent, s'han de dissenyar les opera ions del tipus Aresta,i, per això, al de�nir-ne el tipus. Pel disseny d'aquest nivell aldrà usar una altra abstra ióque orrespon al tipus Punt. Aquesta abstra ió ja s'ha utilitzat amb opera ions a l'apartat1.4.La informa ió rellevant que ne essitem pel tipus és onèixer la longitud de l'aresta persaber si dues arestes tenen la mateixa longitud (MateixaLongitud), i re onèixer si una arestaés la darrera (DarreraAresta). El re oneixement de la darrera aresta passa per omprovarsi el vèrtex origen de la primera aresta oin ideix amb el vèrtex destí de l'aresta que estem omprovant. Per tant, ne essitem guardar els vèrtexs de l'aresta. Atès que dels seus vèrtexspodem deduïr la seva longitud, l'úni a informa ió que al tenir en ompte (i guardar-la) sónels seus vèrtexs.tipus

Aresta = tuplav1, v2 : Puntftupla

Puntftipus

2.7. BIBLIOGRAFIA RELACIONADA 29fun ió ObtenirPrimeraAresta() retorna Arestavar a : Aresta fvara.v1 := LlegirPunt(); a.v2 := LlegirPunt()retorna a�un iófun ió ObtenirAresta(ent a : Aresta) retorna Arestavar a1 : Aresta fvara1.v1 := a.v2; a1.v2 := LlegirPunt()retorna a1�un iófun ió DarreraAresta(ent a, ar : Aresta) retorna booleàretorna PuntsIguals(a.v2, ar.v1)�un iófun ió MateixaLongitud(ent a, ar : Aresta) retorna booleàretorna Distancia(a.v1, a.v2) = Distancia(ar.v1, ar.v2)�un ióEn el ter er nivell d'anàlisi des endent, s'han de dissenyar les opera ions del tipus Punt,i, per això, al de�nir-ne el tipus. Vegeu l'apartat 1.4.NOTES• El disseny del tipus Punt no ondi iona ni l'algorisme prin ipal ni les implementa ionsde les opera ions del tipus Aresta fetes en el segon nivell de l'anàlisi des endent. Espodria dissenyar el tipus Punt de forma que representés punts en 3D (en omptes de2D) o bé que les oordenades fossin enters en ompte de reals. L'úni que variaria serial'etapa de disseny des endent on es dissenyarien les opera ions del tipus Punt.• Aquest mateix raonament es pot apli ar al tipus Aresta. L'algorisme prin ipal és inde-pendent de la de�ni ió on reta d'aquest tipus.2.7 Bibliogra�a rela ionadaAquest tema es pot ampliar amb el apítol 5 del llibre [2℄.

30 CAPÍTOL 2. ANÀLISI DESCENDENT

Capítol 3Fitxers seqüen ials de text3.1 Introdu ióEn aquest apítol es tra tarà el tema dels �txers. En primer llo es fa una introdu ió alhardware i al software veient els �txers en aquest ontext. Aquesta part està extreta delllibre [6℄. A ontinua ió, després d'una breu lassi� a ió dels tipus de �txers, es presenta unaespe i� a ió del tipus de �txers seqüen ials de text, per tal de poder treballar-hi des delsalgorismes, i se'n veuen algunes apli a ions.3.2 Arquite tura d'un omputador3.2.1 Les parts prin ipals d'un omputadorA la �gura 3.1 es pot veure un diagrama que mostra les parts més importants d'un omputador.La gran majoria de omputadors, tant si són portàtils, om PC's, om esta ions de treball o omputadors entrals, segueixen l'arquite tura mostrada a la �gura 3.1. Els diferents nomsamb què es designen fan referèn ia a la velo itat, la quantitat de memòria, i la apa itat deemmagatzematge de la màquina. Totes aquestes presta ions s'in rementen quan es passa del omputador portàtil al omputador entral.principal

Memoria ElementsEntrada/SortidasecundariaCPU

Bus de dades

Memoria

Figura 3.1: Model d'un omputador.A ontinua ió es fa una breu des rip ió de adas un d'aquests elements:1. El bus és el entre de omuni a ió del omputador. Les dades i les instru ions es mouena través del bus entre me anismes que hi estan subje tes.2. La unitat entral de pro és (CPU) és un onjunt de ir uits que dirigeix les a tivitatsdel omputador. Una de les seves prin ipals a ions és anar a bus ar instru ions de lamemòria prin ipal, des odi� ar-les i exe utar-les.31

32 CAPÍTOL 3. FITXERS SEQÜENCIALS DE TEXT3. La memòria prin ipal emmagatzema el programa que s'està exe utant i les dades usadespel programa. La memòria prin ipal és volàtil, és a dir, que s'esborra quan el omputadors'apaga.4. La memòria se undària és una ol.le ió de re ursos, om per exemple dis os, apaçosd'emmagatzemar més informa ió que la memòria prin ipal. La informa ió queda em-magatzemada �ns i tot quan el omputador s'apaga i pot ser re uperada de nou quanel omputador es torna a engegar. Des de la memòria se undària les ordres són sempremés lentes que a la memòria prin ipal; per això el omputador intenta guardar les dades(i programes) més freqüentment utilitzats a la seva memòria prin ipal.5. Els elements d'entrada/sortida, I/O, om impressores, pantalles i te lat, estan onne tatsamb un bus dire tament o bé a través d'un ontrolador I/O. Les dades es mouen a travésdel bus entre elements I/O i la memòria prin ipal o la se undària.Algunes arquite tures són diferents de la mostrada a la �gura 3.1. Per exemple, una esta ióde treball sense dis no té elements de memòria se undària. Més aviat obté dades permanent-ment emmagatzemades, tals om programes, d'un altre omputador anomenat servidor, que téun sistema d'emmagatzematge de memòria se undària. D'aquesta manera, l'esta ió de treballsense dis es onne ta mitjançant una xarxa lo al.Un bon nombre de grans omputadors són multipro essadors o pro essadors paral.lels. La�gura 3.1 fa referèn ia a una úni a CPU, i un multipro essador pot tenir diversos pro essadors,potser entenars o milers. Cadas un onsisteix en una CPU i, normalment, algun magatzemlo al que fun iona om una memòria prin ipal privada1. Aquests pro essadors poden estar onne tats de diferents formes, in loent-hi els a essoris de tots els omponents de tots elpro essadors en un úni bus, a través del qual es omuniquen amb part de la memòria prin ipali així, indire tament, l'un amb l'altre.3.2.2 La CPULa CPU és el ervell que ontrola el omputador. Consisteix en tres unitats prin ipals: unaunitat aritmeti ològi a (ALU, per abreujar), un seguit de registres i una unitat de ontrol, ommostra la �gura 3.2.Unitat deControl

Registres

UnitatAritmetico-logicaFigura 3.2: La CPU.1Aquesta memòria prin ipal privada s'anomena memòria a he

3.2. ARQUITECTURA D'UN COMPUTADOR 33L'ALU realitza opera ions aritmètiques ( om sumes, restes, multipli a ions, divisions, . . . ),opera ions lògiques ( om AND, OR, . . . ) i ompara ions ( om <, ≥, . . . ) de les dades trobadesa la memòria prin ipal o als registres del omputador.Els registres són llo s d'emmagatzematge que propor ionen un a és extremament ràpid alseu ontingut. L'a és a un registre és �ns i tot més ràpid que l'a és a la memòria prin ipal, ien moltes màquines hi ha opera ions, om les aritmètiques, que es poden realitzar amb dadesde registres i no amb dades de la memòria prin ipal. Hi ha alguns registres espe ials. Un,anomenat omptador de programa, indi a la següent instru ió que serà exe utada. Un altre,el registre d'instru ió, onté la instru ió que s'està exe utant en aquell moment.La unitat de ontrol exe uta instru ions en el que s'anomena el i le bus a-des odi� a-exe uta. Consisteix en una seqüèn ia de passos om els següents:1. Es bus a la propera instru ió des de la memòria en el registre d'instru ió.2. Es des odi� a el tipus d'instru ió.3. Es lo alitzen les dades usades per la instru ió i es porten en els registres orresponents.4. Finalment, s'exe uta la instru ió.Freqüentment, quan ens referim a un xip mi ropro essador om un ir uit integrat, hitrobem la CPU i po a osa més. Quan es onne ten xips de omuni a ió i de memòria, i tambéelements de memòria se undària, un xip mi ropro essador es onverteix en un omputador tal om el oneixem.3.2.3 La memòria prin ipalLa unitat d'emmagatzamatge de la memòria prin ipal és el byte. Cada byte té una adreça, queel distingeix dels altres bytes. Cada adreça és un número, omençant per 0, 1, 2, . . . i a abantper N − 1, si N és el nombre de bytes a la memòria prin ipal. De fet, la de�ni ió tè ni a debyte és �la mínima quantitat d'emmagatzematge que té la seva pròpia adreça.�A la prà ti a, un byte són 8 bits. Un bit ( ontra ió de binary digit) és la mínima unitatd'informa ió i pot valer 0 o 1. El valor d'un byte és una seqüèn ia de vuit 0 o 1. Per tant, elnombre de valors diferents que es poden representar amb un byte és 256.És força omú onfondre bytes amb arà ters. A través del odi ASCII2, algunes de les 256seqüèn ies de vuit bits tenen un signi� at, que pot ser un arà ter grà� om per exemple, el arà ter 'A' que es representa amb el odi 01000001, el arà ter 'a' que es representa amb el odi 01100001, o el arà ter '?' amb el odi 00111111. També pot ser un arà ter no grà� om el odi 00001000 que representa l'espai en blan i el odi 00000111 que fa sonar una ampaneta a la onsola i que també es representa om CTRL G (Control G).3En informàti a, els valors més usats són potèn ies de 2. La raó és que els nombres esrepresenten, dins dels omputadors, en base 2 i quan es reserva un nombre determinat de bits,per exemple k, per representar valors d'un determinat tipus, el rang de valors que s'hi podenrepresentar va de 0 a 2k − 1, és a dir, 2k valors diferents.Per treballar amb aquestes quantitats en termes de potèn ies de 10, que és al que estemmés a ostumats, sovint es fa l'aproxima ió de onsiderar 210, que és exa tament 1.024, om2Ameri an Standard Code for Information Inter hange3A tualment, els assignaments del odi ASCII tenen signi� at en seqüèn ies de set bits. Per això, el odiper 'A' és realment 1000001. El odi s'estén a vuit bits posant un 0 a l'esquerra.

34 CAPÍTOL 3. FITXERS SEQÜENCIALS DE TEXT103. I s'a epta parlar en termes que 1 Kbyte són 1.000 bytes (quan exa tament són 1.024bytes) i que 1 Megabyte són 106 bytes (quan en realitat són 1.024 × 1.024 = 1.048.576 bytes).La taula següent indi a el termes que representen les potèn ies de 10 i les seves equivalèn iesaproximades en potèn ies de 2. Pre�x Lletra ValorKilo K 103 o 210Mega M 106 o 220Giga G 109 o 230Tera T 1012 o 240

ParaulesEls arà ters poden estar emmagatzemats en un úni byte, utilitzant el odi ASCII. Tot i així,no és fa tible emmagatzemar enters en un úni byte. Si ho féssim, llavors les variables enterespodrien tenir només 256 valors diferents. Els enters han de poder tenir molts més valors: unsquatre bilions d'enters diferents (232) seria un bon nombre i aldrien 32 bits (4 bytes).Anomenarem paraula a quatre bytes onse utius. Els omputadors utilitzen dos aminsdiferents per ordenar els bytes en una paraula. Una màquina big-endian ordena els bytesd'esquerra a dreta i una màquina little-endian els ordena de dreta a esquerra4.En una màquina big-endian, els bytes 0, 1, 2 i 3 representen la primera paraula, els bytes4, 5, 6 i 7 la segona, i així su essivament. En anvi, en una màquina little-endian, els bytes3, 2, 1 i 0 representen la primera paraula, els bytes 7, 6, 5 i 4, la segona, . . . En tots dos asos,el byte més baix és l'adreça de la paraula. Per exemple, en una màquina big-endian de 32bits, l'enter 11 serà representat en la paraula d'adreça 48 amb 0 en els bytes 48, 49 i 50, i laseqüèn ia de bits 00001011 en el byte 51.En anvi, en una màquina little-endian el mateix enter pot ser representat amb 00001011en el byte 48 i 0 en els bytes 49, 50 i 51.El problema apareix quan les dades d'un tipus de màquina han de ser transportades al'altre tipus; en la transferèn ia, l'ordre de bytes dins de la paraula ha de transposar-se. Pera la resta del apítol, suposarem l'ordre de la màquina big-endian.Com es onstrueix la memòriaLa memòria prin ipal està onstituïda per xips de memòria o RAM5. Un xip és un ir uitintegrat, de menys d'una polzada quadrada de superfí ie, on es ol.loquen els ables i els omponents elè tri s. El ir uit en un xip de memòria que onsisteix en un gran nombre debits; el nombre és sempre una potèn ia parella de 2, és a dir, 22i per a algun enter i.4Els termes són del llibre Els viatges de Gulliver, de Jonathan Swift, on els políti s estaven en guerra perla dis ussió de si un ou s'havia de tren ar per la part gran o per la petita.5RAM ve de random a ess memory (Memòria d'a és aleatori). Signi� a que és igualment fà il a edir(llegir o es riure) a qualsevol bit, és a dir, a edir a un bit aleatori. En ompara ió, els re ursos utilitzats enmemòria se undària, om intes o dis os, són re ursos d'a és seqüen ial, on es pot a edir a bits en un ertordre sense pagar un substan ial preu en temps d'a és

3.2. ARQUITECTURA D'UN COMPUTADOR 35Cada bit d'un xip de memòria té una adreça, de rang des de 0 �ns al nombre de bits delxip menys 1. Tal om es mostra a la �gura 3.3 (a), quan s'entra una adreça i un senyal dellegir, el xip troba el bit amb aquella adreça i el porta al bu�er on el valor pot ser llegit olo alitzat pel bus del omputador. També es pot es riure un nou valor en el bit designat fententrar en el xip de l'adreça assignada un nou valor i el senyal d'es riure, om mostra la �gura3.3 (b). Cadas una d'aquestes opera ions triga aproximadament una dè ima de mi rosegon,és a dir 10−7s.Adreca

Bit

llegir

Bit

Adreca

Escriure

(a) Llegir (b) EscriureFigura 3.3: Opera ions de llegir i es riure en un xip de memòria.Normalment, la memòria es tra ta om una organitza ió de bytes i no de bits i, per això,per onstruir una memòria de, per exemple, un megabyte (220 bytes o 1 Mbyte) s'agafen vuitxips d'un megabit i se'ls posa la mateixa adreça. Aquesta opera ió es mostra a la �gura 3.4,on es pot veure l'opera ió de le tura. El byte desitjat prové d'un bit de adas un dels vuitxips. Com que són llegits (o es rits) a la vegada (en paral.lel), es triga el mateix per llegir unbyte que per llegir un bit.Adreca

llegir

Figura 3.4: Organitza ió de la memòria per bytes.

36 CAPÍTOL 3. FITXERS SEQÜENCIALS DE TEXTLa memòria a hePer a a essos ràpids, molts omputadors tenen la memòria a he, que és una petita memòriamolt ràpida que onté òpies d'algunes de les paraules de la memòria prin ipal. En la prà ti a,quan s'ha a edit a una paraula, és molt probable que es torni a fer servir aviat. Per tant,sempre que es llegeix una paraula de la memòria prin ipal se'n fa una òpia a la memòria a he, si és que aquesta paraula no hi era. Si el omputador vol llegir una paraula, primermirarà si es troba a la memòria a he i, en as a�rmatiu, la treurà d'aquesta memòria en untemps molt inferior del que ne essitaria per treure-la de la memòria prin ipal.No és evident om es troba una paraula a la memòria a he. Si posem les paraules dequalsevol manera en ara que duguin les seves adre es per identi� ar-les, serà tan fà il trobaruna paraula om trobar una agulla en un paller. Hi ha molts esquemes de memòria a he enús, però un dels més simples es mostra a la �gura 3.5. La memòria a he s'organitza omuna taula, per exemple d'1 Kparaula indexada per determinats bits d'una adreça. Si hi ha1 Kparaula, o 210 paraules a la memòria a he, aleshores l'índex orrespon als 10 bits menyssigni� atius (els de més a la dreta) de l'adreça d'una paraula. Com que totes les adre es deparaula, en binari, a aben en dos 0, s'agafen els següents 10 bits de la dreta om els bits menyssigni� atius de l'adreça de paraula. Per exemple, si les adre es tenen 23 bits, l'índex de lamemòria a he orrespon als bits del 12 al 21, omptant per l'esquerra. 0 1 . . .

BITS SIGNIFICATIUS VALOR

1023Figura 3.5: La memòria a he.3.2.4 Magatzem se undari de memòriaEls tres dispositius d'emmagatzematge se undari de memòria més importants són les intes,el dis magnèti i el dis òpti . En aquest apartat es presenten el dis magnèti i el dis òpti .Per a ada aparell, s'expliquen breument els prin ipis físi s en què es basa i se'n men ionenles velo itats típiques i les apa itats.El dis magnèti Una unitat de dis magnèti onsisteix en un o més plats rodons amb una superfí ie magnèti aen tots dos ostats, l'anvers i el revers del dis . Els dis s més petits, anomenats dis �exible ominidis , tenen un úni plat, mentre que les unitats més àmplies poden arribar a tenir-ne deuo més, apilats al voltant d'un eix de revolu ió en el seu entre, tal om es mostra a la �gura3.6. Cada superfí ie té el seu propi apçal de le tura, i tots els apçals es mouen ap a dinso ap a fora alhora per llegir la informa ió a diferents radis del entre. De totes maneres, enmoltes unitats de dis només pot llegir un apçal a la vegada.Tota la unitat de dis (ex epte els apçals) gira ràpidament al voltant de l'eix de revolu iósituat al entre del dis . Les velo itats més usuals són d'alguns milers de revolu ions per

3.2. ARQUITECTURA D'UN COMPUTADOR 37

Figura 3.6: Diagrama esquemàti d'un dis .minut. Per aquest motiu, un punt de la superfí ie passa pel apçal unes 60 vegades per segon.La informa ió d'un dis està organitzada en pistes, que són er les on èntri s, tal ommostra la �gura 3.7, que és una vista en planta d'una de les superfí ies de la unitat de dis . En ada pista, els bits estan representats magnèti ament, amb el 0 i l'1 representats per dire ionsde polaritat oposades. El nombre de bits en una pista és de entenars de milers. Depenentdel format, aquest bits es poden dividir en se tors, que són separats per regions en forma dese tors de er le sense polaritat magnèti a, o pot haver-hi un úni se tor, tal om mostra la�gura 3.7. El propòsit de la regió no polaritzada és ajudar la unitat a trobar el omençamentde les dades en la pista o se tor.El nombre de pistes a la superfí ie anvia. En dis s �exibles és d'unes 40, mentre que lesunitats més grans poden tenir-ne 1.000 o més. D'aquesta manera, la apa itat total d'unaunitat de dis pot anar d'uns quants entenars de milers de bytes a alguns gigabytes.

38 CAPÍTOL 3. FITXERS SEQÜENCIALS DE TEXT

Figura 3.7: Pistes en la superfí ie d'un dis Llegir i es riure en un dis Per llegir un byte parti ular del dis (o per es riure'l) al fer dues oses6:1. Situar els apçals de manera que es trobin damunt de la pista del byte desitjat.2. Esperar que el byte desitjat passi per sota del apçal.Cadas una d'aquestes opera ions triga de mitjana algunes entèsimes de segon. El tempsno sols depèn de les ara terístiques de la unitat de dis ; també hi in�ueixen el nombre depistes sobre les quals els apçals han de moure's i la posi ió relativa entre el byte i el apçalen el moment en què el apsal arriba a la pista. Aquest temps és enorme, omparat amb lafra ió de mi rosegon ne essària per llegir un byte de la memòria prin ipal. Per altra banda,si estem llegint dos bytes onse utius d'una pista, un op s'ha trobat el primer byte, el següentbyte passa pel apçal ràpidament.El temps per trobar un úni byte és en ordres de magnitud més gran que el temps ne essariper llegir o es riure un byte. Sovint els dis s es refereixen om un magatzem d'a és seqüen ial,ja que és més e� ient llegir dades del dis tal om apareixen enmagatzemades que llegir-lesen un ordre aleatori. En ompara ió, la memòria prin ipal s'anomena d'a és aleatori, perquèl'ordre en què llegim o es rivim els bytes no afe ta el temps per byte. Per fer un ús mése�dient del dis es tendeix a dividir les pistes en blo s, de 1.000 bytes o més adas un, i allegir o es riure els blo s om a unitats. A més, si diversos blo s formen un �txer, és desitjableque aquests blo s estiguin en el mateix ilindre, que és la ol.le ió de pistes, una en adasuperfí ie, que estan a la mateixa distàn ia del entre. D'aquesta manera es pot a edir a totsels blo s sense moure els apçals i el temps de er a es redueix a zero.6Parlarem només sobre la le tura. El pro és d'es riptura és essen ialment el mateix, ex epte que impli adeixar nova informa ió en la posi ió indi ada, en llo de llegir-ne els valors.

3.3. LA JERARQUIA DE LES ABSTRACCIONS EN UN COMPUTADOR 39Dis òpti A omençaments dels anys 90, el dis òpti , que utilitza te nologia semblant a la dels dis s ompa tes dels equips de músi a, es va onvertir en un element important dins la te nologiade l'emmagatzematge de dades. Com el dis magnèti , el magatzem físi és un dis dividiten pistes on s'emmagatzemen els bits. En llo d'un material magnèti , s'usa un material quere�e teix la llum. Un làser il.lumina un punt minús ul, i segons se'n apta o no la re�exió,es onsidera que la informa ió orrespon a un 0 o a un 1 respe tivament. Quan la superfí ied'aquest punt és molt llisa (superfí ie brillant), la llum s'hi re�e teix molt (a tua om unmirall) i aleshores la informa ió orrespon a un 0. Per representar un 1, la superfí ie d'aquestpunt es grava de forma que sigui més rugosa i re�e teixi la llum molt po (superfí ie mat).Quan s'il.lumina aquest punt amb el làser i es apta una re�exió no signi� ativa es on louque hi ha un 1.Els primers dis s òpti s es podien es riure una sola vegada. Aixó vol dir que, un opuna àrea era gravada, no podia ser allisada, amb la qual osa es prohibia el anvi d'un 1 aun 0. Aquest dis s en ara s'utilitzen en ertes apli a ions. Per exemple, una persona potvoler omprar un sistema operatiu en un dis òpti i utilitzar els programes que hi estanes rits repetidament. De fet, no és normal que l'usuari vulgui formatejar un dis que onté elsistema operatiu. Un altre ús important és el d'arxivar, es rivint òpies de seguretat de �txersemmagatzemats en el dis dur que poden ser re uperats si el dis dur falla, o si el propietaridel �txer ne essita re uperar-ne un estat anterior per orregir un anvi errorni posterior.Els darrers dis s òpti s utilitzen te nologia que permet rees riure, om en un dis mag-nèti . El gravat de la superfí ie es realiza amb una altera ió ele tròni a del material i potser reversible, osa que permet que l'àrea reservada per un bit pugui ser llisa un altre op i,d'aquesta manera, emmagatzemar un 0. Les presta ions de tots dos dis s òpti s són grans,ja que permeten emmagatzemar informa ió d'una manera més ompa ta (amb més bits perpolzada quadrada de superfí ie) que els dis s magnèti s.3.3 La jerarquia de les abstra ions en un omputadorUn omputador, juntament amb el seu software, presenta una jerarquia d'abstra ions anome-nades màquines virtuals. La �gura 3.8 mostra les prin ipals abstra ions d'aquesta jerarquia.Cada nivell, ex epte el més baix, està implementat per traduir o interpretar les ordres d'aquestnivell utilitzant omandes de nivells inferiors. Els termes abstra ió i nivell són sinònims demàquina virtual en aquest apítol.NIVELL ABSTRACCIÓ6 Programes d'Apli a ió5 Llenguatges de programa ió4 Llenguatge assemblador3 Sistemes operatius2 Llenguatge màquina1 Mi roprograma ió0 Lògi a digitalFigura 3.8: Nivells d'abstra ió presents en un omputador digital i el seu software

40 CAPÍTOL 3. FITXERS SEQÜENCIALS DE TEXTEl nivell més baix, la lògi a digital, és una abstra ió dels ir uits ele tròni s del ompu-tador. La lògi a digital està implementada per ir uits anomenats portes. Aquestes portesagafen una o més entrades digitals o inputs (representades normalment per 0 i 1) i produeixenuna sortida o output que és la fun ió lògi a ( om AND o OR) de les seves entrades. Les portesestan fetes de transistors i altres elements de ir uit.El nivell 1, el nivell de mi roprograma ió, és el primer nivell de llenguatge. No tots els omputadors tenen aquest nivell. Consisteix en un seguit de passos usats per implementarles instru ions de llenguatge màquina de nivell 2. Una instru ió de llenguatge màquina potsumar 2 nombres, moure dades d'un registre a un altre o determinar si un nombre és iguala 0, per exemple. Instru ions simples om aquestes són su� ients per exe utar qualsevolprograma o apli a ió de nivells superiors.El nivell 3 representa el sistema operatiu. Els usos d'aquest nivell són programar i lo alitzarels re ursos del omputador enfront dels diferents programes que exe uta la màquina. MS-DOS, UNIX, Linux, l'entorn Ma intosh i Mi rosoft Windows són alguns dels sistemes operatiusmés omuns. El sistema operatiu en si mateix pot ser implementat en un llenguatge de nivellsuperior que s'ha traduït a llenguatge màquina. Sovint, el sistema operatiu in lou una varietatde programes d'apli a ió (nivell 6) que ajuden l'usuari a editar �txers, treballar amb �nestresi moltes altres a tivitats.El sistema operatiu permet gestionar els dispositius d'emmagatzematge se undari. Permeteditar, opiar, moure de llo , treure per pantalla o imprimir �txers. Tenint en ompte que els�txers són onjunts de blo s, el sistema operatiu els ha d'organitzar d'una manera determinada.Aquesta organitza ió usa bàsi ament dues estru tures de dades:• L'estru tura jeràrqui a de dire toris. És una taula on ada element representa un �txermitjançant una tupla amb diversos aps d'informa ió relatius al �txer:� nom del �txer� mida del �txer (en bytes)� data darrera en què s'ha variat� propietari� índex al primer blo de la FAT (�le a ess table) orresponent a aquest �txer• La FAT. És una taula on ada element representa un blo . Els blo s d'un mateix �txerestan enllaçats i els blo s no rela ionats amb ap �txer (lliures) també estan enllaçats.La rea ió d'un nou �txer o l'esborrat d'un �txer existent modi�quen aquestes dues es-tru tures. Aquestes estru tures es guarden en una part de la memòria se undària (dis ) noa essible a l'usuari. Quan es formata un dis , l'úni que es fa és enllaçar tots els seus blo s om a blo s lliures. Quan es produeix un error físi en un dis , si és en un blo qualsevol nopassa res, però si és en un blo on hi ha la taula FAT, aleshores es perd tota la informa ió.Per això, aquesta taula a ostuma a estar dupli ada.El nivell 4, el nivell del llenguatge assemblador, és una representa ió simbòli a per instru - ions de nivells inferiors. Un programa es rit en llenguatge assemblador es onverteix en un onjunt d'instru ions de nivell inferior mitjançant un tradu tor anomenat assemblador.El nivell 5 representa els llenguatges d'alt nivell que, amb les seves apli a ions de programa,poden resoldre problemes de manera més senzilla que amb el llenguatge assemblador. Alguns

3.4. CLASSIFICACIÓ DELS FITXERS 41dels llenguatges de nivell 5 més omuns són Basi , C, Cobol, Fortran, Lisp i Pas al, tot i quehi ha milers de llenguatges d'alt nivell utilitzats pels omputadors a tuals. Un programa quetradueix un llenguatge de nivell 5 en un de nivell inferior s'anomena ompilador.Les apli a ions de nivell 6 són ol.le ions de programes, adas un amb el seu model dedades, dissenyats per resoldre problemes espe í� s en un ampli rang de dis iplines. Els paquetsd'apli a ions són utilitzats per fer àlgebra, dissenyar automòbils, programar trens, manteniruna base de dades i realitzar innombrables tasques. El nivell 6 és el que dóna la gran versatilitatals omputadors i és la raó de la seva extensa ubiqüitat en la vida moderna.Alguns omputadors tenen abstra ions addi ionals, om poden ser les interfí ies d'usuarii la apa itat de omuni a ió de dades.3.4 Classi� a ió dels �txersUn �txer és un onjunt d'informa ió de�nida pel seu reador. Per tant, és un on epte moltampli. Els �txers es poden lassi� ar segons diferents riteris.Segons el tipus d'informa ió que ontenen:• programes font (es rits en C, C++, JAVA, FORTRAN, et .)• programes obje te• programes exe utables• �txers de dades• �txers amb do uments (Word, WP, et .)• �txers amb �gures• �txers amb imatges (jpeg, et .)• �txers imprimibles (posts ript, pdf, et .)• . . .Els �txers amb què treballarem en aquest apítol seran �txers de dades. Normalmentaquests �txers estan estru turats en registres del mateix tipus, els quals estan estru turatsen amps d'informa ió. De vegades els registres poden estar ordenats segons la informa ió ontinguda en un amp. Aleshores aquest amp s'anomena amp lau.Per exemple, el �txer amb la nòmina d'una empresa tindrà tants registres om treballadors.Els amps poden ser el DNI, el nom, la data d'alta a l'empresa, el sou brut, et ., i el amp lau pot ser el DNI.Segons el format de les dades emmagatzemades:• Fitxers de text. Tota la informa ió són arà ters. Els �txers que ontenen programesfont, els �txers editats amb EMACS i els �txers post ript, per exemple, ho són. Aquests�txers són dire tament imprimibles.• Fitxers binaris. La informa ió que ontenen és un re�ex del que ontindria la memòria entral i no són dire tament imprimibles. Els �txers exe utables són d'aquest tipus.

42 CAPÍTOL 3. FITXERS SEQÜENCIALS DE TEXTSegons la forma d'a edir a les dades:• Seqüen ial. No es pot a edir a un registre si no s'ha passat per l'anterior.• Dire te. Es pot a edir a un registre determinat indi ant la posi ió que o upa aquestregistre en el �txer.• Indexat. Es pot a edir a un registre determinat indi ant el valor del amp lau.3.5 Tra tament algorísmi dels FST3.5.1 Referèn ia a �txer. Con epte de bindingEn aquesta se ió s'expli a om es pot treballar amb �txers des d'un algorisme.Només es treballarà amb �txers seqüen ials de text (FST). Com ja s'ha dit, un �txer se-qüen ial de text és un onjunt d'informa ió formada per arà ters, estru turada de maneraseqüen ial. L'a és als arà ters d'aquests �txers serà anàleg al d'una seqüèn ia de arà -ters. En aquesta se ió veurem les opera ions algorísmiques d'a és a la informa ió, és a dir,opera ions per llegir i per es riure en un �txer.Els �txers són gestionats pel sistema operatiu i estan emmagatzemats en dispositius externsde memòria se undària. A fí que un algorisme pugui utilitzar un �txer serà ne essari que aquesthagi de larat un obje te variable que ontingui la informa ió de óm a edir al �txer ( omuna mena de vin le o referèn ia al �txer). Aquest obje te variable s'anomenarà referèn ia del�txer, i serà d'un nou tipus, que anomenarem FST.Entre altres entitats, la referèn ia del �txer, onté un bu�er, que és un magatzem d'in-forma ió que a tua om una molla i permet esmorteir l'entrada d'informa ió. El pro és dele tura (per exemple) fun iona de la següent manera: la informa ió del dis s'agafa per blo s,de manera que ada blo es diposita en el bu�er ; aleshores el programa agafa la informa iód'aquest bu�er de forma més detallada. En el bu�er hi aben un ert nombre de blo s del�txer. L'a tualitza ió del bu�er amb els nous blo s del �txer que va ne essitant el programad'apli a ió es fa de forma transparent al programador. A l'a ió de portar un blo de dis a memòria se l'anomena fet h. A part del bu�er, la referèn ia del �txer també gestiona uníndex que indi a la posi ió del bu�er a què s'està a edint a ada moment.Alguns sistemes operatius porten blo s al bu�er abans que el programa els ne essiti. Així,mentre el programa va usant el blo i, el sistema operatiu passa el blo i + 1 al bu�er.3.5.2 Opera ions sobre �txers de textLes opera ions que es poden fer amb obje tes de tipus FST són:• De larar obje tes (variables) de tipus FST.• Ini ialitzar variables de tipus FST. En aquesta opera ió s'establirà el lligam entre el �txeri la referèn ia al �txer. Aquest lligam s'anomena binding o anal. En aquesta opera iós'indi arà el mode, le tura (L) o es riptura (E). Els �txers seqüen ials es poden obrirnomès per L o nomès per E, però no per les dues oses alhora.• Llegir i es riure informa ió dels �txers.

3.5. TRACTAMENT ALGORÍSMIC DELS FST 43Amb aquestes opera ions, tots els algorismes apli ables a seqüèn ies de arà ters ho sóntambé als �txers de text. També es poden apli ar algorismes que tra ten més d'una seqüèn iaen paral.lel, om el de fusió que es veurà a 3.6.2.A ontinua ió es donen les espe i� a ions de les opera ions que es faran amb el tipus FST.tipusMode = (le tura, es riptura)ftipusEl tipus Cadena es de�neix om adena de arà ters.{Pre : El �txer nom no està obert ∧ (m = le tura⇒ existeix(nom))}fun ió ObrirFST(ent m : Mode, ent nom : Cadena) retorna FST{Post: ObrirFST(m,nom) = f ∧

(m = le tura⇒pe(f) = en_ urs(f) = ∅ ∧ pd(f) = seqüèn ia(nom)) ∧(m = es riptura⇒ pe(f) = en_ urs(f) = pd(f) = ∅)}skip

{Pre : mode(f) = le tura ∧ pe(f) = α∧ en_ urs(f) = β ∧ pd(f) = c.γ ∧ pd(f) 6= ∅}a ió LlegirCara terFST(entsor f : FST, sor c : arà ter)

{Post: mode(f) = le tura ∧pe(f) = α.β ∧ c = en_ urs(f) ∧ pd(f) = γ}skip{Pre : mode(f) = es riptura ∧ pe(f) = α}a ió Es riureCara terFST(entsor f : FST, ent c : arà ter){Post: mode(f) = es riptura ∧ pe(f) = α.c}skip{Pre : mode(f) = le tura}fun ió FdFST(ent f : FST) retorna booleà{Post: FdFST(f) ≡ pd(f) = ∅}skip{Pre : mode(f) = le turamode(f) = es riptura}a ió Tan arFST(entsor f : FST){Post: mode(f) 6= le tura ∧ mode(f) 6= es riptura}També hi ha les següents opera ions amb enters i reals d'espe i� a ió similar a les orres-ponents amb arà ters:a ió LlegirEnterFST(entsor f : FST , sor e : enter)a ió LlegirRealFST(entsor f : FST, sor r : real)a ió Es riureEnterFST(entsor f : FST, ent e : enter)a ió Es riureRealFST(entsor f : FST, ent r : real)Cal notar que tant les opera ions orresponents a le tura d'informa ió om les d'es ripturahan de ser a ions, ja que el paràmetre de tipus FST (la referèn ia al �txer) és un paràmetred'entrada/sortida. Això és així a ausa que tant el pro és de le tura om el d'es ripturamodi�quen la variable de tipus FST, és a dir, modi�quen la referèn ia al �txer (el bu�er il'índex). Les a ions de le tura i es riptura d'enters i reals són similars a les vistes per al CSE,

44 CAPÍTOL 3. FITXERS SEQÜENCIALS DE TEXTés a dir, que fan la onversió entre els arà ters que representen el valor en el �txer (formattext) i la orresponent odi� a ió interna per a enters i reals (format binari).El sistema operatiu ol.lo a al �nal de ada �txer un arà ter que fa de sentinella o tambéde mar a de � de �txer. Aquest arà ter s'anomena EOF (end of �le) i té un determinat odi ASCII. Com que tots els sistemes operatius posen aquest arà ter, s'ha de�nit l'opera ió orresponent, FdFST, que retorna el valor booleà ert quan el arà ter en urs és pre isamentel arà ter EOF.De totes maneres, ex epte en asos d'algorismes generals, es desa onsella usar aquest arà ter om a forma de dete tar quan s'a aba el �txer. A més, sovint, la informa ió que hi haal �txer està estru turada en registres més o menys omplexos que seran els que es onsideraran om els elements de la seqüèn ia a generar i, en anvi, aquesta mar a és simplement un arà ter(per tant, no es pot onsiderar sentinella de la seqüèn ia, ja que no és del mateix tipus que elselements de la seqüèn ia). Per tant, normalment, per saber si s'ha arribat al �nal d'un �txeres onsidera una propietat que ompleixi el darrer registre que podrà ser el darrer element dela seqüèn ia o bé un element sentinella però que tindrà el mateix tipus que els elements de laseqüèn ia.Així, per exemple, en un �txer que onté una seqüèn ia d'edats (enters) haurem d'indi ar om és el darrer registre: si orrespon a la darrera edat a tra tar i val, per exemple, 77 o bési orrespon a una edat sentinella i val, per exemple, -5.Tot i que, després d'aquest darrer registre, el sistema operatiu hi haurà posat el arà terEOF, des de l'algorisme, no el farem servir per a res.Els esquemes de re orregut i er a en FST s'apliquen de la mateixa manera que per a lesseqüèn ies.Les implementa ions de les opera ions sobre el tipus FST en C es poden trobar a l'apèndixA.7 de [7℄. En aquesta implementa ió es fa ús del tipus �le, que és un tipus aportat pelllenguatge de programa ió C. L'espe i� a ió d'aquest tipus amb les seves opera ions (fun ionsfopen, fs anf, fprintf . . . ) es pot trobar al �txer de apçaleres (headers) stdio.h.3.5.3 Exemple d'apli a ióEnun iatPel CSE es dóna una seqüèn ia en apçalada per una paraula i seguida d'una seqüèn iade noms de �txer, a abada amb una paraula sentinella que és �ZZ�. Es demana que pel CSSs'es riguin els noms de �txer que ontenen la paraula que en apçala la seqüèn ia.Els �txers ontenen un text que també podem onsiderar que a aba amb la mateixa paraulasentinella.Resolu ióEns onvé pensar el problema en termes de noms. D'aquesta manera, tenimEspe i� a ió:{Pre : CSE = pref, nom1, nom2, . . . , nomnnom_sent ∧ ∀i : 1 ≤ i ≤ n : ∃FST de nom

nomi ∧ nomi = pari1, pari

2, . . . , parimi

, nom_sent, i nom_sent és �ZZ�}algorisme CercaParaula{Post: CSS = nomr

1nomr2 . . . nomr

p ∧ ∀j :

1 ≤ j ≤ n

3.5. TRACTAMENT ALGORÍSMIC DELS FST 45(∃i : 1 ≤ i ≤ n : (nomr

j = nomi ∧ ∃k : 1 ≤ k ≤ mi : parik = pref))}Disseny:L'algorisme en aquest primer nivell d'anàlisi onsisteix en fer un re orregut per la seqüèn iade noms de �txers. El tra tament que s'apli a a ada nom de �txer onsisteix en una er ade la primera paraula que ve pel CSE dins d'aquest �txer.algorisme CercaParaulavar

pref : Paraulanom : Paraulafvar

LlegirParaula(pref)LlegirParaula(nom)mentre ¬ParaulaSentinella(nom) fersi ParaulaTrobada(pref, nom) → EscriureParaula(nom)⊓⊔ ¬ParaulaTrobada(pref, nom) →fsiLlegirParaula(nom)fmentrefalgorismeEl mantenint de l'abstra ió de Paraula ha donat llo a les següents a ions pendents a feren els següents nivells:a ió LlegirParaula(sor p : Paraula)

{Pre : CSE = P S}{Post: p = P ∧ CSE = S}fun ió ParaulaSentinella(ent p : Paraula) retorna booleà{Pre : p=P}{Post: ParaulaSentinella és ert si P és �ZZ�. Fals en as ontrari}fun ió ParaulesIguals(ent p, q : Paraula) retorna booleà{Pre : ert}{Post: ParaulesIguals(p, q)⇔ p = q}a ió EscriureParaula(ent p : Paraula){Pre : CSS = α}{Post: CSS = α p}També en el disseny de l'algorisme prin ipal hem proposat la fun ió ParaulaTrobada.

46 CAPÍTOL 3. FITXERS SEQÜENCIALS DE TEXTfun ió ParaulaTrobada(ent pref, nom : Paraula) retorna booleà{Pre : ∃FST de nom nom ∧ nom = {par1par2 . . .

parm, nom_sent}}{Post: ParaulaTrobada(pref, nom) ≡ ∃k : 1 ≤ k ≤ m : park = pref}que tra ta l'abstra ió de paraula (pref ), però el segon argument usa una paraula perreferir-se al nom d'un �txer FST. Començarem per dissenyar aquesta fun ió que seguirà usantl'abstra ió Paraula:fun ió ParaulaTrobada(ent pref, nom : Paraula) retorna booleàvar

f : FSTtrobat : BOOLEAp : Paraulafvar

f := ObrirFST (lectura, ParaulaACadena(nom))trobat := falsLlegirParaulaFST (f, p)mentre ¬ParaulaSentinella(p) ∧ ¬trobat fersi ParaulesIguals(p, pref) → trobat := ert⊓⊔ ¬ParaulesIguals(p, pref) → LlegirParaulaFST (f, p)fsifmentre

TancarFST (f)retorna (trobat)�un ióLa implementa ió de les opera ions del tipus Paraula serà lleugerament diferent a la vistaa 2.5, ja que aquí la forma de dete tar el �nal de seqüèn ia tant a l'algorisme prin ipal om ala fun ió ParaulaTrobada és mitjançant una paraula sentinella.tipusParaula : tupla

numcar : entermot : TauCarftupla

TauCar : taula [0..19] de arà terftipusa ió LlegirParaula(sor p : Paraula)varcarcurs : arà terfvar

LlegirCaracter(carcurs)mentre Separador(carcurs) ferLlegirCaracter(carcurs)fmentre

3.5. TRACTAMENT ALGORÍSMIC DELS FST 47p.numcar := 0mentre ¬Separador(carcurs) fer

p.mot[p.numcar] := carcursp.numcar := p.numcar + 1LlegirCaracter(carcurs)fmentre�un ióL'opera ió LlegirParaulaFST és similar a LlegirParaula. La diferèn ia fonamental és queaquesta opera ió ha de ser una a ió i el paràmetre orresponent al �txer ha de ser d'entra-da/sortida. La seva espe i� a ió és la següent:a ió LlegirParaulaFST(entsor f : FST, sor p : Paraula)

{Pre : mode(f) = le tura ∧ pe(f) = α ∧Paraula_en_ urs(f) = β ∧ pd(f) = γ δ}{Post: mode(f) = le tura ∧ pe(f) = α.β ∧ p = Paraula_en_ urs(f) = γ ∧pd(f) = δ}En el disseny, en omptes de ridar l'a ió LlegirCara ter haurà de ridar l'a ió Llegir-Cara terFST :a ió LlegirParaulaFST (entsor f : FST, sor p : Paraula)var carcurs : arà ter fvar

LlegirCaracterFST (f, carcurs)mentre Separador(carcurs) ferLlegirCaracterFST (f, carcurs)fmentre{Ini ialitzem el nombre de arà ters}p.numcar := 0mentre ¬Separador(carcurs) fer

p.mot[p.numcar] := carcursp.numcar := p.numcar + 1LlegirCaracterFST (f, carcurs)fmentrefa ióI queda per dissenyar la fun ió ParaulaSentinella.fun ió ParaulaSentinella(ent p : Paraula) retorna booleàvar sent : booleà fvarsi p.numcar = 2 → sent := p.mot[1] = `Z' ∧ p.mot[2] = `Z'

⊓⊔ p.numcar 6= 2 → sent := falsfsiretorna sent�un ió

48 CAPÍTOL 3. FITXERS SEQÜENCIALS DE TEXT3.6 Fusió entre �txers3.6.1 Introdu ióDonats dos �txers amb els registres del mateix tipus i ordenats per un determinat amp lau,s'anomena pro és de fusió el pro és d'obten ió d'un ter er �txer que ontingui els registres orresponents a la unió dels registres dels dos �txers ini ials i també ordenats pel mateix amp lau. Se'n onsideren variants els pro essos que, en llo d'obtenir la unió, obtenen lainterse ió i la diferèn ia.L'algorisme orresponent onsisteix a fer un re orregut simultani dels dos �txers d'entrada omparant els registres en urs i es rivint el que orrespongui al �txer de sortida.3.6.2 Exemple de fusió entre dos �txersEnun iatDonats dos �txers, anomenats Fit1 i Fit2, de registres del mateix tipus que anomenaremtRegistre i ordenats segons la mateixa rela ió d'ordre, dissenyeu un algorisme que obtingui lafusió en un ter er �txer, Fit3. Es pot suposar l'existèn ia dels següents pro ediments: l'a ióLlegirRegistreFST, l'a ió Es riureRegistreFST i la fun ió RegistreSentinella:{Pre : mode(f) = le tura ∧ pe(f) = α ∧ pd(f) =

pβ ∧ en_ urs(f) = γ}a ió LlegirRegistreFST(entsor f : FST, sor p : tRegistre){Post: mode(f) = le tura ∧ pe(f) = α.γ ∧ pd(f) =

β ∧ en_ urs(f) = p}{Pre : mode(f) = es riptura ∧ pe(f) = α}a ió Es riureRegistreFST(entsor f : FST, ent p : tRegistre){Post: mode(f) = es riptura ∧ pe(f) = α.p}{Pre : cert}fun ió RegistreSentinella(ent p : tRegistre) retorna booleà{Post: RegistreSentinella(p) ≡ cert sii p és el registre sentinella}També suposarem l'existèn ia d'una fun ió que, utilitzant la rela ió d'ordre entre obje tesde tipus tRegistre, ens permet la ompara ió d'aquests. Aquesta fun ió ens indi arà no noméssi són iguals o diferents, sinó quin dels dos registres és anterior seguint l'ordre establert.{Pre : cert}fun ió ComparaRegistres(ent p1, p2 : tRegistre) retorna enter{Post: (ComparaRegistres(p1, p2) < 0 ∧ p1 anterior a p2)

(ComparaRegistres(p1, p2) > 0 ∧ p2 anterior a p1)(ComparaRegistres(p1, p2) = 0 ∧ p1 igual a p2)}El disseny d'aquesta fun ió depén del tipus del registre i de la rela ió d'ordre que hi haentre aquests.Resolu ióEn primer llo espe i� arem l'algorisme de fusió:

3.6. FUSIÓ ENTRE FITXERS 49{Pre : Fit1 i Fit2 són dos FST de registres de tipus tRegistre ordenats amb un riteri,

∧ a abats amb un registre sentinella}algorisme Fusio{Post: Fit3 és un FST que onté tots els registres de Fit1 i Fit2 ∧ Fit3 està ordenat amb el riteri }i, tot seguit el disseny.algorisme Fusiovar

f1, f2, f3 : FSTr1, r2 : tRegistrefvar

{Obrir �txers}f1 := ObrirFST (lectura, �Fit1�)f2 := ObrirFST (lectura, �Fit2�)f3 := ObrirFST (escriptura, �Fit3�){re orregut dels �txers}LlegirRegistreFST (f1, r1)LlegirRegistreFST (f2, r2)mentre ¬RegistreSentinella(r1) ∧ ¬RegistreSentinella(r2) fersi ComparaRegistres(r1, r2) < 0 → EscriureRegistreFST (f3, r1)

LlegirRegistreFST (f1, r1)⊓⊔ ComparaRegistres(r1, r2) > 0 → EscriureRegistreFST (f3, r2)

LlegirRegistreFST (f2, r2)⊓⊔ ComparaRegistres(r1, r2) = 0 → EscriureRegistreFST (f3, r1)

LlegirRegistreFST (f1, r1)LlegirRegistreFST (f2, r2)fsifmentrementre ¬RegistreSentinella(r1) fer

EscriureRegistreFST (f3, r1)LlegirRegistreFST (f1, r1)fmentrementre ¬RegistreSentinella(r2) ferEscriureRegistreFST (f3, r2)LlegirRegistreFST (f2, r2)fmentre

{es rivim sentinella al �txer Fit3}EscriureRegistreFST (f3, r1){tanquem �txers}TancarFST (f1)TancarFST (f2)TancarFST (f3)falgorisme

50 CAPÍTOL 3. FITXERS SEQÜENCIALS DE TEXT3.6.3 Mètode de FeigenLa majoria de sistemes informàti s usen un o més �txers ordenats, i les opera ions que s'hifan més sovint, a part de l'ordena ió, són:• inser ió d'un registre• esborrat d'un registre• modi� a ió d'un registreAra bé, aquestes opera ions no es fan dire tament sobre el �txer ini ial, que s'anomena�txer mestre, sinó que es fan en un altre �txer que té la mateixa estru tura i que s'anomena�txer d'a tualitza ions. Aquest mètode és el mètode de Feigen i el seu fun ionament és elsegüent: durant el dia, les a tualitza ions es van afegint en ordre temporal al �txer d'a tua-litza ions; al �nal del dia, aquest �txer s'ordena amb el mateix riteri que el �txer mestre i esfa una fusió entre tots dos per rear un nou �txer mestre. Aquest mètode segueix l'esquemad'una fusió general que farà unions en el as d'inser ions, diferèn ies en el as d'esborratsi substitu ions en el as de modi� a ions. Finalment, s'esborrarà el �txer mestre anti i esdeixarà a punt el nou per al dia següent.3.6.4 Disseny de l'algorisme orresponent al mètode de FeigenCom s'ha expli at a l'apartat anterior, l'algorisme orresponent al mètode de Feigen és unavariant de l'algorisme de fusió. A ontinua ió s'espe i� a el problema:Pre ondi ióEs disposa d'un �txer, que anomenem Mestre, els registres del qual són d'un determinattipus que anomenarem tregistre i estan ordenats per un amp lau que és del tipus t lau.També es disposa d'un �txer, que anomenem A tualitza ions, els registres del qual són d'undeterminat tipus, tregistrea t, que pot ontindre tota la informa ió del tipus tregistre i, a més,la informa ió referent al tipus d'opera ió a apli ar, inser ió, esborrat o modi� a ió. Suposaremque el tipus opera ió ens ve donat per un arà ter: I, E o M, respe tivament.Es pot suposar que en els �txers no hi ha errors que impliquin la onsidera ió de més asosque els esmentats (per exemple, laus oin idents i opera io = I).Post ondi ióEl resultat serà un nou �txer mestre, Mestrenou, on s'hauran apli at totes les a tualitza- ions.Els asos que aldrà tenir en ompte quan es omparen els registres en urs dels �txersMestre i A tualitza ions són els següents:• Les laus oin ideixen i l'opera ió a fer és M: substitu ió del registre del �txer Mestreper un nou registre al ulat a partir d'aquest i del registre del �txerA tualitza ions enel �txer Mestrenou. En aquest as el registre del �txerA tualitza ions pot no ontenirtota la informa ió del tipus registre.• Les laus oin ideixen i l'opera ió a fer és E: esborrat del registre del �txer Mestre.

3.6. FUSIÓ ENTRE FITXERS 51• La lau del registre del �txer A tualitza ions és inferior a la del registre del �txerMestre:en aquest as l'opera ió a fer ha de ser I i al inserir (es riure) el registre del �txerA tualitza ions al �txer Mestrenou.En aquest as el registre del �txerA tualitza ions hade ontenir tota la informa ió del tipus registre.• La lau del registre del �txer A tualitza ions és superior a la del registre del �txerMestre: s'es riu el registre del �txer Mestre en el �txer Mestrenou.algorisme Feigenvarreg, infract : tregistre{registre del Mestre i Mestrenou}regact : tregistreact{registre d'Actualitzacions}fm, fa, fmn : FSTcreg, cract : tclau{ laus dels registres de tots els �txers}operacio : arà terfvar

{Obrim �txers}fm := ObrirFST (lectura, �Mestre�)fa := ObrirFST (lectura, �A tualitza ions�)fmn := ObrirFST (escriptura, �Mestrenou�){re orregut dels �txers}LlegirRegistreFST (fm, reg)LlegirRegActFST (fa, regact)mentre ¬RegSentinella(reg) ∧ ¬RegActSentinella(regact) fer

creg := ObteClauRegistre(reg)cract := ObteClauRegAct(regact)operacio := ObteOperacioRegAct(regact)si Superior(cract, creg) → EscriureRegistreFST (fmn, reg)

LlegirRegistreFST (fm, reg)⊓⊔ Iguals(cract, creg) → {opera ió = M opera ió = E}si operacio = `M' → infract := ObteInformacio(regact, reg)

EscriureRegistreFST (fmn, infract)⊓⊔ operacio = `E' →fsiLlegirRegistreFST (fm, reg)LlegirRegActFST (fa, regact)

⊓⊔ Inferior(cract, creg) → {opera io = I}infract := ObteInformacioNova(regact)EscriureRegistreFST (fmn, infract)LlegirRegActFST (fa, regact)fsifmentre

{si en ara queden registres al �txer Mestre, s'afegeixen al �nal del �txer Mestrenou}mentre ¬RegSentinella(reg) ferEscriureRegistreFST (fmn, reg)LlegirRegistreFST (fm, reg)

52 CAPÍTOL 3. FITXERS SEQÜENCIALS DE TEXTfmentre{si en ara queden registres al �txer Actualitzacions,seran inser ions que aniran al �nal del �txer Mestrenou}mentre ¬RegActSentinella(regact) fer

infract := ObteInformacioNova(regact)EscriureRegistreFST (fmn, infract)LlegirRegActFST (fa, regact)fmentre

TancarFST (fm)TancarFST (fa)TancarFST (fmn)falgorismeLes opera ions d'esborrar el �txer Mestre i anviar de nom el �txer Mestrenou a Mestrees poden fer des del programa d'apli a ió (tots els llenguatges de programa ió disposen de les rides orresponents) o dire tament des del sistema operatiu.3.7 Bibliogra�a rela ionadaAquest tema es pot ampliar amb els apítols 5 i 6 del llibre [4℄ i el apítol 4 del llibre [6℄.

Capítol 4Complexitat Algorísmi a4.1 Introdu ióCada dia apareixen màquines més ràpides, de fet ada po s anys es dupli a el nombre d'ins-tru ions per segon que un omputador és apaç de fer. Això podria fer pensar que no alque ens preo upem de l'e� ièn ia dels algorismes. Ara bé, ada op es vol tra tar un volumde dades més gran, per la qual osa és important millorar-ne l'e� ièn ia.En parti ular, és important que els programes que s'hagin d'utilitzar un ert nombre devegades siguin e� ients. L'e� ièn ia d'un programa o d'un algorisme està asso iada al tempsd'exe u ió del programa i, eventualment, a l'espai de memòria que utilitza.L'e� ièn ia, om a temps d'exe u ió d'un programa o algorisme s'anomena ost, rendi-ment o omplexitat de l'algorisme.Per mesurar la omplexitat d'un algorisme es poden utilitzar dos enfo s diferents: provesi anàlisi.El primer dels enfo s onsisteix en desenvolupar un gran nombre de proves de l'exe u iódel programa en qüestió, tenint en ompte el temps d'exe u ió en ada as. De fet s'hauràd'exe utar el programa a partir d'un onjunt signi� atiu de les possibles dades (o paràmetres)d'entrada i s'avaluarà el temps per ada un d'aquests onjunts de dades.Un op es tenen aquests resultats s'apli aran tè niques estadístiques per de idir el ren-diment del programa per dades d'entrada no presents en la mostra estudiada. Els resultatsobtinguts no sempre són �ables.L'altre enfo , l'anàlisi utilitza pro ediments matemàti s per determinar el ost de l'algo-risme, les on lusions d'aquests mètodes són �ables, però de vegades po prà ti s.4.2 Anàlisi d'algorismesEl primer que hem de fer per analitzar un algorisme és de�nir amb pre isió que s'entén permida de les dades d'entrada. Normalment, aquesta de�ni ió resulta natural i senzilla. Perexemple:• En un algorisme d'ordena ió, la mida de les dades d'entrada és el nombre d'elements aordenar.• En un algorisme de er a en una taula, la mida de les dades d'entrada és el nombred'elements entre els que hem de fer la er a.53

54 CAPÍTOL 4. COMPLEXITAT ALGORÍSMICAUn op de�nida la mida de l'entrada és onvenient trobar una fun ió T (n), que anome-narem fun ió de ost, per representar el nombre d'unitats de temps que l'algorisme trigaen exe utar-se quan les dades d'entrada són de mida n. Ara bé, hem de tenir en ompte queel temps d'exe u ió varia substan ialment segons el omputador on ret que s'utilitza, peraixò, generalment, la fun ió T (n) ens dóna el nombre d'instru ions simples (assigna ions, ompara ions, opera ions aritmètiques, . . .) que s'han d'exe utar.4.3 Exemple: Algorismes d'avalua ió de polinomisAvalua ió d'un polinomi en un punt fent servir el mètode de Horner i avalua ió fent servir elmètode habitual:P (x) = a0 + (a1 + (a2 + (. . . (anx) . . .))x)xL'algorisme d'avalua ió d'un polinomi fent servir el mètode de Horner utilitza la de�ni iódel tipus polinomi.tipuspolinomi = tuplagrau : enter oef : tau_entftuplatau_ent = taula [0..MAX ] de enterftipusi l'algorisme serà om segueix:1 fun ió AvaluacioHorner(ent p : polinomi, ent x : enter) retorna enter2 var3 sol, i : enter4 fvar5 sol := p.coef [p.grau]6 i := p.grau− 17 mentre i ≥ 0 fer8 sol := sol ∗ x + p.coef [i]9 i := i− 110 fmentre11 retorna sol12 �un ióLes dades d'entrada són un polinomi i un valor, x. En aquest as, la mida de les dadesd'entrada és el grau del polinomi. Tot seguit passem a implementar el mètode habitual peravaluar un polinomi en un ert valor.

4.3. EXEMPLE: ALGORISMES D'AVALUACIÓ DE POLINOMIS 551 fun ió AvaluacioUsual(ent p : polinomi, ent x : enter) retorna enter2 var3 aux, sol, i, j : enter4 fvar5 sol := 06 i := 07 mentre i ≤ p.grau fer8 aux := 19 j := 110 mentre j ≤ i fer11 aux := aux ∗ x12 j := j + 113 fmentre14 sol := sol + p.coef [i] ∗ aux15 i := i + 116 fmentre17 retorna sol18 �un ióCom abans la mida de les dades d'entrada és el grau del polinomi. Vegem ara quina és la omplexitat de ada un dels algorismes anteriors.Per al ular el temps d'exe u ió dels algorismes utilitzarem unes onstants que són unitatsmínimes de temps:ta: temps d'una assigna iótac: temps d'a és a un amp d'un tipus de�nit amb el onstru tor tupla.tv: temps d'a és a una omponent d'un ve tor.tp: temps d'exe utar un produ tetd: temps de restar una unitat a un enter.ts: temps d'exe utar una suma.tc: temps d'una ompara ió.Vegem quina és la omplexitat del primer algorisme (avalua ió Horner). Per això avaluaremel temps d'exe u ió de ada línia de odi.• Línia 5 : ta + 2tac + tv

• Línia 6 : ta + tac + tdEl bu le de les línies 7�10 es realitzarà p.grau vegades i el ost que té ada op que entremen el bu le vindrà donat pels ostos de les línies 8�9 :• Línia 8 : ta + tp + tv + tac + ts

• Línia 9 : td + taLes línies 8 i 9 s'exe utaran n = p.grau ops, on n és la mida de les dades d'entrada.Cada op que entrem en la itera ió 7�10 es fa una ompara ió (expressió línia 7 : tc)). A més,es farà una ompara ió més que el nombre d'itera ions. Així don s el ost de l'algorisme deHorner vindrà donat per:2 · ta + 3 · tac + tv + td + n · (2 · ta + tp + tv + tac + ts + td + tc) + tc

56 CAPÍTOL 4. COMPLEXITAT ALGORÍSMICAD'aquesta expressió podem on loure que la omplexitat és lineal en la mida de les dadesd'entrada. Es a dir, que la omplexitat ve donada per una fun ió del tipus : A+ Bn.En el as del segon algorisme (avalua ió usual), om en el as de l'algorisme anterior, lamida de les dades d'entrada és n = p.grau. El àl ul de la omplexitat és:• Línia 5 : ta

• Línia 6 : ta

• Línia 7 : tac+tc. Ja que ada op es fa un a és a un amp d'una tuple i una ompara ió.Aquest bu le es farà n + 1 vegades, en anvi la ompara ió es farà n + 2 ops.• Línies 8 i 9 : 2 · ta

• Línies 10 a 12 : El ost de ada itera ió d'aquest bu le intern és tc + tp + 2 · ta + ts i esrealitza i ops. Per tant, el seu ost és i · (tc + tp + 2 · ta + ts) + tc.Com que i = 0, . . . , n, tenimn∑

i=0

(i · (tc + tp + 2 · ta + ts) + tc) = (tc + tp + 2 · ta + ts) ·n(n + 1)

2+ n · tcFinalment, el ost de la línia 14 és: ta + ts + tac + tv + tp, i el de la línia 15 és: ta + ts.Per tant, tenint en ompte tots els passos, la omplexitat d'aquest algorisme ve donadaper la fun ió quadràti a:

2 · ta + tac + tc +(n+1)(2 · tac + tc +4 · ta +2 · ts + tv + tp)+n(n + 1)

2· (tc + tp +2 · ta + ts)+n · tcD'aquesta llarga expressió podem on loure que la omplexitat d'aquest algorisme ve do-nada per una fun ió del tipus: A + B · n + C · n2. Es a dir, té omplexitat quadràti a.4.4 Càl ul de la fun ió de ostLa fun ió de ost d'un algorisme es al ula analitzant adas una de les seves instru ions.En totes les expressions que trobem en aquesta se ió, N representa la mida de les dadesd'entrada. Les propietats que fem servir en el àl ul de les fun ions de ost són les següents:4.4.1 Cost d'avaluar una expressióEl ost d'avaluar una expressió depèn del tipus d'expressió, i no sempre és onstant.1. Cost TV (N) d'avaluar una expressió formada per un valor, una onstant o una variable

V :TV (N) = TVon TV ∈ R

+, és un valor onstant.

4.4. CÀLCUL DE LA FUNCIÓ DE COST 572. Cost T⊙E(N) d'avaluar una expressió formada per un operador unari ⊙ apli at a unaexpressió E:T⊙E(N) = T⊙ + TE(N)on T⊙ ∈ R

+ és el ost d'apli ar l'operador unari ⊙ i TE(N) és el ost d'avaluar l'expressióE.3. Cost TE1⊕E2

(N) d'avaluar una expressió formada per un operador binari ⊕ apli at adues expressions E1 i E2:TE1⊕E2

(N) = TE1(N) + T⊕ + TE2

(N)on T⊕ ∈ R+ és el ost d'apli ar l'operador binari ⊕ i TE1

(N) i TE2(N) són el ostd'avaluar les expressions E1 i E2 respe tivament.4. Cost TF (E1,...,El)(N) d'avaluar una expressió formada per la rida a una fun ió de nom

F amb l paràmetres a tuals orresponents a les expressions E1, . . . , El:TF (E1,...,El)(N) = TF (N) + TE1

(N) + · · · + TEl(N)on TF (N) és el ost d'exe utar l'algorisme que implementa la fun ió F i TEi

(N) per1 ≤ i ≤ l és el ost d'avaluar l'expressió Ei.4.4.2 Cost d'exe utar una assigna ióEl ost d'assignar a una variable V el valor d'una expressió E depén del ost d'avaluar la orresponent expressió, és a dir,

TV :=E(N) = T:= + TE(N)on T:= ∈ R+ representa el ost elemental d'exe utar una assigna ió i TE(N) és el ost d'avaluarl'expressió E.4.4.3 Cost d'exe utar el retorn d'una fun ióEl ost de retornar el valor d'una expressió E depén del ost d'avaluar la orresponent expres-sió, és a dir,

Tretorna_E(N) = Tretorna + TE(N)on Tretorna ∈ R+ representa el ost elemental d'exe utar un retorn i TE(N) és el ost d'avaluarl'expressió E.4.4.4 Cost d'exe utar una rida a una a ióSuposem que volem avaluar el ost TA(E1,...,El,V1,...,Vm)(N) d'exe utar la rida a l'a ió de nom

A, on E1, . . . , El són expressions que ens donen els paràmetres a tuals d'entrada de l'a ió Ai les variables V1, . . . , Vm són els paràmetres a tuals de sortida o d'entrada/sortida de la ridaa exe utar-se.TA(E1,...,El,V1,...,Vm)(N) = TA(N) + TE1

(N) + · · ·+ TEl(N)on TA(N) és el ost d'exe utar l'algorisme que implementa l'a ió A i TEi

(N) per 1 ≤ i ≤ l ésel ost d'avaluar l'expressió Ei. Entenem que el ost d'exe utar l'algorisme ja in lou el ostd'a és a les variables V1, . . . , Vm, el qual és onstant.

58 CAPÍTOL 4. COMPLEXITAT ALGORÍSMICA4.4.5 Cost d'una omposi ió seqüen ialLa omposi ió seqüen ial de dues a ions A1 i A2 impli a la rida de A1 seguida de la rida aA2. Per tant, per avaluar el ost TA1; A2

(N) d'exe utar aquesta omposi ió seqüen ial hauràde ser la suma dels orresponents ostos:TA1; A2

(N) = TA1(N) + TA2

(N)on TA1(N) i TA2

(N) són el ost d'exe utar les a ions A1 i A2 respe tivament, en fun ióde N .4.4.6 Cost d'una omposi ió alternativaSi volem avaluar el ost d'una omposi ió alternativa amb prote ions Ei per i = 1, . . . , l iamb a ions Ai per i = 1, . . . , l, hem de tenir en ompte que les prote ions s'avaluaran totes,en anvi només s'exe utarà una úni a a ió, l'a ió orresponent a la prote ió que sigui erta.Per tant , el ost de :siE1 → A1

⊓⊔ E2 → A2

· · ·⊓⊔ El → Alfsies al ularà en el as pitjor, és a dir, quan s'exe uti l'a ió de ost màxim.Tsi E1 → A1 ⊓⊔ · · · ⊓⊔ El → Al fsi(N) = TE1

(N) + · · ·+ TEl(N) + max{TA1

(N), . . . , TAl(N)}on TEi

(N) i TAi(N) per 1 ≤ i ≤ l són el ost d'avaluar l'expressió Ei i el ost d'exe utarl'a ió Ai respe tivament.4.4.7 Cost d'una omposi ió iterativaL'avalua ió del ost d'una omposi ió iterativa amb prote ió E i a ió A, és a dir, del tipus:mentre E fer

Afmentreés fà ilment al ulable si ada itera ió té el mateix ost, és a dir, si el ost d'exe utar-se l'a ióA i la prote ió E no depenén de la itera ió que estem realitzant. En aquest as,

Tmentre E fer A fmentre(N) = f(N) · (TE(N) + TA(N)) + TE(N)on f(N) és el nombre d'itera ions, TE(N) és el ost d'avaluar l'expressió E i TA(N) és el ostd'exe utar l'a ió A. Observen que la prote ió s'ha d'exe utar un op més que l'a ió A.Si el ost de ada itera ió no podem assegurar que sigui onstant, aquesta fórmula no ésapli able. En aquest as, si es realitzen f(N) itera ions i el ost de la itera ió i és TE(N, i) +TA(N, i) (és a dir, el ost de la prote ió més el de l'a ió en el pas i-èssim) per i = 1, . . . , f(N),llavors el ost de la omposi ió iterativa serà:

Tmentre E fer A fmentre(N) =∑

i=1,...,f(N)TE(N, i) + TA(N, i)

4.5. CONCLUSIONS SOBRE L'ANÀLISI D'ALGORISMES 594.5 Con lusions sobre l'anàlisi d'algorismesLa fun ió de ost d'un algorisme depèn de:• La mida de les dades d'entrada, que hem representat per N .• El ontingut de les dades d'entrada• El omputador i el ompilador que s'han utilitzat.La dependèn ia del ontingut de les dades d'entrada es resoldrà estudiant el as pitjor( om ja hem dit en l'estudiar les omposi ions alternatives). Respe te al ter er fa tor, ladependèn ia del omputador i del ompilador, que en les expressions anteriors s'observa en elsvalors dels temps elementals, aquesta dependèn ia no es tindrà en ompte, és a dir, s'ignoraràa tots els efe tes. Per això, s'utilitza el riteri asimptòti .El riteri asimptòti analitza el ost o l'e� ièn ia dels algorismes independentment deles màquines i dels llenguatges, al ulant les fun ions de ost sense tenir en ompte onstantsmultipli atives. Segons hem dit, diferents implementa ions d'un mateix algorisme tenen tempsd'exe u ió els quals es diferen iaran en, om a molt, una onstant multipli ativa positiva.4.6 Mesures AsimptòtiquesDe�ni ió 1 Sigui f : N → R

+ una fun ió de�nida sobre els números naturals. De�niml'ordre de f(n) om,O(f(n)) = {g : N −→ R

+ | ∃n0 ∈ N ,∃ c0 ∈ R+ tals que ∀n ≥ n0 g(n) ≤ c0 · f(n)}En aquest as direm que g és de l'ordre de f(n) i ho denotarem om g ∈ O(f(n)). O(f(n))denota la família de fun ions que, om a molt, reixen tant ràpid om f(n), llevat possiblementuna onstant multipli ativa.Notem que si el temps d'exe u ió o el ost d'un algorisme ens dóna en una erta màquinauna fun ió O(f(n)) en una altra màquina tambè serà O(f(n)), ja que el fa tor que està lligata la màquina és un fa tor multipli atiu.Si el temps d'exe u ió d'un programa és donat per una fun ió f(n), direm que el programaté ordre de omplexitat O(f(n)).Una fun ió f(n) és del mateix ordre o d'ordre inferior que g(n) si f(n) ∈ O(g(n)).Si a més g(n) ∈ O(f(n)), aleshores g(n) i f(n) són del mateix ordre.4.6.1 PropietatsTot seguit enumerarem un onjunt de propietats que utilitzarem més endavant per al ularla omplexitat asimptòti a de omposisió d'algorismes. La demostra ió d'aquestes propietatss'obté a partir de la De�ni ió 1. Per tota fun ió de ost, per exemple,

∀f, f1, f2, g, g1, g2, h : N −→ R+es ompleix:

60 CAPÍTOL 4. COMPLEXITAT ALGORÍSMICA1. Invariàn ia multipli ativa.∀c ∈ R

+ g(n) ∈ O(f(n))⇒ c · g(n) ∈ O(f(n))2. Invariàn ia additiva.∀c ∈ R

+ g(n) ∈ O(f(n))⇒ c + g(n) ∈ O(f(n))3. Re�exivitat.f(n) ∈ O(f(n))4. Transitivitat.

h(n) ∈ O(g(n)) ∧ g(n) ∈ O(f(n))⇒ h(n) ∈ O(f(n))5. Criteri de ara teritza ió.g(n) ∈ O(f(n))⇔ O(g(n)) ⊆ O(f(n))6. Regla de la suma.

g1(n) ∈ O(f1(n)) ∧ g2(n) ∈ O(f2(n))⇒ (g1 + g2)(n) ∈ O(max(f1, f2)(n))on la fun ió suma de fun ions es de�neix om (g1 + g2)(x) = g1(x) + g2(x) i la fun iómàxim de fun ions es de�neix om (max(f1, f2))(x) = max(f1(x), f2(x)).7. Regla del produ te.g1(n) ∈ O(f1(n)) ∧ g2(n) ∈ O(f2(n))⇒ (g1 · g2)(n) ∈ O(f1(n) · f2(n))on la fun ió produ te de fun ions es de�neix om (g1 · g2)(x) = g1(x) · g2(x).D'aquestes propietats se'n poden derivar les onseqüèn ies següents:

• Considerem onstants a i b tals que 0 ≤ a ≤ b, llavors, es ompleix na ∈ O(nb). A méssón del mateix ordre si a = b, i si a < b, aleshores na és d'ordre inferior a nb.• Els ordres de omplexitat satisfan:

O(1) ⊂ O(logn) ⊂ O(n) ⊂ O(n2) ⊂ . . . ⊂ O(2n) ⊂ O(n!)

• Els termes d'ordre inferior no importen. Si T (n) = a0 + . . . + aknk on ak > 0, tenim

T (n) ∈ O(nk). De fet si T (n) és una suma de fun ions positives fi(n), aleshores T (n) ∈O(fk(n)), on fk és la fun ió d'ordre més gran de les {fi}.

• La base dels logaritmes no importa. Es a dir, ∀ b1, b2 > 0, logb1(n) ∈ O(logb2(n)), jaque podem passar d'una base d'un logaritme a una altra multipli ant per una onstant:logb1(n) = logb2(n) · logb1(b2)

4.6. MESURES ASIMPTÒTIQUES 61T (n) n = 100 n = 200

k1logn 1h 1.15hk2n 1h 2h

k3nlogn 1h 2.3hk4n

2 1h 4hk5n

3 1h 8hk62

n 1h 1.27 · 1030hTaula 4.1: Efe te de dupli ar la mida del problemaT (n) t=1h t=2h

k1logn n=100 n=10000k2n n=100 n=200

k3nlogn n=100 n=178k4n

2 n=100 n=141k5n

3 n=100 n=126k62

n n=100 n=101Taula 4.2: Efe te de dupli ar el temps4.6.2 ExemplesSuposem que per un problema determinat disposem de diferents algorismes amb ordres de omplexitat O(logn), O(n), O(nlogn), O(n2), O(n3), O(2n) i suposem que per una midad'entrada de n = 100 tots ells triguen un temps de T = 1h. La taula 4.1 mostra els tempsque trigarien aquests algorismes si dupliquem la mida del problema (n = 200). La taula 4.2mostra la mida de l'entrada que podrien tra tar tots aquests algorismes si dupliquéssim eltemps d'exe u ió [8℄.La taula 4.3 mostra per unes altres fun ions de ost orresponents a uns altres algorismesquina és la mida de l'entrada que es pot tra tar amb un temps d'exe u ió de 103s i 104srespe tivament. També mostra la propor ió de l'in rement.Cost en temps Mida entrada Mida entrada Propor ióT(n) per 103s per 104s in rement100n 10 100 10.05n2 14 45 3.2n3/2 12 27 2.32n 10 13 1.3Taula 4.3: Efe te de multipli ar el temps per 10La taula 4.4 torna a analitzar diferents algorismes amb les orresponents omplexitats iestudia el temps que triga la seva exe u ió per unes determinades mides d'entrada, n. Elstemps orresponen a una màquina que va a 1 M�op (Mega �oating point operations per segon).A la taula 4.4 es pot fer l'exer i i de suposar una màquina 1000 vegades o 106 vegades mésràpida (impli aria dividir els temps per aquestes quantitats) per omprovar el omportament

62 CAPÍTOL 4. COMPLEXITAT ALGORÍSMICAn=10 n=20 n=40 n=60 n=1000n 0.00001 s 0.00002 s 0.00004 s 0.00006 s 0.001 sn2 0.0001 s 0.0004 s 0.0016 s 0.0036 s 1 sn3 0.001 s 0.008 s 0.064 s 0.216 s 17 m2n 0.001 s 1 s 12.7 dies 36534 anysHome Cromagnonn! 3.629 s 77094 anys 2.6 · 1034 anys 2.6 · 1068 anysHome Neanderthal Edat de l'univers

1.5 · 1010 anysTaula 4.4: Temps orresponents a diferents mides d'entradaassimptòti dels algorismes.Finalment, la �gura 4.1 és una representa ió grà� a que permet omparar el ompartamentde diversos algorismes amb diferents ordres de omplexitat (logarítmi , lineal, quasilienal,quadràti , úbi , exponen ial i fa torial).4.7 Càl ul de ost asimptòti de la omposi ió d'algorismesEn aquesta se ió es veurà om apli ar les propietats de les mesures asimptòtiques per al ularl'ordre de omplexitat dels algorismes onstruits a partir d'estru tures ja onegudes. Els valorsasimptòti s s'obtindran apli ant les propietats vistes a la se ió 4.6.1 a les expressions trobadesen la se ió 4.44.7.1 Cost asimptòti d'avaluar una expressióCom ja hem dit, el àl ul del ost d'avalua ió d'una expressió, i per tant també el ostasimptòti , depèn del tipus d'expressió que avaluem.1. Si l'expressió està formada úni ament per un valor, una onstant o una variable V , el ost asimptòti d'avaluar-la no depèn de la mida de les dades, és a dir, és onstant:TV (N) ∈ O(1)2. Com que el ost d'apli ar un operador unari és onstant, és a dir, T⊙ ∈ O(1), apli ant laregla de les sumes, el ost asimptòti d'avaluar una expressió formada per un operadorunari ⊙ apli at a una expressió E és

T⊙E(N) ∈ O(TE(N))3. Com que T⊕ ∈ O(1), apli ant la regla de les sumes, el ost asimptòti d'avaluar unaexpressió formada per un operador binari ⊕ apli at a dues expressions E1 i E2 ésTE1⊕E2

(N) ∈ O(max{TE1(N), TE2

(N)})

4.7.CÀLCULDECOSTASIMPTÒTICDELACOMPOSICIÓD'ALGORISMES63

0

1000

2000

3000

4000

5000

mida de les dades (n)

tem

ps

500 log(n) + 50 50 351,03 527,121 652,06 748,97 828,151 895,098 953,09 1004,24 1050 1091,39 1129,18 1163,94 1196,13 1226,09 1254,12 1280,45 1305,27 1328,75 1351,03 1372,22 1392,42 1411,73 1430,21 1447,94

100 n 100 200 300 400 500 600 700 800 900 1000 1100 1200 1300 1400 1500 1600 1700 1800 1900 2000 2100 2200 2300 2400 2500

90 n log(n) 0 54,1854 128,823 216,742 314,537 420,202 532,412 650,225 772,936 900 1030,98 1165,52 1303,31 1444,12 1587,72 1733,93 1882,59 2033,54 2186,67 2341,85 2498,99 2658 2818,78 2981,26 3145,37

5 n^2 10 40 90 160 250 360 490 640 810 1000 1210 1440 1690 1960 2250 2560 2890 3240 3610 4000 4410 4840 5290 5760 6250

n^3 1 8 27 64 125 216 343 512 729 1000 1331 1728 2197 2744 3375 4096 4913 5832 6859 8000 9261 10648 12167 13824 15625

2^n 2 4 8 16 32 64 128 256 512 1024 2048 4096 8192 16384 32768 65536 131072 262144 524288 1048576 2097152 4194304 8388608 1,7E+07 3,4E+07

n! / 1000 0,001 0,002 0,006 0,024 0,12 0,72 5,04 40,32 362,88 3628,8 39916,8 479002 6227021 8,7E+07 1,3E+09 2,1E+10 3,6E+11 6,4E+12 1,2E+14 2,4E+15 5,1E+16 1,1E+18 2,6E+19 6,2E+20 1,6E+22

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

Figura4.1:Representa iógrà� adediferentsordresde omplexitat.

64 CAPÍTOL 4. COMPLEXITAT ALGORÍSMICA4. Per la regla de les sumes, el ost asimptòti d'avaluar una expressió formada per la rida a una fun ió de nom F amb l paràmetres a tuals orresponents a les expressionsE1, . . . , El ( om a pràmetres d'entrada de la fun ió), a més d'altres variables que podenser d'entrada/sortida o sortida, és

TF (E1,...,El)(N) ∈ O(max{TF (N), TE1(N), . . . , TEl

(N)})4.7.2 Cost asimptòti d'una assigna ióEl ost asimptòti de realitzar una assigna ió del tipus V := E, on V és una variable i E ésuna expressió, es al ula tenint en ompte que T:= ∈ O(1) i apli ant la regla de les sumes.Tenim per tant,TV :=E(N) ∈ O(TE(N))4.7.3 Cost asimptòti del retorn d'una fun ióEl ost asimptòti de realitzar un retorn del tipus retorna E, on E és una expressió, es al ula tenint en ompte que Tretorna ∈ O(1) i apli ant la regla de les sumes. Tenim per tant,

Tretorna_E(N) ∈ O(TE(N))4.7.4 Cost asimptòti d'una rida a una a ióPer al ular el ost asimptòti d'una rida a una a ió de nom A amb les expressions E1, . . . , El om a paràmetres a tuals d'entrada i les variables V1, . . . , Vm om a paràmetres a tuals desortida o d'entrada/sortida apli arem, de nou, la regla de les sumes a l'expressió trobada enla se ió 4.4. Utilitzant que l'avalua ió i a és a una variable és d'ordre onstant, tenimTA(E1,...,El,V1,...,Vm)(N) ∈ O(max{TA(N), TE1

(N), . . . , TEl(N)})4.7.5 Cost asimptòti d'una omposi ió seqüen ialEl àl ul del ost asimptòti d'una omposi ió seqüen ial de dues a ions A1 i A2 es basa enl'apli a ió de la regla de les sumes. Tenim:

TA1; A2(N) ∈ O(max{TA1

(N), TA2(N)})4.7.6 Cost asimptòti d'una omposi ió alternativaSi volem avaluar el ost asimptòti d'una omposi ió alternativa amb prote ions Ei per

i = 1, . . . , l i amb a ions Ai per i = 1, . . . , l, apli arem de nou la regla de les sumes i al ularem el ost en el as pitjor, és a dir, quan s'exe uti l'a ió de ost màxim. D'aquestamanera tenim la següent expressió:Tsi E1 → A1 ⊓⊔ · · · ⊓⊔ El → Al fsi(N) ∈ O(max{TE1

(N), . . . , TEl(N), TA1

(N), . . . , TAl(N)})

4.8. BIBLIOGRAFIA RELACIONADA 654.7.7 Cost asimptòti d'una omposi ió iterativaEl àl ul del ost asimptòti d'una omposi ió iterativa és fà ilment al ulable en el as quetotes les itera ions tinguin la mateixa omplexitat, és a dir, quan el ost de l'avalua ió dela prote ió E i de l'exe u ió de l'a ió A és independent de la itera ió. En aquest as, perla regla dels produ tes i la regla de les sumes, el ost asimptòti d'exe utar la omposi ióiterativa amb prote ió E i a ió A ésTmentre E fer A fmentre(N) ∈ O(f(N) ·max{TE(N), TA(N)})Ara bé, sovint ens trobarem estru tures iteratives en que el ost de la itera ió no és onstant. Ens aquests asos, s'haurà de al ular la fun ió de ost om la suma de les fun ionsde ost per ada itera ió i, un op al ulada, apli ar les propietats de les mesures asimptòtiquesvistes previament.4.8 Bibliogra�a rela ionadaAquest tema es pot ampliar amb el apítol 1 del llibre [8℄.

66 CAPÍTOL 4. COMPLEXITAT ALGORÍSMICA

Capítol 5Cer a i Ordena ió5.1 Introdu ióSovint, els algorismes que tra ten dades prèviament ordenades són més e� ients en tempsde omputa ió que els algorismes que tra ten les mateixes dades sense ap ordre establerta priori. Nosaltres mateixos trobem ràpidament qualsevol osa que erquem si prèviamentaquesta ha estat ben endreçada. En aquest apítol veurem que l'ordena ió prèvia de dadespermet onstruir algorismes més e� ients per tra tar-les. De fet, així ho hem vist en estudiarla fusió de �txers FST. Els obje tius d'aquest apítol són dos:1. Dissenyar alguns algorismes que ordenen les dades i algorismes que erquen dades quanja estan ordenades.2. Analitzar la omplexitat dels algorismes proposats.Començarem estudiant la er a d'un element tal om la oneixem �ns ara i després la mi-llorarem pel as en què les dades estiguin ordenades. Això ens portarà a onèixer l'algorismede er a di otòmi a. Es tra ta d'una idea senzilla que sovint es desenvolupa de forma alegrerealitzant programes in orre tes i de depura ió molt lenta. Només amb un desenvolupamentmetodològi i tenint ura del seguiment dels diferents estats pels quals passa l'algorisme resul-tant, podrem assegurar la seva orre tesa. La di� ultat d'aquest algorisme és, en part, deguta l'ús de l'a és dire te, més difí il d'entendre que l'a és seqüen ial. El resultat de l'anàliside la seva omplexitat demostrarà que ens trobem davant d'un dels algorismes més e� ientsper la er a d'un element.La er a di otòmi a és un bon exemple d'algorisme e� ient que apro�ta el fet que les dadesestiguin ordenades. D'aquí, la importàn ia de trobar algorismes que ordenin les dades. Nohi ha una solu ió úni a. Aquí presentaren l'algorisme d'ordena ió per sele ió per introduir-nos en el tema de l'ordena ió, malgrat que l'algorisme presentat ni és el més e� ient dels quees poden proposar, ni l'úni que resol l'ordena ió.5.2 Espe i� a ió d'estats d'una taula en el ontext d'ordena ióPer laredat d'exposi ió, tots els algorismes que desenvoluparem aquí treballaran sobre unataula d'enters totalment plena de dimensió N (evidentment N és una onstant de�nida apriori): 67

68 CAPÍTOL 5. CERCA I ORDENACIÓtipus taulaEnters = taula [1..N ] de enter ftipusPer omentar i espe i� ar els diversos estats que assoliran les taules amb què treballen elsalgorismes que presentarem en aquest tema, farem algunes abrevia ions per es riure de formamés on isa les espe i� a ions.En aquest tema parlarem de si les taules estan ordenades o no. Per a�rmar que una taulat de N enters està ordenada as endentment ho podem expressar de la següent manera:

t[1] ≤ t[2] ≤ t[3] ≤ . . . ≤ t[N − 1] ≤ t[N ]O més pre isament om:per tot k, omprès entre 1 i N − 1 (1 ≤ k < N) es ompleix que t[k] ≤ t[k + 1].Per abreujar l'espe i� a ió, de�nirem la fun ió lògi a OrdenatAsc(t) que ens indi arà sitots els elements de la taula t estan ordenats as endentment. Per tant,OrdenatAsc(t) ≡per tot k, (1 ≤ k < N), es ompleix que t[k] ≤ t[k + 1]A vegades, ens interessarà referir-nos a una propietat que només ompleixen els elementsd'una part o se ió d'una taula. Si tenim la taula t de N elements i ens volem referir a lase ió ompresa entre i (índex d'ini i de se ió) i f (índex de � de se ió) la denotarem per

t[i..f ]. Per exemple, si tenim una taula t de 100 elements i volem expressar el fet que en elselements de la se ió ompresa entre els índexs 4 i 20 estan ordenats, es riurem:OrdenatAsc(t[4..20])que serà equivalent a a�rmarper tot k, (4 ≤ k < 20), es ompleix que t[k] ≤ t[k + 1].Al llarg del tema, introduirem altres fun ions lògiques d'aquest estil.5.3 Cer a d'un element en una taula ordenadaEns proposen solu ionar el següent enun iat:Dissenyeu una fun ió que indiqui si un enter x és en una taula t d'enters ordenatsas endentment.Comen em espe i� ant l'enun iat:Espe i� a ió : En la pre ondi ió establirem que la taula està ordenada. Farem ús dela fun ió OrdenatAsc de�nida a l'apartat anterior.També de�nirem HiEs(x, t) om una fun ió booleana que és erta si un element x es trobaa la taula t. Més formalment HiEs(x, t) és equivalent al predi atexisteix una k, 1 ≤ k ≤ N tal que ompleix x = t[k]Amb aquestes de�ni ions, l'espe i� a ió del nostre problema queda om:

5.3. CERCA D'UN ELEMENT EN UNA TAULA ORDENADA 69{x = X ∧ t = T ∧N > 0 ∧OrdenatAsc(T )}fun ió Cercar(x : enter; t : taulaEnters) retorna booleà{x = X ∧ t = T∧ (Cercar(x, t) és ert si es ompleix HiEs(x, T ))}Passem a plantejar la solu ió.5.3.1 Cer a linealEl primer plantejament que podem fer és apli ar l'esquema de er a d'un element que s'hadonat en el tema anterior. De fet, és un esquema general que fun iona sempre independentmentde si els elements de la taula estan ordenats o no. L'anomenarem er a lineal.La solu ió és:1 {x = X ∧ t = T ∧N > 0}2 fun ió CercaLineal(x : enter; t : taulaEnters) retorna booleà3 var i : enter; trobat : booleà fvar4 trobat := fals5 i := 16 mentre ¬trobat ∧ i ≤ N fer7 si t[i] = x → trobat := ert8 ⊓⊔ t[i] 6= x → i := i + 19 fsi10 fmentre11 retorna trobat12 �un ió13 {x = X ∧ t = T∧ (Cercar(x, t) és ert si es ompleix HiEs(x, T ))}La mida de les dades és N . Per analitzar la omplexitat farem ús de la numera ió de leslínies. Així, t4 indi arà el ost en temps de la línia 4 de l'algorisme proposat, t6−10 el ost entemps de les línies que van des de la 6 �ns la 10.Tenim quetCercaLineal(N) = t4(N) + t5(N) + t6−10(N) + t11El ost t4(N) pertany a O(1), ja que els ostos en temps de l'assigna ió i de l'expressiófals pertanyen a O(1). També tenim que t5(N) ∈ O(1), ja que l'avalua ió de l'expressió de la onstant 1 pertany a O(1). L'ordre del ost en temps de l'avalua ió de l'expressió de retorn(línia 11) de la fun ió també és O(1). Per re�exivitat, t6−10(N) ∈ O(t6−10(N)), i per la reglade les sumes, tenim

O(tCercaLineal(N)) ∈ O(t6−10(N))Si anomenem f(N) al nombre de vegades que s'exe uta el mentre , i te6(N) és el ost entemps per avaluar l'expressió del mentre , el ost de la itera ió, t6−10(N), vindrà donat pert6−10(N) = f(N) · (te6(N) + t7−9(N)) + te6(N) ∈ O(f(N) · (max{te6(N), t7−9(N))})ja que ni el ost de l'expressió del mentre , ni els ost del os del mentre no depenen de ap variable que anvii el seu valor en la itera ió.

70 CAPÍTOL 5. CERCA I ORDENACIÓL'expressió del mentre s'avalua de forma onstant, i per tant, te6(N) ∈ O(1), obtenint:t6−10(N) ∈ O(f(N) · (t7−9(N)))El ost de l'alternativa serà

t7−9(N) ∈ O(max{te7(N), te8(N), ta7(N), ta8(N)})on tei es refereix a l'expressió de l'alternativa, i tai l'a ió a exe utar de la línia i. És fà il omprovar que te7(N) ∈ O(1), te8(N) ∈ O(1), ta7(N) ∈ O(1), i ta8(N) ∈ O(1), i per tant,t7−9(N) ∈ O(1)

t6−10(N) ∈ O(f(N)) per la regla dels produ tes.O(tCercaLineal(N)) ∈ O(f(N))El problema que tenim en analitzar aquest algorisme és saber quantes itera ions farà jaque depèn de si troba l'enter aviat o no. Per exemple, si l'enter a er ar és el primer de lataula, el mentre s'exe uta un op, mentre que si no hi és a la taula, s'exe uta N ops.Quan tenim diverses possibilitats agafarem sempre la possibilitat que sigui la pitjor en ost. En l'anàlisi que ens o upa, l'enter no es troba a la taula. Per tant, f(N) ∈ O(N), i

O(tCercaLineal(N)) ∈ O(N)Algunes vegades, i depenen del problema a analitzar, pot tenir sentit parlar d'altres asosque no siguin el pitjor, bé per ressaltar alguns aspe tes sobre el omportament de l'algorismea analitzar, o bé, per què els asos onsiderats són freqüents. Per exemple, en el nostre as noté ap sentit parlar del as millor (l'element és el primer de la taula), ja que si aquest és donéssempre, arribaríem a la on lusió que no al apli ar l'algorisme: per què er ar un element siaquest sempre es troba a la primera posi ió?El as mig és més difí il d'analitzar en general ja que al de�nir el as de forma orre tai això depèn de diverses onsidera ions, a més de formula ions més omplexes pel seu anàlisi.No ho tindrem en ompte aquí, tot i que és força important, ja que ens hauria d'importar el omportament asimptòti de l'algorisme en els asos més freqüents. En general, el as mig dela er a lineal és O(N).5.3.2 Cer a lineal millorada per a taules ordenadesEn l'anterior mètode de er a no trèiem ap pro�t del fet que la taula estigui ordenada. En anvi, amb una petita modi� a ió, podem fer que això sigui possible, i obtindrem per alguns asos una millora signi� ativa. El seu as pitjor, però segueix essent el mateix que l'anterior.La fun ió resultant és:

5.3. CERCA D'UN ELEMENT EN UNA TAULA ORDENADA 711 {x = X ∧ t = T ∧N > 0 ∧OrdenatAsc(T )}2 fun ió CercaLineal(x : enter; t : taulaEnters) retorna booleà3 var i : enter; trobat : booleà fvar4 trobat := fals5 i := 1;6 mentre ¬trobat ∧ i ≤ N fer7 si t[i] ≥ x → trobat := ert8 ⊓⊔ t[i] < x → i := i + 19 fsi10 fmentre11 retorna t[i] = x12 �un ió13 {x = X ∧ t = T∧ (Cercar(x, t) és ert si es ompleix HiEs(x, T ))}El anvi de les expressions de l'alternativa respe te a la versió anterior és signi� atiu iapro�ta el fet que els elements de la taula estan ordenats as endentment. Si trobem que x ésmés gran que l'element a tual onsultat vol dir que s'haurà de trobar més endavant, en el asque hi sigui. Si trobem que t[i] > x perdem l'esperança de trobar-lo més endavant, ja que siaixò fos possible, la taula no estaria ordenada. Més que er ar l'element, erquem en quinaposi ió hauria d'estar.Observeu ara que el as pitjor no ha de ser ne essàriament un element que no sigui a lataula, ja que per tot element x menor al primer element de la taula sabem de seguida que nohi és a la taula en omparar-lo amb el primer element. El as pitjor el tenim només quan x ésmés gran que el darrer element de la taula. L'anàlisi de la omplexitat és similar a la versióanterior . És a dir, el as pitjor és O(N).5.3.3 Cer a di otòmi aEl mètode de er a lineal no és el que fem habitualment, quan, per exemple, onsultem undi ionari, una en i lopèdia o una guia telefòni a. Quan erquem el telèfon d'un abonat enla guia, a ostumem a obrir la guia per una pàgina, omprovem si la lletra ini ial de l'abonat oin ideix amb el desitjat i, en as negatiu, apro�tem el resultat per dirigir-nos a un dels dosgrups de pàgines en que la pàgina onsultada divideix la guia per prosseguir la er a.Per exemple, imaginem que tenim la següent taula t:1 98 11 23 37 46 60 114 123 175i ens proposem er ar el valor 20 (x = 20) a la taula. Comen em per inspe ionar el inquèelement m = 5 de la taula.1 5 98 11 23 37 46 60 114 123 17520 < 46Trobem que el valor orresponent a l'esmentat índex és 46, i veri� a 20 < 46, (x < t[m]).Atès que la taula és ordenada, on loem que el 20 ha de trobar-se, en el as de ser-hi, en lapart esquerra de la taula orresponent als índexs 1 a 5. Prosseguim, don s, amb aquesta partinspe ionant la omponent 3.

72 CAPÍTOL 5. CERCA I ORDENACIÓ1 3 5 98 11 23 37 46 60 114 123 17520 < 23Ara sele ionem la part ompresa entre els índexs 1 i 3.1 2 3 98 11 23 37 46 60 114 123 175

20 > 11Aquí trobem que 20 > 11 i, per tant, el 20 ha de trobar-se en la part dreta [2..3] de lase ió [1..3]. 1 2 3 98 11 23 37 46 60 114 123 17511 < 20 < 23...arribant a la on lusió que el 20 ha de trobar-se entre els elements de les posi ions 2 i 3 dela taula. Per tant, el valor er at no és a la taula. Noteu que en una er a lineal hauríem defer nou ompara ions en omptes de les quatre que hem fet. El mètode promet ser e� ient.Generalitzant, el mètode de la er a di otòmi a onsisteix en omparar un element qual-sevol de la taula t, diguem t[m], amb l'element x a er ar. Si el resultat produeix x < t[m], as que x sigui a la taula, haurà d'estar a la part esquerra de la mateixa i des artem er ar-loa la part dreta. Si el resultat és x > t[m] haurem de er ar l'element a la part esquerra ides artem la part dreta. Seguim el mateix pro ediment a la part es ollida �ns que la part onpugui estar ontingui dos o menys elements.Observem que més que er ar l'element en sí, erquem la seva posi ió ja que l'ordena ióde la taula ens permet de idir progressivament a quina se ió d'aquesta ha de trobar-se, en el as que existeixi. Una se ió de la taula la podem des riure per dos índexs e (d'esquerra) i d(de dreta) de la taula orresponents a l'element ini ial i �nal de la se ió t[e..d].

. . . e d . . .

. . . . . . . . .Identi� a ió de la seqüèn iaUn op omprès el mètode, passem a veure si podem identi� ar alguna seqüèn ia amb elproblema. Atès que, de les dues se ions de la taula en des artem només una, sempre existiràuna se ió per inspe ionar. Podem re onèixer en el mètode la genera ió d'una seqüèn ia dese ions de la taula t, t[e1..d1], t[e2..d2], . . . , t[ef ..df ], que ompleixen la propietat que l'elementa er ar, en el as de ser-hi, ha de trobar-se dins de la se ió; és a dir, t[e] ≤ x < t[d].L'asimetria de la desigualtat és expressa i s'entrendrà més endavant.Re ordem que les seqüèn ies es ara teritzen mitjançant la identi� a ió de:• El primer element• Cóm s'obté l'element següent• L'element �nal

5.3. CERCA D'UN ELEMENT EN UNA TAULA ORDENADA 73En el nostre as, tenim:• La primera se ió hauria de ser tota la taula. Però això no és possible, ja que no podemassegurar que l'element x a er ar hi sigui: x < t[1] ∨ x > t[N ]. Una solu ió a aquestproblema és omprovar aquests asos abans de pro edir i suposar om a pre ondi ió del'algorisme a desenvolupar que t[1] ≤ x < t[N ]; és a dir, l'element haurà de trobar-se, siés que hi és, en una posi ió vàlida dins del rang d'índexs de la taula.var . . . Posicio : enter; . . . fvar

. . .si x < t[1] → Posicio := 0⊓⊔ t[1] ≤ x ∧ x < t[N ] → Posicio := CercarDPos(x, t)⊓⊔ x ≥ t[N ] → Posicio := Nfsiretorna Posicio. . .Una altra solu ió onsisteix en posar dos sentinelles � ti is en la taula que assegurin quex hagi d'estar sempre dins de la taula t:0 1 N N+1

−∞ ∞Ara tenim que t[0] = −∞ y t[N +1] =∞ i podem assegurar que per la se ió t[0..N +1]es ompleix t[0] ≤ x < t[N +1]. Optem per aquesta solu ió per de�nir el primer elementde la seqüèn ia.Com que aquests sentinelles són � ti is onvé que l'algorisme a dissenyar no els onsultimai, ja que en realitat no existeixen. A més, aquesta op ió ens permetrà simpli� ar elspredi ats quan espe i�quem l'algorisme.• La se ió �nal t[ef ..df ] ens ha d'ajudar a de idir fà ilment en quina posi ió ha de trobar-se l'element a er ar en el as que hi sigui. Les possibilitats són: de�nir una se ió delongitud buida, d'una posi ió o de dues posi ions. Una de isió raonable és que la se iósigui de longitud 2, de forma que es pugui a�rmar fà ilment que t[ef ] ≤ x < t[df ] i pertant, om que df = ef + 1, tenim que t[ef ] ≤ x < t[ef + 1].Les possibles se ions �nals són:

t[0..1]︷ ︸︸ ︷

t[N..N+1]︷ ︸︸ ︷

. . .

︸ ︷︷ ︸

t[1..2]

︸ ︷︷ ︸

t[N−1..N ]I per tant, tenim que la darrera se ió ompleixx = X ∧ t = T ∧ 0 ≤ e < N + 1 ∧ t[e] ≤ x < t[e + 1]A partir de la qual on loem que només queda per omprovar t[e] = x per saber sil'element és a la taula o no.

74 CAPÍTOL 5. CERCA I ORDENACIÓ• La següent se ió t[ek+1..dk+1] s'obtindrà a partir del resultat de omparar x amb unelement de la se ió a tual t[ek..dk]. La ompara ió de idirà quina de les dues novesse ions serà la següent se ió que haurà de omplir t[ek+1] ≤ x < t[dk+1]. Per oherèn iaamb la primera se ió de�nida (0..N + 1), els elements que onsultem hauran de ser elsque estan ompresos entre el primer i el darrer de la se ió.e Elements a consultar

︷ ︸︸ ︷ dPodem observar que totes les se ions que generem de la taula han de omplir que(0 ≤ e < d ≤ N + 1) ∧ (t[e] ≤ x < t[d])Passem a desenvolupar l'algorisme omençant per la nova espe i� a ió.

{x = X ∧ t = T ∧OrdenatAsc(T ) ∧ (t[0] ≤ x < t[N + 1]}fun ió CercaDPos(x : enter, t : taulaEnters) retorna enter{x = X ∧ t = T ∧ 0 ≤ e < N + 1 ∧ t[e] ≤ x < t[e + 1]

On e = CercaDPos(x, t)}La pre ondi ió estableix que la taula està ordenada, i aquest fet junt amb la desigualtatque la segueix, ens indi a que la posi ió de l'element a er ar ha de ser dins la taula � tí ia.En la post ondi ió hem tingut en ompte els índexs de la taula. Cal observar que l'índex epot prendre el valor 0, ja que hem de omptar amb la possibilitat que x < t[1]. El as t[N ] < xja està ontemplat en la post ondi ió (Quan e = N es té t[N ] ≤ x < t[N + 1]).Un op s'ha sele ionat la posi ió, per saber si l'element està present faltarà fer:fun ió Cercar(x : enter, t : taulaEnters) retorna booleàvar i : enter; HiEs : booleà fvari := CercaDPos(x, t)si i 6= 0 → HiEs := x = t[i]⊓⊔ i = 0 → HiEs := falsfsiretorna HiEs�un ióHem identi� at el problema om un as de re orregut. Per tant, apli ant l'esquema dere orregut pel nostre as, tenim

. . .ObtenirPrimeraSe iómentre ¬DarreraSe ió ferObtenirSegüentSe iófmentre

. . .Comen em per establir la apçalera i les variables que farem servir. Les variables e (es-querra) y d (dreta) des riuran la se ió de la taula t.

5.3. CERCA D'UN ELEMENT EN UNA TAULA ORDENADA 75fun ió CercaDPos(x : enter, t : taulaEnters) retorna entervar e, d : enter fvarRe�nem l'esquema de re orregut:Obtenir primera se ió ≡ e := 0; d := N + 1;I podrem a�rmar que la primera se ió ompleix que (i forçarem que per les restants tambého sigui):I : (0 ≤ e < d ≤ N + 1) ∧ (t[e] ≤ x < t[d])que ve a dir que les se ions t[e..d] han de omplir sempre (t[e] ≤ x < t[d]) (l'element en asde ser-hi s'ha de trobar dins de la se ió de taula entre e i d) i que els índexs dels extrems deles se ions han d'estar entre els límits de la taula � tí ia. Com que aquesta propietat s'ha demantenir per totes les se ions generades, la propietat serà invariant al llarg de la genera ióde se ions.Per tant, fun ió CercaDPos(x : enter, t : taulaEnters) retorna entervar e, d,m : enter fvar

e := 0; d := N + 1;{(0 ≤ e < d ≤ N + 1) ∧ (t[e] ≤ x < t[d])}El darrer element de la seqüèn ia de se ions haurà de omplir que

d = e + 1i observem que aquesta ondi ió ens dóna la post ondi ió desitjada.Així don s, mentre no darrera se ió ...fun ió CercaDPos(x : enter, t : taulaEnters) retorna entervar e, d,m : enter fvare := 0; d := N + 1;{(0 ≤ e < d ≤ N + 1) ∧ (t[e] ≤ x < t[d])}mentre e + 1 6= d ferSi estem dins del os del mentre, sabem que la se ió no és la darrera. Haurem de generar lasegüent se ió que segueixi omplint la propietat desitjada i de manera que la seva longitudsigui més reduïda que l'anterior per a poder arribar a la darrera.Per assegurar la propietat de la se ió s'haurà de omparar x amb algun element de lase ió a tual.A més, els extrems de la se ió no poden onsultar-se, ja que en el as de la primera se ióaquests extrems no existeixen (t[0] i t[N + 1]). Per tant, l'índex, m, de l'element que onsul-tarem haurà de omplir que e < m < d. Pel moment, suposem una fun ió V alorEntre(e, d)que retorna un valor entre e i d (e < m < d). Més endavant la on retarem.fun ió CercaDPos(x : enter, t : taulaEnters) retorna entervar e, d,m : enter fvar

e := 0; d := N + 1;{(0 ≤ e < d ≤ N + 1) ∧ (t[e] ≤ x < t[d])}mentre e + 1 6= d fer

m := V alorEntre(e, d){e < m < d}

76 CAPÍTOL 5. CERCA I ORDENACIÓA ontinua ió poden passar dos fets: x < t[m] o bé x ≥ t[m]. Tra tem-los per separat itenint en ompte que la propietat invariant no ha estat modi� ada després de l'assigna ió dem, tenim que si es ompleix x < t[m] llavors podem a�rmar que t[e] ≤ x < t[m]. O sigui, mpot fer el paper que abans feia d, i a més, tenim que m < d, obtenint una se ió de longitudmés petita. Fent d := m, tindrem don s, la nova se ió. Si tenim que x ≥ t[m], podem a�rmarque t[m] ≤ x < t[d], i fent e := m obtindrem la nova se ió de longitud més petita (e < m).Per tant, fun ió CercaDPos(x : enter, t : taulaEnters) retorna entervar e, d,m : enter fvar

e := 0; d := N + 1;mentre e + 1 6= d ferm := V alorEntre(e, d)si x < t[m] → d := m⊓⊔ x ≥ t[m] → e := mfsifmentreretorna e�un ióQueda per de idir en què onsistirà la fun ió V alorEntre(e, d)Una possibilitat seria que V alorEntre(e, d) = e + 1. Com que la fun ió s'exe uta dins dela itera ió, es té om a pre ondi ió de la fun ió, e + 1 < d i e + 1 < d ⇒ e < e + 1 < d,satisfent la post ondi ió desitjada de la fun ió e < V alorEntre(e, d) < d. No obstant això,aquesta ele ió ondueix a un algorisme semblant a la er a lineal, pel què fa al seu ost. Lalongitud de la se ió es redueix en 1 a ada pas de la itera ió. La mateixa on lusió es troba sies ollim V alorEntre(i, d) = d− 1, que onsistiria en fer una er a lineal omençant pel �nalde la taula.Una manera de fer més e� ient l'algorisme és que V alorEntre(e, d) = (e + d) div 2. Lalongitud de ada nova se ió es veurà reduïda aproximadament a la meitat, i per tant, aldranmenys passos que en l'anterior fun ió per arribar a la se ió �nal. Cal omprovar si la novaproposta ompleix la post ondi ió desitjada de la fun ió (e < V alorEntre(e, d) < d). Don sbé, sempre que e + 1 < d (la ondi ió de la itera ió, i per tant, pre ondi ió a l'opera ió) es téque e < (e + d) div 2 < d.Finalment, la fun ió queda:1 fun ió CercaDPos(x : enter, t : taulaEnters) retorna enter2 var e, d,m : enter fvar3 e := 0; d := N + 1;4 mentre e + 1 6= d fer5 m := (e + d) div 26 si x < t[m] → d := m7 ⊓⊔ x ≥ t[m] → e := m8 fsi9 fmentre10 retorna e11 �un ió

5.3. CERCA D'UN ELEMENT EN UNA TAULA ORDENADA 77Observa ions• El fet que abans de l'alternativa es tingui e < m < d, assegura que no es onsulten lesposi ions t[0] y t[N + 1]. Noteu a més que a ex ep ió de la primera se ió, els extremsde la resta de se ions sempre han sigut onsultats.• Hi ha qui té pressa i desenvolupa un algorisme que en el moment en que troba que t[m] =

x surt de la itera ió. Malgrat que en algun as serà e� ient, per exemple quan el primerelement onsultat ja és l'element a er ar, en la majoria de asos l'algorisme resultantes menys e� ient, ja que la itera ió ha de fer una ompara ió de més, i l'alternativa tétambé una ompara ió de més. La millora per alguns asos es fa en detriment d'altres asos que poden esdevenir més freqüents.• Existeixen altres versions de l'algorisme que difereixen bàsi ament en si la se ió t[e..d]ha de omplir

t[e] ≤ x < t[d], ot[e] < x ≤ t[d], ot[e] < x < t[d] (en el as que es vulgui sortir quan t[m] = x), i si la longitud de lase ió �nal és 2 (d = e + 1), 1 (e = d) o 0 (d < e). Cal anar en ompte amb l'opera ió(e + d) div 2 que dóna omportaments diferents, així om el rang de l'índex retornat.Anàlisi de la omplexitatLa mida de les dades és N , és a dir el nombre d'enters que hi ha a la taula.

tCercaDicotomica(N) = t3(N) + t4−9(N) + t10(N)El ost de t3(N) és el de la omposi ió seqüen ial de dues assigna ions que ontenenexpressions que s'avaluen en temps onstant: t3(N) ∈ O(1). En la línia 10 es retorna unaexpressió que s'avalua en temps onstant. Per tant, t10(N) ∈ O(1). Per la regla de les sumesi re�exivitat:tCercaDicotomica(N) ∈ O(t4−9(N))i

t4−9(N) = f(N) · (te4(N) + t5−8(N)) + te4(N) ∈ O(f(N) · (max{te4(N), t5−8(N)})on f(N) és el nombre de vegades que s'exe uta el mentre, te4(N) és el ost en temps peravaluar l'expressió del mentre. Tenim que ni el ost de l'expressió del mentre, ni el ost del os del mentre depenen de les variables de la itera ió,L'expressió del mentre s'avalua de forma onstant (una suma, un operador rela ional) , iper tant, te4(N) ∈ O(1), i obtenim:t4−9(N) ∈ O(f(N) · (t5−8(N)))El ost de l'alternativa serà

t5−8(N) ∈ O(max{te5(N), te6(N), ta5(N), ta6(N)})

78 CAPÍTOL 5. CERCA I ORDENACIÓon tei es refereix a l'expressió de l'alternativa, i tai l'a ió que exe utarem de la línia i. Éspot omprovar que te5(N) ∈ O(1) (operador rela ional), te6(N) ∈ O(1) (operador rela io-nal), ta5(N) ∈ O(1) (assigna ió amb expressió de ost en temps onstant), i ta6(N) ∈ O(1)(assigna ió amb expressió en temps onstant), i per tant,t5−8(N) ∈ O(1)

t4−9(N) ∈ O(f(N)) per la regla de produ tes.tCercaDicotomica(N) ∈ O(f(N))Ens resta per esbrinar quantes vegades s'exe uta el mentre. Si anomenem l la longitudde la se ió de la taula (l = d−e+1), al �nal de la itera ió tindrem que l = 2, ja que d = e+1i fa que l = e + 1− e + 1 = 2. A més, a ada itera ió, la longitud de la se ió és la meitat quela de la se ió anterior.És a dir, si ini ialment tenim l = L = N + 2, a la primera itera ió l = ⌊L2 ⌋, a la segona,

l = ⌊ L22 ⌋, et . Si s'exe uta f(N) vegades:

2 =L

2f(N)of(N) = log2(L)− 1 = log2(N + 2)− 1 ∈ O(log(N))on hem obviat els trun aments i onstants, ja que ens interessava l'ordre de la fun ió. Aixídon s,

tCercaDicotomica(N) ∈ O(log(N))Noteu la millora obtinguda, ja que deixant de banda algunes onstants, el nombre depassos a fer per una taula de 1024 enters és aproximadament de 10 (log21024) per qualsevol as, mentre que utilitzant la er a lineal pot arribar a ser de 1024 en el as pitjor.5.4 Ordena ióEn aquest apartat tra tem l'ordena ió d'elements d'una taula. Sense pèrdua de generalitatsuposarem que els elements són enters. No obstant això, el que omentarem aquí serà apli ablea qualsevol tipus que tingui una rela ió d'ordre.Així don s, intentarem resoldre el següent enun iat:Donada una taula de n enters, dissenyeu una a ió que ordeni as endentment totsels enters de la taula.Hi ha moltes solu ions possibles a aquest enun iat, ja que hi ha molts mètodes per orde-nar un onjunt d'elements ordenables. Abans, però, de omençar a exposar alguns mètodesque porten a la solu ió onvé fer algunes onsidera ions que són omunes als algorismes quepresentarem.La primera és que ens interessarem per aquells mètodes en que no algui utilitzar una omés taules auxiliars de més. Si l'ordena ió la podem fer en la mateixa taula que ens donen,obtindrem un algorisme que podrà ordenar un màxim de dades d'a ord amb la memòria queel omputador té disponible. Si de larem més taules de la mateixa mida que la que hemd'ordenar, no podrem apro�tar tota la memòria disponible.

5.4. ORDENACIÓ 79Fer-ho en una sola taula omportarà que part del mètode onsistirà en moure els elementsde la taula d'una posi ió a una altra per tal d'assolir progressivament la posi ió que li to a a ada element en la taula ordenada. Si parlem de anviar la posi ió dels elements de la taula,parlem, en un sentit més matemàti , de permuta ions d'elements. Per exemple, si tenim elstres enters 1, 2 i 3, tenim les següents permuta ions possibles:1 2 31 3 22 1 32 3 13 1 23 2 1Noteu que només la primera permuta ió de l'exemple té un ordre as endent dels tres enters.De fet, quan es dóna que tots els valors de la taula són diferents, només hi ha una permuta iódels valors de la taula que tingui la propietat d'estar ordenada as endentment. Si la taulaoriginal té alguns elements iguals, hi hauran tantes permuta ions om elements iguals.Podríem entendre l'ordena ió om la er a d'una permuta ió de valors de la taula t tal quees ompleix que per tot p, q, 1 ≤ p < q ≤ n, es ompleix t[p] ≤ t[q]. Noteu que aquesta ideaens portaria a un algorisme de omplexitat O(N !).Per re�e tir que els valors que hi hagi en t són els mateixos que hi pugui haver en una taula

v però que l'ordre en què estan és diferent, suposarem que tenim una fun ió perm(t, v) queretornarà ert si t és una permuta ió dels valors de v. Amb aquesta fun ió podrem espe i� arl'a ió a dissenyar de forma més òmoda:{t = T}a ió ordenar(entsor t : taulaEnters){perm(t, T ) ∧OrdenatAsc(t)}On perm(t, T ) és ert si t és una permuta ió de T , i OrdenatAsc(t) és ert si per tot p i

q, 1 ≤ p < q ≤ n, es ompleix t[p] ≤ t[q].El mètode que presentarem aquí té divideix la taula en dues se ions ben diferen iades.Una se ió tindrà els seus elements ordenats, i l'altra els elements que al ordenar. Per parlarde se ions de taula utilitzarem la nota ió t[i..f ] que expressa una se ió de la taula que omença a la posi ió i i a aba a la posi ió f . Ambdues posi ions estan in loses en la se ió.5.4.1 Mètode de sele ióDividim la taula en dues se ions. Una se ió mantindrà els elements ordenats i l'altre on-tindrà els elements que al ordenar en la primera se ió. El mètode de sele ió onsisteixen agafar el mínim dels elements de la se ió que al ordenar i afegir-lo al �nal de la se ióordenada.Per exemple,El mínim element en la se ió que al ordenar ésel 4. L'inter anviem amb el primer element de lase ió que al ordenar. i1 2 3 4 515 30 25 4 12︸ ︷︷ ︸

cal ordenar

80 CAPÍTOL 5. CERCA I ORDENACIÓAra tenim una se ió ordenada d'un element, el4. El mínim en la se ió que al ordenar és el12. L'inter anviem amb el primer element de lase ió que al ordenar (30). ordenat︷ ︸︸ ︷ i1 2 3 4 54 30 25 15 12

︸ ︷︷ ︸

cal ordenarRepetim el pro ediment anterior. Noteu que totsels elements de la se ió que al ordenar son mésgrans que els que hi ha a la se ió ordenada. ordenat︷ ︸︸ ︷ i1 2 3 4 54 12 25 15 30

︸ ︷︷ ︸

cal ordenarAquí tenim un as en que el mínim ja està bensituat. S'inter anviarà amb sí mateix. ordenat︷ ︸︸ ︷ i1 2 3 4 54 12 15 25 30

︸ ︷︷ ︸

cal ordenarUn op arribats aquí ens falta un element que alordenar. Però om que aquest és més gran que elsque estan a la se ió ordenada, ja tenim la taulaordenada i no al fer ap pas més. ordenat︷ ︸︸ ︷ i1 2 3 4 54 12 15 25 30

︸ ︷︷ ︸

cal ordenar

En l'exemple observem que només han algut 4 passos per ordenar una taula de in elements, ja que la on lusió presa en el darrer pas no és una asualitat sinó que sempre es omplirà.Anem a repassar les idees exposades, generalitzant en el as general d'una taula t de nenters. La taula estarà dividida en dues se ions mitjançant un índex i om segueix: la se ióordenada, t[1..i − 1], que està entre les posi ions 1 i i − 1 de la taula, i la que al ordenar,t[i..n]. que estarà entre les posi ions i i n.1 . . . i− 1 i . . . n

→ ordenat ← → al ordenar ←A l'ini i tindrem que la se ió ordenada no existeix. Considerem don s, que a l'ini i lase ió ordenada és t[1..0]. Com que l'interval 1..0 no és possible, onsiderem que la se ió ésbuida. Tal om hem vist a l'exemple, es tra ta que a ada pas fem réixer la se ió d'entersordenats t[1..i− 1]: t[1..0], t[1..1], t[1..2], t[1..3], et ; mentre la se ió d'enters que al ordenart[i..n] minva: t[1..n] , t[2..n] , t[3..n] , et .Si tenim t[1..i − 1] amb els enters de�nitivament ordenats i posem el següent enter queseguirà en l'ordre de�nitiu, tindré t[1..i] ordenat. Per tant, si fem i := i + 1, haurà res utt[1..i − 1] i minvat t[i..n].L'esborrany del que hem omentat és:

5.4. ORDENACIÓ 81i := 1; {se ió ordenada és buida (t[1..0])}{se ió que al ordenar és tota la taula (t[1..n])}mentre i ≤ n− 1 ferposa en t[i] l'enter que o uparà la posi ió i de�nitiva quan la taula estigui ordenada;

i := i + 1 {OrdenatAsc(t[1..i− 1])}fmentre{i = n. Per tant t[1..n − 1] està ordenat en les seves posi ions de�nitives. Enla se ió t[n..n] ens queda un enter que al ordenar. Si en t[1..i − 1] ja estantots ben olo ats, t[n] ja està on li to a.}Com ho farem?. Estareu d'a ord en que el primer enter en la taula de�nitiva ordenadaserà l'enter més petit (mínim) que hagi en la taula que al ordenar. El següent que li ha deseguir serà el mínim que hi hagi entre els enters que no han sigut el mínim el primer op.La idea don s, onsistirà en trobar el mínim en la se ió que al ordenar i posar-lo en t[i].Haurem de onservar, però, l'enter que hi ha en t[i] per posar-lo més endavant a la posi ió queli to a. De moment, el que podem fer es posar-lo en el llo on hi havia el mínim. És a dir,fem un inter anvi entre t[i] i la posi ió on hi ha el mínim (min). L'esborrany ara serà:i := 1;mentre i ≤ n− 1 fer er a el mínim de t[i..n] i fes que min sigui l'índex del mínim trobat;inter anvia t[i] i t[min]

i := i + 1fmentrePer trobar el mínim, el que hem de fer és suposar que ho sigui el primer (t[i]) que disposem,i omprovar després amb la resta d'elements de t[i..n] si efe tivament ho és. En as de que noho sigui per algun enter, posem om a nou mínim l'enter que ha tren at la suposi ió.Utilitzarem una variable entera j per re órrer la se ió, i una altra, min, que serà l'índexo posi ió on es troba el mínim de la se ió. Ini ialment suposarem que el mínim es troba enla posi ió i, i per tant ho haurem de omprovar des de la posi ió i + 1 �ns a n.Per tant,. . .j := i + 1min := imentre j ≤ n fersi t[j] < t[min] → min := j⊓⊔ t[j] ≥ t[min] →fsij := j + 1fmentre

x := t[i]; t[i] := t[min]; t[min] := x;. . .Noteu que també podríem haver posatsi t[j] ≤ t[min] → min := j⊓⊔ t[j] > t[min] →fsi

82 CAPÍTOL 5. CERCA I ORDENACIÓque en el as de que en la se ió tingui mínims iguals es quedaria amb el darrer trobat; és adir, el que té la posi ió més elevada. En anvi, en la solu ió que hem proposat, es quedariaamb el primer que ha trobat, a onseguint així, que els elements iguals mantinguin l'ordreque tenien originalment en la taula. Aquest detall pot ser irrellevant pel nostre as, però,per l'ordena ió d'altres elements, om tuples sota el riteri d'algun dels seus amps, pot serinteressant mantenir l'ordre original, si aquest per exemple ve donat sota el riteri d'un altre amp. Als algorismes d'ordena ió que mantenen l'ordre original dels elements iguals s'elsanomena estables.Un op tenim que min apunta al valor mínim al fer l'inter anvi per que estigui en t[i](utilitzarem una variable auxiliar x per portar a terme l'inter anvi):. . .x := t[i]; t[i] := t[min]; t[min] := x;. . .La solu ió ompleta és:1 a ió ordena(entsor t : taulaEnters);2 var i, j, x.min : enter; fvar3 i := 1;4 mentre i ≤ N − 1 fer5 min := i;6 j := i + 1;7 mentre j ≤ N fer8 si t[j] < t[min] → min := j9 ⊓⊔ t[j] ≥ t[min] →10 fsi;11 j := j + 112 fmentre13 x := t[i]; t[i] := t[min]; t[min] := x;14 i := i + 115 fmentre16 fa ióAnàlisi de la omplexitatLa mida de les dades és N . Tenim que

tordenaSel(N) = t3(N) + t4−15(N) ∈ O(max{t3(N), t4−15(N)})Tenim que O(t3(N)) ∈ O(1) ja que es tra ta d'una assigna ió amb una expressió d'una onstant. Amb això, per la regla de les sumes i per re�e tivitat, tenimtordenaSel(N) ∈ O(t4−15(N))Per avaluar el mentre de la línia 4 podem observar que el ost del seu os depèn de quinpas de la itera ió (i) ens trobem. Per tant hem d'apli ar el ost del mentre mitjançant unsumatori.

t4−15(N) =N−1∑

i=1

(te4(N) + t5−6(N) + t7−12(N, i) + t13−14(N)) + te4(N)

5.5. BIBLIOGRAFIA RELACIONADA 83Tenim que te4(N) és una onstant, ja que l'expressió usa un operador rela ional i unaresta. El ost en temps de t5−6(N) és el resultat d'apli ar el ost d'una omposi ió seqüen ialde dues assigna ions amb expressions que s'avaluen a un ost en temps onstant. El ost entemps de t13−14 també és onstant ja que es basa en la omposi ió de quatre assigna ions que ontenen expressions que s'avaluen en temps onstant (operadors d'a és [], i una suma en unade les assigna ions). Fent A = te4(N) ∈ O(1) i B = t5−6(N) + t13−14(N) ∈ O(1), rees rivimla darrera equa ió om:t4−15(N) = N · A + (N − 1) · B +

N−1∑

i=1

(t7−12(N))El ost del mentre de la línia 7 és:t7−12(N, i) = (N − i) · (te7(N) + t8−11(N)) + te7(N)El ost en temps de l'alternativa t8−10 pertany a O(max{te8, te9, ta8, ta9}) i és O(1), jaque les expressions te8, te9 s'avaluen a temps onstant, ta8 és una assigna ió, i ta9 és buida.El ost en temps de t11 és el d'una assigna ió i una suma i per tant és onstant. Fent

C = te7(N) + t8−11(N), i D = te7(N), tindremt4−15(N) = N ·A + (N − 1) ·B +

N−1∑

i=1

((N − i) · C + D)

= N ·A + (N − 1) · (B + D) + C ·N · (N − 1)− C ·N−1∑

i=1

i

∈ O(N2)degut a que ∑ni=1 i = (n+1)·n

2 . Per tant,tordenaSel(N) ∈ O(N2)Podem observar les següents ara terístiques del mètode exposat:

• És un mètode d'ordena ió estable (valors iguals en la permuta ió ini ial es posen en elmateix ordre).• El mètode no té un omportament natural (si la taula ini ial està gairebé ordenadal'esforç de l'algorisme és el mateix que per qualsevol altra permuta ió d'elements).• Si hom vol saber només els m (m < n) primers elements ordenats només al fer mitera ions. La se ió ordenada onté sempre els elements en les seves posi ions de�nitives.5.5 Bibliogra�a rela ionadaUn estudi més detallat sobre el tema d'ordena ió el trobareu a [11℄

84 CAPÍTOL 5. CERCA I ORDENACIÓ

Capítol 6Introdu ió a les estru tures de dades6.1 Introdu ióCom s'ha vist a l'apartat 1.2, en la metodologia del disseny desdendent d'algoritmes s'apli al'abstra ió fun ional: es van espe i� ant subprogrames que s'implementen en un nivell poste-rior. De totes maneres, la segmenta ió dels programes no és arbitrària, sinó que, de fet, esbasa en la forma de treballar amb els obje tes que intervenen en el problema.L'apli a ió del on epte d'abstra ió a les dades (obje tes) va desenvolupar-se després del'abstra ió fun ional i ha seguit els següents passos:1. In lusió de tipus de dades elementals en els llenguatges d'alt nivell. Podem treballaramb el tipus enter, per exemple, operant elements d'aquest tipus i fent abstra ió de laforma om estan representats ( om un onjunt de bits).2. Crea ió de tipus de dades per enumera ió que permeten de�nir explí itament el dominide valors dels tipus.3. Crea ió de tipus estru turats, introduïnt la idea de generi itat: taules i tuples. Elllenguatge propor iona opera ions per manipular aquests nous tipus, om també l'a ésals seus omponents.Totes aquestes in orpora ions són en ara insu� ients i, en el moment de dissenyar apli- a ions d'una erta dimensió, al que el dissenyador pugui rear nous tipus o estru tures dedades.Una estru tura de dades és una ol.le ió de valors i opera ions sobre aquests valors.Les opera ions es de�neixen mitjançant una espe i� a ió que és independent de qualsevolrepresenta ió del onjunt de valors.En la rea ió d'un nova estru tura de dades hi intervenen dos pro essos: l'espe i� a iói la implementa ió.L'espe i� a ió d'una estru tura de dades indi a QUÈ es pot fer amb aquella estru tu-ra de dades i onsisteix en l'espe i� a ió de totes les a ions i fun ions orresponents a lesopera ions sobre l'estru tura, és a dir, la apçalera i l'espe i� a ió, amb la pre ondi ió i lapost ondi ió, de totes les a ions i fun ions.La implementa ió d'una estru tura de dades indi a COM es representa aquella novaestru tura fent ús dels tipus de dades de què es disposa en el llenguatge amb què es treballa iCOM s'implementen totes les a ions i fun ions orresponents a les opera ions.85

86 CAPÍTOL 6. INTRODUCCIÓ A LES ESTRUCTURES DE DADESAquest on epte d'abstra ió en les dades exigeix que tant la representa ió on reta del'estru tura om la forma om fa les opera ions (la implementa ió) siguin ina essibles a laresta del programa. Des de la resta del programa, només se'n oneixerà el nom del noutipus de dades, per tal de poder de larar variables d'aquest tipus, i l'espe i� a ió de les sevesopera ions, per tal que puguin ser ridades des d'aquest programa.Un op espe i� at un nou tipus de dades, es pot desenvolupar l'apli a ió que l'usa sense quehagi estat prèviament implementat. D'altra banda, les implementa ions poden variar: es potfer una primera implementa ió més simple però menys e� ent si es disposa de po temps pera una primera versió de l'apli a ió i, més endavant, es poden estudiar altres implementa ionsmés e� ients. L'avantatge d'haver usat aquesta metodologia de treball és que tota l'apli a ió ototes les apli a ions que usen aquest nou tipus de dades són independents de les seves possiblesimplementa ions: els anvis en les implementa ions del nou tipus no afe ten el disseny de lesapli a ions que l'usen.D'altres avantatges de l'ús metòdi de les estru tures de dades són la robustesa del odi(i per tant, la �abilitat dels nostres programes) i la possibilitat de reutilitzar una estru turade dades sense haver-la de tornar a dissenyar ni implementar (i per tant, guanyem rapidesa i�exibilitat en el disseny algorísmi ).Com ja s'ha esmentat en el apítol 2, les opera ions que de�neixen un nou tipus de dadeses poden lassi� ar en dos sub onjunts:• Opera ions onstru tores: són les que permeten modi� ar les variables del nou tipus.Normalment hi ha una opera ió d'ini ialitza ió o rea ió i una o més opera ions d'in-trodu ió o modi� a ió de la informa ió. En algunes implementa ions també hi haopera ions destru tores, que om que modi�quen el ontingut de les variables, tambés'in louen dins d'aquest sub onjunt. Aquestes opera ions es ara teritzen perquè o bésón fun ions que retornen una variable d'aquest tipus o bé són a ions que tenen unparàmetre de sortida del tipus nou.• Opera ions observadores o de onsulta. Aquestes opera ions no modi�quen les variablesdel nou tipus sino que només n'extreuen informa ió. Es ara teritzen perquè o bé sóna ions o bé fun ions que tenen un paràmetre d'entrada del tipus que estem de�nint.Existeixen llenguatges de programa ió que fa iliten la rea ió de nous tipus de dades: Ada(pa kage), Mòdula 2 (mòdul) i C++ ( lasse). De totes maneres, aquesta fa ilitat a vegadeses pot traduir en algunes restri ions per a qui desenvolupa els programes. Els llenguatgesque no aporten aquestes fa ilitats, om el C, també permeten dissenyar programes seguintaquestes idees, sempre que es segueixi una bona dis iplina d'ús.En aquest apítol es veuran espe i� a ions dels tipus Ve tor, Matriu i Taula de Freqüèn iesamb diferents implementa ions per adas un d'ells.A l'apartat 7.4 es veuran altres implementa ions dels tipus Ve tor i Matriu que fan ús dememòria dinàmi a i apuntadors.6.1.1 Espe i� a ió del tipus Ve tortipus Ve tor ftipus

6.1. INTRODUCCIÓ 87skip{Pre : n > 0}fun ió CrearVe tor(ent n : enter) retorna Ve tor{Post: CrearVe tor(n) és un ve tor amb interval [0..n − 1]}{Pre : ert}fun ió DimVe tor(ent v : Ve tor) retorna enter{Post: DimVe tor(v) és la dimensió del ve tor v}{Pre : 0 ≤ i < DimVe tor(v)}a ió AssigVe tor(entsor v : Ve tor , ent i : enter, ent r : real){Post: vi = r ∧ la resta dels omponents no s'han modi� at}{Pre : 0 ≤ i < DimVe tor(v)}fun ió ConsVe tor(ent v : Ve tor , ent i : enter) retorna real{Post: ConsVe tor(v, i) = vi}En aquesta espe i� a ió hi ha dues opera ions onstru tores: CrearVe tor, que permetini ialitzar una variable de tipus Ve tor, i AssigVe tor, que permet assignar un nou valor a un omponent del ve tor. També hi ha dues opera ions observadores o de onsulta: DimVe tor,que indi a la longitud a tual del ve tor, i ConsVe tor, que permet onsultar el valor d'un omponent del ve tor. Notem que l'opera ió CrearVe tor és aquella que �xa la dimensió delve tor, i per tant des del moment que hagi estat reat la seva dimensió quedarà �xada. 16.1.2 Implementa ió V1: ve tor estàti amb dimensió variableAquesta implementa ió és la més habitual. El ve tor es representa mitjançant una tupla onhi ha dos amps: l'un és una taula dimensionada a un valor màxim (longitud de larada) queindi a el nombre màxim d'elements que podrà tenir el tipus, i l'altre orrespon al nombred'elements que té el ve tor en una apli a ió determinada (longitud a tual). onst MaxDim : enter = 500 f onsttipus

V ector = tuplatelem : TauRealnelem : enter {1 ≤ nelem ≤MaxDim}ftupla

TauReal = taula [0 . .MaxDim-1] de realftipusskipfun ió CrearV ector(ent n : enter) retorna V ectorvar v : V ector fvarv.nelem := nretorna v�un ióskipfun ió DimV ector(ent v : V ector) retorna enterretorna v.nelem1Una espe i� a ió alternativa del tipus Ve tor podria admetre opera ions que en variessin la seva dimensió,la qual osa requeriria que la implementa ió ontemplés ve tors totalment dinàmi s.

88 CAPÍTOL 6. INTRODUCCIÓ A LES ESTRUCTURES DE DADES�un ióskipfun ió ConsV ector(ent v : V ector, ent i : enter) retorna realvar r : real fvarr := v.telem[i]retorna r�un ióskipa ió AssigV ector(entsor v : V ector, ent i : enter, ent r : real)v.telem[i] := rfa ió6.2 Matrius. Espe i� a ió i implementa ió6.2.1 Espe i� a ió del tipus Matriutipus Matriu ftipus{Pre : nf > 0 ∧ nc > 0}fun ió CrearMatriu(ent nf, nc : enter) retorna Matriu{Post: CrearMatriu(nf, nc) és una matriu amb interval [0..nf − 1, 0..nc − 1]}{Pre : cert}fun ió FilesMatriu(ent m : Matriu) retorna enter{Post: FilesMatriu(m) és el nombre de �les de la matriu m}{Pre : cert}fun ió ColsMatriu(ent m : Matriu) retorna enter{Post: ColsMatriu(m) és el nombre de olumnes de la matriu m}{Pre : 0 ≤ i < FilesMatriu(m) ∧ 0 ≤ j < ColsMatriu(m)}a ió AssigMatriu(entsor m : Matriu, ent i, j : enter, ent r : real){Post: mi,j = r ∧ la resta dels omponents no s'han modi� at}{Pre : 0 ≤ i < FilesMatriu(m) ∧ 0 ≤ j < ColsMatriu(m)}fun ió ConsMatriu(ent m : Matriu, ent i, j : enter) retorna real{Post: ConsMatriu(m, i, j) = mi,j}En aquesta espe i� a ió hi ha dues opera ions onstru tores: CrearMatriu, que permetini ialitzar una variable de tipus Matriu, i AssigMatriu, que permet assignar un nou valor aun omponent de la matriu. Hi ha tres opera ions observadores o de onsulta: FilesMatriui ColsMatriu, que indiquen el nombre de �les i olumnes a tual de la matriu, i ConsMatriu,que permet onsultar el valor d'un omponent de la matriu.6.2.2 Exemple d'ús d'aquesta espe i� a ióEnun iatDissenyeu un subprograma que multipliqui dues matrius usant les opera ions indi ades.Resolu ióEspe i� a ió del subprograma:

6.2. MATRIUS. ESPECIFICACIÓ I IMPLEMENTACIÓ 89{Pre : FilesMatriu(A) = n ∧ ColsMatriu(A) = m ∧ FilesMatriu(B) = m

∧ ColsMatriu(B) = p}fun ió ProducteMatrius(ent A,B : Matriu) retorna Matriu{Post: C = ProducteMatrius(A,B) ∧ C = A×B ∧ FilesMatriu(C) = n

∧ ColsMatriu(C) = p}Implementa ió del subprograma:fun ió ProducteMatrius(ent A,B : Matriu) retorna MatriuvarC : Matriun,m, p, i, k, j : enterelement : realfvar

n := FilesMatriu(A)m := ColsMatriu(A)p := ColsMatriu(B)C := CrearMatriu(n, p)i := 0mentre ¬(i ≥ n) fer

j := 0mentre ¬(j ≥ p) ferelement := 0.0k := 0mentre ¬(k ≥ m) fer

element := element + ConsMatriu(A, i, k) ∗ ConsMatriu(B, k, j)k := k + 1fmentre

AssigMatriu(C, i, j, element)j := j + 1fmentre

i := i + 1fmentreretorna (C)�un ió6.2.3 Implementa ió M1: matriu estàti a amb dimensió variableUna primera implementa ió del tipus Matriu és la implementa ió més habitual d'una matriu,matriu estàti a amb dimensió variable, que es mostra tot seguit. Vegeu la �gura 6.1 a). onstN : enter = 30M : enter = 40f onst

90 CAPÍTOL 6. INTRODUCCIÓ A LES ESTRUCTURES DE DADES

N

M

a)

ncols=3nfiles=2

ncols=6

nfiles=4

b)

N

Figura 6.1: a) Implementa ió del tipus Matriu M1. b) Variant que usa una taula unidimensi-onal.tipusMatriu = tupla

melem : MatRealnfiles, ncols : enter {1 ≤ nfiles ≤ N ∧ 1 ≤ ncols ≤M}ftupla

MatReal = taula [0 . .N-1, 0 . .M-1] de realftipusfun ió CrearMatriu(ent nf, nc : enter) retorna Matriuvar m : Matriu fvarm.nfiles := nf ; m.ncols := ncretorna m�un iófun ió FilesMatriu(ent m : Matriu) retorna enterretorna m.nfiles�un iófun ió ColsMatriu(ent m : Matriu) retorna enterretorna m.ncols�un iófun ió ConsMatriu(ent m : Matriu, ent i, j : enter) retorna realvar r : real fvarr := m.melem[i, j]retorna r�un ióa ió AssigMatriu(entsor m : Matriu, ent i, j : enter, ent r : real)m.melem[i, j] := rfa ióUna altra possible implementa ió del tipus Matriu estàti a i amb dimensió variable seriala següent: en llo de guardar els valors de la matriu en una taula bidimensional, guardar-los

6.3. MATRIUS DISPERSES 91en una taula unidimensional. Vegeu la �gura 6.1 b).La posi ió d'un element a la taula unidimensional es al ula en fun ió de la �la i olumna orresponent i del nombre de olumnes: i ∗ ncols + j ( onsiderant que els elements estanordenats per �les). onst N : enter = 500 f onsttipusMatriu = tupla

telem : TauRealnfiles, ncols : enter {1 ≤ nfiles ∗ ncols ≤ N}ftupla

TauReal = taula [0 . .N-1]ftipusLa implementa ió de les a ions i fun ions en aquesta versió és similar a la de la versióanterior. Tan sols varien l'a ió AssigMatriu i la fun ió ConsMatriu.a ió AssigMatriu(entsor m : Matriu, ent i, j : enter, ent r : real)var k : enter fvark := i ∗ ColsMatriu(m) + jm.telem[k] := rfa iófun ió ConsMatriu(ent m : Matriu, ent i, j : enter) retorna realvar

k : enterr : realfvar

k := i ∗ ColsMatriu(m) + jr := m.telem[k]retorna r�un ióNOTA: Si la matriu s'hagués espe i� at amb l'interval [1..nf ][1..nc] l'expressió per al- ular la posi ió de l'element seria: k := (i− 1) ∗ ColsMatriu(m) + (j − 1).6.3 Matrius dispersesEs de�neix om una matriu dispersa o quasinul.la una matriu que té un elevat per entatged'elements que són nuls (zero). Aquestes matrius a ostumen a ser matrius de sistemes d'e-qua ions de dimensió elevada. Les implementa ions expli ades a la se ió 6.2 són po e� ientsper aquests tipus de matrius. Per això s'usen estru tures de dades adequades que es basen aguardar només els elements de la matriu que són diferents de zero.A ontinua ió es mostren dues implementa ions possibles per a matrius disperses.6.3.1 Implementa ió M2: matriu estàti a amb dimensió variable dispersa• Representarem el tipusMatriu om una taula de parells (índex,valor) ordenada pel ampíndex. Només es guarden els parells en què valor 6= 0.

92 CAPÍTOL 6. INTRODUCCIÓ A LES ESTRUCTURES DE DADES• El amp índex es al ula om i ∗ ncols + j, és a dir, emmagatzemem els elements nonuls de la matriu per �les. Aquest riteri és similar al vist a la segona implementa ió del'apartat 6.2.3, només que ara sols es guarden els elements no nuls. onst

MAX : enter = 100 {Maxim nombre d'elements no nuls}f onsttipusMatriu = tupla

t : TauIVnf, nc : enter {nf, n : nombre de �les i olumnes}n : enter {n: nombre d'elements no nuls}ftupla

TauIV = taula [0 . .MAX-1] de IVIV = tupla

index : entervalor : realftuplaftipusfun ió CrearMatriu(ent nf, nc : enter) retorna Matriuvar m : Matriu fvar

m.nf := nfm.nc := ncm.n := 0retorna m�un iófun ió FilesMatriu(ent nf : enter) retorna enterretorna m.nf�un iófun ió ColsMatriu(ent nc : enter) retorna enterretorna m.nc�un iófun ió ConsMatriu(ent m : Matriu, ent i, j : enter) retorna realvar

pos, index : enter;r : real

6.3. MATRIUS DISPERSES 93trobat : booleàfvar

CercaM(m, i, j, trobat, pos)si trobat → r := m.t[pos].valor⊓⊔ ¬trobat → r := 0.0fsiretorna r�un ióa ió AssigMatriu(entsor m : Matriu, ent i, j : enter, ent r : real)var

pos : entertrobat : booleàfvar

CercaM(m, i, j, trobat, pos)si r = 0.0 → si trobat → EsborraM(m, pos)⊓⊔ ¬trobat →fsi

⊓⊔ r 6= 0.0 → si trobat → m.t[pos].valor := r⊓⊔ ¬trobat → InsereixM(m, pos, i, j, r)fsifsifa ióAra dissenyarem els subprogrames del 2n nivell de l'anàlisi des endent del tipus Matriu:les a ions Cer aM i InsereixM. Aquestes dues a ions s'han de dissenyar tenint en ompteuna propietat que ha de ser invariant: que la taula estigui ordenada pel amp índex. Laimplementa ió de l'a ió EsborraM es deixa om exer i i.El subprograma de er a bus arà el valor. Si el troba, indi arà la posi ió on és i, si no eltroba, indi arà la posi ió on hauria d'anar.

{Pre : m és una matriu ordenada pel amp índex in és el nombre d'elements diferents de 0 de m}a ió CercaM(ent m : Matriu, ent i, j : enter, sor trobat : booleà, sor pos : enter)

{Post: (trobat ≡ ∃pos : 0 ≤ pos < n : indexpos = i ∗ ColsMatriu(m) + j) ∧(¬trobat ≡ ∀k : 0 ≤ k < pos : indexk < i ∗ ColsMatriu(m) + j)∧ ∀k : pos ≤ k < n : indexk > i ∗ ColsMatriu(m) + j}a ió CercaM(ent m : Matriu, ent i, j : enter, sor trobat : booleà, sor pos : enter)var

index : enterfvar

94 CAPÍTOL 6. INTRODUCCIÓ A LES ESTRUCTURES DE DADESpos := 0trobat := falsindex := i ∗m.nc + jmentre pos < m.n ∧ ¬trobat fersi m.t[pos].index ≥ index → trobat := ert⊓⊔ m.t[pos].index < index → pos := pos + 1fsifmentresi trobat → si m.t[pos].index > index → trobat := fals

⊓⊔ m.t[pos].index = index →fsi⊓⊔ ¬trobat →fsifa ióAquesta a ió s'ha implementat seguint l'esquema d'una er a seqüen ial en un onjuntordenat. Es deixa om a exer i i, la implementa ió seguint l'esquema d'una er a binària.L'a ió InsereixM en el as que sigui una inser ió al mig o a l'ini i, ha de fer un despla-çament ap enrere de tots els elements que van darrere del que volem inserir. Vegeu la �gura6.2. Si la inser ió és al �nal, no aldrà fer el desplaçament.

1 2 k n

1 2 n n+1element nouFigura 6.2: Inser ió d'un element al mig.

{Pre : m = M és una matriu ordenada pel amp índex in és el nombre d'elements diferents de 0 de m}a ió InsereixM(entsor m : Matriu, ent pos, i, j : enter, ent r : real)

{Post: m = M amb tots els elements a partir de pos desplaçats una posi ió ap enrere ∧el nombre d'elements diferents de 0 de m és n + 1 ∧ valorpos = r∧ indexpos = i ∗ ColsMatriu(m) + j}a ió InsereixM(entsor m : Matriu, ent pos, i, j : enter, ent r : real)var k : enter fvarsi pos < m.n →

k := m.nmentre ¬(k ≤ pos) ferm.t[k] := m.t[k − 1]k := k − 1

6.3. MATRIUS DISPERSES 95fmentre⊓⊔ pos = m.n →fsim.t[pos].index := i ∗m.nc + jm.t[pos].valor := rm.n := m.n + 1fa ióLa implementa ió de l'a ió EsborraM també ha de tenir en ompte si al fer un despla-çament o no. Si s'esborra el darrer element, no al fer ap desplaçament, mentre que si sen'esborra algun altre, al fer un desplaçament ap enrere de tots els elements que es trobenmés enllà de l'element que s'esborra. D'aquesta a ió només se'n dóna l'espe i� a ió, la sevaimplementa ió es deixa om a exer i i.{Pre : m = M és una matriu ordenada pel amp índex ∧

n és el nombre d'elements diferents de 0 de m ∧ 1 ≤ pos ≤ n}a ió EsborraM(entsor m : Matriu.ent pos : enter){Post: m = M amb n− 1 elements diferents de 0, sense l'element de la posi ió pos}Exer i i. A abem de presentar una implementa ió de les matrius disperses obligant a quèla taula de de parells (índex, valor) estigui permanentment ordenada pel amp índex. No obs-tant, també és possible implementar-ho sense fer aquesta suposi ió, és a dir, emmagatzemantels valors a la taula sense ap ordre prestablert. Penseu om aldria implementar adas unade les opera ions sobre el tipus en aquest segon as. Analitzeu la omplexitat assimptòti a de adas una de les opera ions en els dos asos tot omparant les dues alternatives.Una altra variant d'aquesta implementa ió del tipusMatriu dispersa és la que es presen-ta a ontinua ió. El tipus Matriu es representarà om una taula de tuples de tres amps(fila, col, valor) ordenada pel amp fila i dins d'aquest pel amp col. Només es guarden lestuples en què valor 6= 0. Els amps fila i col indiquen la �la i la olumna, respe tivament, orresponents a l'element.

96 CAPÍTOL 6. INTRODUCCIÓ A LES ESTRUCTURES DE DADEStipusMatriu = tupla

t : TauFCVnf, nc : enter nf, n : nombre de �les i olumnesn : enter n: nombre d'elements no nulsftupla

TauFCV = taula [0 . .MAX-1] de FCVFCV = tupla

fila : entercol : entervalor : realftuplaftipusLa implementa ió de les opera ions es deixa om a exer i i.6.3.2 Considera ionsCom que l'espe i� a ió és independent de la implementa ió, per multipli ar dues matriusdisperses podríem usar el subprograma vist a l'apartat 6.2.2, fent servir la implementa ió deltipus matriu M2 vista. I això mateix passa amb altres algorismes que usin el tipus Matriu om la suma de matrius, el produ te d'una matriu per un es alar, et .Alguns d'aquests algorismes poden resultar més e� ients si en llo de dissenyar-se usantl'espe i� a ió del tipus matriu vista, es onsideren om una opera ió més del tipus matriu is'implementen om a tals. A ontinua ió se'n mostra un exemple. L'algorisme de suma dematrius es dissenyarà de dues maneres.Suma de matrius. Versió 1Enun iatDissenyeu un subprograma que sumi dues matrius usant les opera ions de l'espe i� a iódel tipus matriu donades.Resolu ióEspe i� a ió del subprograma:

{Pre : FilesMatriu(a) = n ∧ ColsMatriu(a) = m ∧ FilesMatriu(b) = n∧ ColsMatriu(b) = m}fun ió SumaMatrius(ent a, b : Matriu) retorna Matriu

{Post: c = SumaMatrius(a, b) ∧ c = a + b ∧ FilesMatriu(c) = n∧ ColsMatriu(c) = m}

6.3. MATRIUS DISPERSES 97Implementa ió del subprograma:fun ió SumaMatrius(ent a, b : Matriu) retorna Matriuvarc : Matriun,m, i, j : enterelement : realfvar

n := FilesMatriu(a)m := ColsMatriu(a)c := CrearMatriu(n,m)i := 0mentre ¬(i ≥ n) fer

j := 0mentre ¬(j ≥ m) ferelement := ConsMatriu(a, i, j) + ConsMatriu(b, i, j)AssigMatriu(c, i, j, element)j := j + 1fmentre

i := i + 1fmentreretorna (c)�un ióL'avantatge d'aquesta implementa ió és que és independent de la implementa ió del tipusMatriu. És apli able a matrius normals, o disperses, o a altres possibles implementa ions, om les que usen memòria dinàmi a i apuntadors, que es veuran al apítol orresponent, al'apartat 7.4.Suma de matrius. Versió 2Enun iatDissenyeu un subprograma que sumi dues matrius onsiderant que és una nova opera iódel tipus Matriu i usant la implementa ió M2 vista a l'apartat 6.3.1.Resolu ióL'espe i� a ió és la mateixa. Ara bé, la implementa ió farà ús de la forma espe í� a omestà representada la matriu i l'estratègia que se seguirà serà similar al pro és de fusió vist al'apartat 3.6.2. Es fa un re orregut en paral.lel de les dues taules que ontenen les matriusini ials i, segons om siguin els índexs respe tius, es posa a la matriu resultat o bé l'elementde la matriu a, o bé l'element de la matriu b, o bé la suma de tots dos.fun ió SumaMatriu(ent a, b : Matriu) retorna Matriuvarpa, pb, ps : enters : Matriufvar

98 CAPÍTOL 6. INTRODUCCIÓ A LES ESTRUCTURES DE DADESs.nf := a.nfs.nc := a.ncpa := 0pb := 0ps := 0mentre pa < a.n ∧ pb < b.n fersi a.t[pa].index < b.t[pb].index →

s.t[ps] := a.t[pa]ps := ps + 1pa := pa + 1

⊓⊔ a.t[pa].index = b.t[pb].index →valor := a.t[pa].valor + b.t[pb].valorsi valor 6= 0.0 →

s.t[ps].index := a.t[pa].indexs.t[ps].valor := valorps := ps + 1

⊓⊔ valor = 0.0 →fsipa := pa + 1pb := pb + 1

⊓⊔ a.t[pa].index > b.t[pb].index →s.t[ps] := b.t[pb]ps := ps + 1pb := pb + 1fsifmentrementre pa < a.n fer

s.t[ps] := a.t[pa]ps := ps + 1pa := pa + 1fmentrementre pb < b.n fers.t[ps] := b.t[pb]ps := ps + 1pb := pb + 1fmentre

s.n := psretorna s�un ióAquesta implementa ió només és apli able per a la de�ni ió de tipus orresponent a laimplementa ió M2 i, en què és molt e� ient.6.4 Taula de freqüèn iesUna taula de freqüèn ies és una estru tura d'ús molt freqüent en apli a ions informàtiques.Una taula de freqüèn ies permet tra tar el nombre d'apari ions de determinats elements en un

6.4. TAULA DE FREQÜÈNCIES 99 onjunt ini ial d'elements i manté un onjunt de parells (element, freqüèn ia), un per a adaelement diferent. En aquest apartat es veurà l'espe i� a ió d'aquesta estru tura i algunesimplementa ions i alguns algorismes que la fa in servir.6.4.1 Espe i� a ió d'una taula de freqüèn iestipus TauFreq ftipus{Pre : cert}a ió Inicialitzar(sor t : TauFreq){Post: t és una taula de freqüèn ies buida}{Pre : Freq(t, x) = f}a ió Afegir(entsor t : TauFreq, ent x : Element){Post: Freq(t, x) = f + 1}{Pre : cert}fun ió Freq(ent t : TauFreq, ent x : Element) retorna enter{Post: ∃i : (elementi, frequenciai) ∈ t ∧ x = elementi

∧ Freq(t, x) = frequenciaiFreq(t, x) = 0}En aquesta espe i� a ió hi ha dues opera ions onstru tores: Ini ialitzar, que permetini ialitzar una taula, i Afegir, que permet afegir un nou element a la taula. A mé hi ha unaopera ió observadora o de onsulta: Freq, que permet onsultar la freqüèn ia d'un elementdonat.6.4.2 Exemple d'ús d'aquesta espe i� a ióA ontinua ió es resol el problema 6.1 de [10℄.Enun iatDonada una seqüèn ia de arà ters a abada amb el arà ter '.' que arriba pel CSE,dissenyeu un algorisme que es rigui pel CSS una taula amb la freqüèn ia d'apari ió de adauna de les vo als.Resolu ióResoldrem aquest problema usant l'espe i� a ió per a una taula de freqüèn ies de l'apartatanterior.Espe i� a ió de l'algorisme:{Pre : CSE = c1c2 . . . .}algorisme FreqV ocals{Post: CSS = af1ef2 . . . uf5 ∧

∀i : 1 ≤ i ≤ 5 : fi és el nombre de vegades que la vo al apareix en el text}Implementa ió de l'algorisme:tipus TauFreq ftipusalgorisme FreqV ocalsvar

100 CAPÍTOL 6. INTRODUCCIÓ A LES ESTRUCTURES DE DADESt : TauFreqc : arà terfvar

Inicialitzar(t)LlegirCaracter(c)mentre c 6= `.' fersi V ocal(c) → Afegir(t, c)⊓⊔ ¬V ocal(c) →fsiLlegirCaracter(c)fmentre

EscriureEnter(Freq(t, `a'))EscriureEnter(Freq(t, `e'))EscriureEnter(Freq(t, `i'))EscriureEnter(Freq(t, `o'))EscriureEnter(Freq(t, `u'))falgorisme6.4.3 Implementa ió TF1: taula estàti a de freqüèn ies de dimensió �xaEn aquest apartat es presenta una implementa ió ad ho per a una taula de vo als. El tipusElement serà el tipus ara ter amb la restri ió que només pot ser lletra vo al. La longitudde larada i l'a tual de la taula oin idiran i valen 5. I els parells quedaran reduïts a un sol amp(el amp orresponent a la freqüèn ia). El amp orresponent a l'element serà representat perl'índex de la taula: es farà una orrespondèn ia entre els in primers enters (l'índex de lataula) i les in vo als.Les pre ondi ions de les a ions Afegir i Freq s'haurien de reforçar de manera que elparàmetre x fos realment del tipus dels elements que es tra ten, és a dir, en aquest as lapre ondi ió s'ha d'ampliar imposant que x sigui una vo al.{Pre : Freq(t, c) = f ∧ c és una vo al}a ió Afegir(entsor t : TauFreq, ent c : arà ter){Post: Freq(t, c) = f + 1}{Pre : }fun ió Freq(ent t : TauFreq, ent x : arà ter) retorna enter{Post: ∃i : (vocali, frequenciai) ∈ t ∧ x = vocali

∧ Freq(t, x) = frequenciaiFreq(t, x) = 0}A ontinua ió es mostra la implementa ió:tipusTauFreq : taula [1..5] de enterftipusa ió Inicialitzar(sor t : TauFreq)var i : enter fvari := 1mentre ¬(i > 5) fer

t[i] := 0

6.4. TAULA DE FREQÜÈNCIES 101i := i + 1fmentrefa ióa ió Afegir(entsor t : TauFreq, ent c : arà ter)var i : enter fvar

i := V ocalIndex(c)t[i] := t[i] + 1fa iófun ió Freq(ent t : TauFreq, ent c : arà ter) retorna entervar i : enter fvari := V ocalIndex(c)retorna t[i]�un ióNOTA: En aquesta implementa ió la freqüèn ia d'algun element pot ser 0, i a l'estru turasempre hi ha els in possibles elements (vo als).A ontinua ió s'espe i�quen i implementen els subprogrames que han quedat indi ats.Aquesta implementa ió onstitueix el ter er nivell de l'anàlisi des endent en la resolu ió delproblema 6.1, i també està orientada a un tipus d'obje te: vo als.Per simpli� ar onsiderem que les vo als que apareixen en el text són només minús ulesi sense ap tipus d'a ent. Es deixa om a exer i i dissenyar els mateixos subprogrames onsiderant majús ules i vo als a entuades.Espe i� a ió:{Pre : }fun ió V ocal(ent : c : arà ter) retorna booleà{Post: V ocal(c) = ert⇔ és una vo al}{Pre : V ocal(c)}fun ió V ocalIndex(ent c : arà ter) retorna enter{Post: V ocalIndex(c) = l'enter orresponent a la vo al c}{Pre : 1 ≤ i ≤ 5}fun ió IndexV ocal(ent i : enter) retorna arà ter{Post: IndexV ocal(i) = la vo al orresponent a l'enter i}Implementa ió:fun ió V ocal(ent : c : arà ter) retorna booleàretorna c = `a'c = `e'c = `i'c = `o'c = `u'�un iófun ió V ocalIndex(ent c : arà ter) retorna entervar i : enter fvarsi c = `a' → i := 1⊓⊔ c = `e' → i := 2⊓⊔ c = `i' → i := 3⊓⊔ c = `o' → i := 4⊓⊔ c = `u' → i := 5fsiretorna i�un ió

102 CAPÍTOL 6. INTRODUCCIÓ A LES ESTRUCTURES DE DADESfun ió IndexV ocal(ent i : enter) retorna arà tervar c : arà ter fvarsi i = 1 → c := `a'⊓⊔ i = 2 → c := `e'⊓⊔ i = 3 → c := `i'⊓⊔ i = 4 → c := `o'⊓⊔ i = 5 → c := `u'fsiretorna c�un ió6.4.4 Implementa ió TF2: taula estàti a de freqüèn ies de dimensió vari-ableLa implementa ió que es presenta en aquest apartat és una implementa ió general. Es potapli ar al problema 6.1, però també es pot apli ar a qualsevol altre problema que requereixi lagestió d'una taula de freqüèn ies. En aquest as es mantindrà una taula de parelles (element,freqüèn ia).Per al problema de les vo als, al substituir el tipus Element pel tipus ara ter.Si, en llo de resoldre el problema 6.1, se'ns demanés la freqüèn ia d'apari ió de ada unade les lletres d'un text, l'algorisme prin ipal seria el mateix que el vist per al problema 6.1 ila implementa ió seria la TF2, que es veu en aquest apartat. onst N = 100 f onsttipusTauFreq = tupla

telem : TauParellesnelem : enterftupla

TauParelles = taula [1 . . N ] de ParellaParella = tupla

x : Elementf : enterftuplaftipusskipa ió Inicialitzar(sor t : TauFreq)

t.nelem := 0fa ióskipa ió Afegir(entsor t : TauFreq, ent x : Element)vartrobat : booleàpos : enterfvar

CercaTF (t, x, trobat, pos)

6.4. TAULA DE FREQÜÈNCIES 103si trobat → t.telem[pos].f := t.telem[pos].f + 1⊓⊔ ¬trobat → InsereixTF (t, x, pos)fsifa ióskipfun ió Freq(ent t : TauFreq, ent x : Element) retorna entervar

trobat : booleàpos : enterf : enterfvar

CercaTF (t, x, trobat, pos)si trobat → f := t.telem[pos].f⊓⊔ ¬trobat → f := 0fsiretorna f�un ióAra dissenyarem els subprogrames del segon nivell de l'anàlisi des endent del tipus Tau-Freq : les a ions Cer aTF i InsereixTF. Aquestes dues a ions es dissenyaran tenint en ompteuna propietat que ha de ser invariant: que la taula estigui ordenada pel amp de tipus Ele-ment. Aquestes a ions són similars a les vistes a la implementa ió M2 del tipus Matriu vistesa l'apartat 6.3.1. L'a ió Cer aTF bus a l'element; si el troba, indi a la posi ió on és i, si noel troba, indi a la posi ió on hauria d'anar.Vegem primer les espe i� a ions:{Pre : t és una taula de freqüèn ies ordenada pel amp Element}a ió CercaTF (ent t : TauFreq, ent x : Element, sor trobat : booleà, sor pos : enter){Post: (trobat ≡ ∃pos : 1 ≤ pos ≤ t.nelem : elementpos = x ∧

(¬trobat ≡ ∀i : 1 ≤ i < pos : elementi < x∧ ∀i : pos ≤ i ≤ t.nelem : elementi > x}skip

{Pre : t = T és una taula de freqüèn ies ordenada pel amp de tipus Element∧ n = t.nelem ∧ x 6∈ t}a ió InsereixTF (entsor t : TauFreq, ent x : Element, ent pos : enter)

{Post: t = T amb tots els elements a partir de pos desplaçats una posi ió ap enrere∧ t.nelem = n + 1 ∧ elementpos = x ∧ frequenciapos = 1}Implementa ions:a ió CercaTF (ent t : TauFreq, ent x : Element, sor trobat : booleà, sor pos : enter)

pos := 1; trobat := falsmentre pos ≤ t.nelem ∧ ¬trobat fersi t.telem[pos].x ≥ x → trobat := ert⊓⊔ t.telem[pos].x < x → pos := pos + 1fsi

104 CAPÍTOL 6. INTRODUCCIÓ A LES ESTRUCTURES DE DADESfmentresi trobat → si t.telem[pos].x > x → trobat := fals⊓⊔ t.telem[pos].x = x →fsi

⊓⊔ ¬trobat →fsifa ióa ió InsereixTF (entsor t : TauFreq, ent x : Element, ent pos : enter)var i : enter fvarsi pos ≤ t.nelem →i := t.nelem + 1mentre ¬(i ≤ pos) fer

t.telem[i] := t.telem[i− 1]i := i− 1fmentre

⊓⊔ pos > t.nelem →fsit.telem[pos].x := xt.telem[pos].f := 1t.nelem := t.nelem + 1fa ió6.4.5 Un altre exempleEnun iatPel CSE entra una seqüèn ia d'edats a abada amb el valor -1. Dissenyeu un algorismeque tregui pel CSS la distribu ió d'edats i la seva mitjana. Suposem que totes les edats sónmenors que 120.Resolu ióResoldrem aquest problema usant l'espe i� a ió per a una taula de freqüèn ies de l'apartat6.4.1.Espe i� a ió de l'algorisme:{Pre : CSE = e1e2 . . . − 1}algorisme Edats{Post: CSS = e1f1 . . . enfnp ∧ n: nombre edats diferents a la seqüèn ia d'entrada

∧ ∀i : 1 ≤ i ≤ n : fi = freq(ei) amb fi 6= 0 ∧ p =Pn

i=1eifi

Pni=1

fi}Disseny de l'algorisme:algorisme Edatsvar

t : TauFreqe, nt, nfreq, i, f : enter

6.5. BIBLIOGRAFIA RELACIONADA 105p : realfvar

Inicialitzar(t)LlegirEnter(e)mentre e 6= −1 fer

Afegir(t, e)LlegirEnter(e)fmentre

nt := 0nfreq := 0i := 1mentre ¬(i > 120) fer

f := Freq(t, i)si f 6= 0 → EscriureEnter(i)EscriureEnter(f)nt := nt + fnfreq := nfreq + i ∗ f

⊓⊔ f = 0 →fsii := i + 1fmentre

p := EnterAReal(nfreq)/EnterAReal(nt)EscriureReal(p)falgorismeLa implementa ió TF2 de les opera ions que fan referèn ia a la taula de freqüèn ies éstambé apli able en aquest problema. Només al substituir Element per enter.6.5 Bibliogra�a rela ionadaAquest tema es pot ampliar amb el apítol 5 del llibre [8℄. Es re omana resoldre i onsultarl'exer i i 7.4, Experiment PSI, de [10℄. Vegeu també la ol.le ió de problemes.

106 CAPÍTOL 6. INTRODUCCIÓ A LES ESTRUCTURES DE DADES

Capítol 7Apuntadors i memòria dinàmi a7.1 Apuntadors7.1.1 Introdu ióUn apuntador és una variable que onté l'adreça de memòria d'una altra variable. Els apun-tadors són una eina tan útil om perillosa. Cal usar-los orre tament i de forma lara. Si no,podem rear programes in omprensibles o, el que és pitjor, de difí il depura ió. Als apuntadorstambé se'ls anomena adre es.En aquest apítol, el tema dels apuntadors es tra tarà dire tament des del punt de vistadel llenguatge C.Apuntadors i adre esLa memòria entral està organitzada en el.les que es poden manipular individualment o engrups ontigus. Cada el.la o grup pot estar asso iat a una variable i té un ontingut i unaadreça. El valor de la variable orrespon a aquest ontingut i les variables es manipuleninternament mitjançant les adre es i externament, pel programa, mitjançant els noms. Unapuntador és un grup de el.les en les quals el ontingut és l'adreça a un altre grup de el.les.Es disposa de dos operadors unaris que permeten obtenir l'adreça d'una variable, &, i el ontingut d'una adreça, *, respe tivament.A la �gura 7.1.1, la variable pa és un apuntador de la variable a, &a indi a l'adreça de a,i *pa indi a el ontingut de la variable apuntada per pa, és a dir, el valor de a.Per de larar una variable apuntador al indi ar el tipus que apunta.float a;float *pa; /* variable apuntador de float */int x, y;int *ip; /*de larem un apuntador d'enter*/x = 1;ip = &x; /* ip onte l'adreça de x */y = *ip; /* y pren per valor el ontingut de la variableapuntada per ip, 1 */*ip = 2; /* equival a x = 2; */*ip = *ip + 1; /* in rementa x, equival a fer x= x+1; */107

108 CAPÍTOL 7. APUNTADORS I MEMÒRIA DINÀMICApa

a1089

34.5

347

1089Figura 7.1: Apuntadors. pa és un apuntador de a. pa onté l'adreça de a.En l'exemple anterior, x i *ip són sinònims. Això vol dir que hi ha formes diferentsd'a edir a una mateixa variable (regió de memòria). En el odi anterior, quan fem *ip =2; també assignem aquest valor a la variable x. Evidentment, si no es va amb ompte, tenirsinònims pot ser on�i tiu.Apuntadors i taulesEn C, hi ha una gran rela ió entre apuntadors i taules. I és així �ns al punt que tota opera ióque es pot fer mitjançant indexa ió de taules, també es pot fer amb apuntadors.Per de�ni ió, el nom d'una variable de tipus taula és l'adreça de la taula (del primerelement de la taula). In rementant aquesta adreça s'obtenen les adre es de tots els elementsde la taula, independentment del tipus dels elements.int a[10℄;• a equival a &a[0℄, adreça de l'ini i de la taula (la del primer omponent de la taula)• a + i equival a &a[i℄, adreça del omponent i de la taula. *(a+i) equival a a[i℄. Defet, el llenguatge C avalua a[i℄ fent *(a+i). Això és sempre ert independentment deltipus dels elements de la taula, ja que (a+i) apunta l'i-èsim obje te després de a.• Cal tenir en ompte que a no és una variable i, per tant, no es pot fer a= &b ni a++,opera ions que es poden fer amb variables que siguin apuntadors.• int a[℄; és equivalent a int *a;Aritmèti a d'apuntadorsUn apuntador i un enter es poden sumar i restar:int n;float *p, *q;q = p + n;q és l'adreça de l'enèsim obje te més enllà de l'obje te apuntat per p, sigui quin sigui eltipus de l'obje te apuntat per p. En aquest as, els obje tes són float i, per rant, q es trobaa una posi ió que està a una diatàn ia de n per la mida d'un float més enllà de p.Les opera ions vàlides entre apuntadors són:

7.1. APUNTADORS 109• Assignar apuntadors del mateix tipus.• Sumar o restar un apuntador i un enter.• Restar o omparar dos apuntadors d'elements d'una mateixa taula:Suposem la de lara ió:int a[10℄;El resultat de l'expressió &a[3℄ < &a[5℄ és CERT independentment del ontingut. I elresultat de l'expressió &a[5℄ - &a[3℄ + 1 és 3.• Assignar o omparar amb zero. Al �txer de apçaleres stdio.h hi ha de�nida la onstantNULL om a zero, que és la que s'usa quan es treballa amb apuntadors.#define NULL 0No és permès sumar dos apuntadors, multipli ar-los, dividir-los, sumar-hi un float oqualsevol altre tipus que no sigui un int ni assignar un apuntador d'un tipus a un d'un altretipus.7.1.2 Apuntadors i arguments de fun ionsEl me anisme de pas de paràmetres vist �ns ara (ent, sor, ent/sort) orrespon a una las-si� a ió on eptual. El me anisme de pas intern es pot dur a terme fonamentalment de duesmaneres: per valor i per adreça (o referèn ia). El pas per valor impli a fer una òpia del pa-ràmetre i treballar amb aquesta òpia, de manera que protegim la informa ió que es passa depossibles modi� a ions. Els paràmetres d'entrada s'han de passar per valor. El pas per adreçano impli a ap òpia sinó que la fun ió que rida envia l'adreça dels paràmetres a la fun ió ridada, de manera que aquesta fun ió pot a edir a la posi ió de memòria de la variable imodi� ar-la. Els paràmetres de sortida i d'entrada/sortida s'han de passar per referèn ia.El me anisme de pas del llenguatge C és sempre per valor. El llenguatge C simula el pasper referèn ia passant per valor l'adreça del paràmetre orresponent. Això vol dir que, quanes vol passar un paràmetre per adreça, al posar explí itament l'apuntador (adreça) de lavariable.En el següent exemple, la rida inter anvi (a, b) fa que la fun ió inter anvi inter anviïels valors de x i y que són òpies de a i b. Aquest intervanvi no té ap efe te en el programaprin ipal.void main (void){int a, b;a = 4;b = 5;inter anvi (a, b);/* a = 4, b = 5 */}void inter anvi (int x, int y)

110 CAPÍTOL 7. APUNTADORS I MEMÒRIA DINÀMICA{ int temp;temp = x; x = y; y = temp;} En el següent exemple, la rida inter anvi (&a, &b) envia l'apuntador de les variablesa i b (&a i &b) a la fun ió inter anvi. Aquesta fun ió rep els apuntadors de a i b (px ipy), de manera que px i py són òpies de &a i &b), i inter anvia el ontingut de les variablesapuntades per ells (*px i *py). Es ompleix que px és el mateix que &a i que a és el mateixque *px (és a dir, són sinònims). El mateix passa per a py.void main (void){int a, b;a = 4;b = 5;inter anvi (&a, &b);/* a = 5, b = 4 */}void inter anvi (int *px, int *py){ int temp;temp = *px; *px = *py; *py = temp;} Quan es passa l'adreça d'un paràmetre, al protegir-nos a nosaltres mateixos de no mo-di� ar l'adreça, ja que això omportaria seriosos on�i tes de memòria. De fet, el que volemmodi� ar és el ontingut de la variable apuntada per l'adreça i no pas l'adreça.Re ordem la sintaxi per al me anisme de pas pels paràmetres:tipus ent a: tipus ent/sor, sor a: tipusno taula tipus a tipus *atipus * onst ataula onst tipus a tipus aEn aquesta sintaxi s'usa el modi� ador de tipus onst per als paràmetres que no són detipus taula quan són de sor, ent/sort. Un obje te de tipus onst es pot ini ialitzar, peròdesprés ja no se li pot assignar res més. Quan aquest modi� ador s'apli a a una adreça, privaque aquesta adreça pugui ser modi� ada.En l'exemple que es mostra tot seguit no s'usa el modi� ador de tipus onst. Estem ometent un gran error, ja que l'assigna ió a=5; és una assigna ió a un apuntador i no a unenter, om hauria de ser. El ompilador dóna un avís (non portable pointer onversion), peròno dóna un error.#in lude''entsort.h''void ab (int *a);void main (void){int a;

7.1. APUNTADORS 111a = 4;ab (&a);Es riureEnter (a);}void ab (int *a){ a = 5;}En aquest altre exemple estem ometent el mateix error però, om que usem el modi� adorde tipus onst, el ompilador dóna error (no es pot modi� ar un obje te onstant) ja que estemintentant modi� ar un obje te onstant (l'apuntador d'una variable).#in lude''entsort.h''void ab (int * onst a);void main (void){int a;a = 4;ab (&a);Es riureEnter (a);}void ab (int * onst a){ a = 5;}Aquest és el odi orre te de l'a ió ab : aquí es fa una assigna ió a un enter i no a unapuntador.void ab (int * onst a){ *a = 5;}Quan passem una taula, en realitat estem passant l'apuntador al seu ini i. Per tant,l'estem passant per adreça. Si volem passar una taula om a paràmetre d'entrada hauremd'usar també el modi� ador onst. onst int a[100℄ força que el ontingut de a sigui onstant.int a[100℄;ab (a); /* passem l'apuntador a l'ini i de a */...........void ab (int a[100℄){ .... a[3℄ = 4; ....} /* ho permet, sor o e/s */...........void ab ( onst int a[100℄){ .... a[3℄ = 4; ....} /* no ho permet, ent */

112 CAPÍTOL 7. APUNTADORS I MEMÒRIA DINÀMICA7.2 Gestió dinàmi a de memòria7.2.1 Reserva i alliberament de memòriaLa memòria dinàmi a és la part de la memòria d'un omputador que pot ser reservada ialliberada en temps d'exe u ió.Els llenguatges de programa ió ofereixen opera ions per fer reserves i alliberaments dezones de memòria dinàmi a. L'opera ió de reserva de memòria sol.li ita espai su� ient peren abir-hi un o més obje tes d'un ert tipus i retorna un apuntador d'aquest espai de memòria.A partir d'aquest moment, el treball amb els obje tes esmentats es fa mitjançant aquestapuntador. L'opera ió inversa d'alliberament de memòria rep un apuntador i allibera l'espaide memòria apuntat per aquest apuntador.Aquestes opera ions en C són dues fun ions de la llibreria estàndard que estan espe i� adesal �txer de apçaleres (headers) stdlib.h. Els seus prototipus són:void *mallo (size_t size);void free (void *p);La fun ió mallo rep om a paràmetre una variable que indi a la mida (en bytes) de lazona de memòria que es vol reservar i retorna un apuntador de void que es pot assignar a unapuntador de qualsevol tipus. La fun ió mallo pot retornar el valor NULL que signi� a que nohi ha prou memòria per fer aquesta reserva. L'a ió free allibera la memòria orresponent.Per saber la mida d'un determinat tipus podem usar l'operadorsizeof(T);que reporta el nombre de bytes ne essaris per guardar un obje te del tipus del seu operand.Per exemple, sizeof( har) retorna 1. Si s'apli a a una taula o tupla, el resultat és el nombrede bytes que o upa la taula o tupla. Aquest tipus es de�neix om size_t.A ontinua ió es mostren les opera ions per dur a terme reserves i alliberaments per adiversos tipus de variables [7℄:• elementals• tupla• taula7.2.2 Memòria dinàmi a per a diversos tipusTipus elementals#in lude <assert.h>#in lude <stdio.h>#in lude <stdlib.h>void main(void){ har *a;a = CrearCara ter();*a = 'x';

7.2. GESTIÓ DINÀMICA DE MEMÒRIA 113Es riureCara ter(*a);Es riureCara ter('\n');DestruirCara ter(a);} har * CrearCara ter(void){ har * ; = mallo (sizeof ( har));assert( != NULL);return ; }void DestruirCara ter( har * ) {free( );} L'asser ió assert( != NULL);, que es veurà en totes les opera ions de rea ió que reque-reixen reservar memòria, ontrola que hi hagi prou memòria. En as que no n'hi hagi prou,l'adreça que retorna la fun ió mallo és NULL.Tipus tupla#in lude <assert.h>#in lude <stdio.h>#in lude <stdlib.h>#define M 10typedef int TaulaEnter[M℄;typedef stru t { har ;int i;TaulaEnter t;} TuplaA;void main(void) {TuplaA *ta;int i;ta = CrearTuplaA();(*ta). = 'v';(*ta).i = 321;i = 0;while (i < M) {(*ta).t[i℄ = 2 * i;i = i + 1;}Es riureTuplaA(*ta);

114 CAPÍTOL 7. APUNTADORS I MEMÒRIA DINÀMICADestruirTuplaA(ta);}TuplaA * CrearTuplaA(void) {TuplaA *t;t = mallo (sizeof (TuplaA));assert(t != NULL);return t;}void DestruirTuplaA(TuplaA * t){free(t);}Tipus taula#in lude <assert.h>#in lude <stdio.h>#in lude <stdlib.h>#define N 10typedef har TauCar[N℄;void main(void) {TauCar *t ;t = CrearTauCar();(*t )[0℄ = 'a';(*t )[5℄ = 'b';Es riureCara ter((*t )[0℄);Es riureCara ter((*t )[5℄);Es riureCara ter('\n');DestruirTauCar(t );}TauCar * CrearTauCar(void) {TauCar *t;t = mallo (sizeof (TauCar));assert(t != NULL);return t;}void DestruirTauCar(TauCar * t) {free(t);}

7.3. APUNTADORS D'APUNTADORS. TAULES D'APUNTADORS 1157.2.3 Errors freqüents en l'ús d'apuntadorsA [7℄ es mostren uns exemples de programes C on hi ha errors en l'ús d'apuntadors. A l'apèndixA.16 s'intenta a edir a memòria prèviament alliberada, a l'apèndix A.17 s'intenta alliberarmemòria no reservada prèviament, i a l'apèndix A.20 es mostra l�ús de sinònims.7.3 Apuntadors d'apuntadors. Taules d'apuntadorsLes següents de lara ions són equivalents: har a[℄; har *a;Indiquen que a és un apuntador de arà ter i que es pot onsiderar om una taula dinàmi a.Com amb els altres tipus d'obje tes, es poden de larar taules d'apuntadors. També hi pothaver apuntadors d'altres apuntadors, és a dir obje tes tals que el seu ontingut és l'apuntadord'un altre obje te que també és un apuntador.La de lara iófloat **telem;es pot interpretar om un apuntador d'un apuntador de float.Per fer la reserva de memòria orresponent a la variable **telem, al fer:telem = (float **) mallo (sizeof (float*));*telem = (float *) mallo (sizeof (float));A la �gura 7.2 es mostra el resultat d'aquestes opera ions. La variable telem és unapuntador d'un apuntador de float i s'ha de larat de forma estàti a. La variable *telem ésun apuntador de float i la variable **telem és un float. D'aquestes dues se n'ha fet unareserva dinàmi a.telem

*telem**telem

Figura 7.2: Apuntador d'un apuntador de float.L'assigna ió**telem = 34.5;tindria sobre la �gura 7.2 l'efe te que es veu a la �gura 7.3.Ara bé, la mateixa de lara iófloat **telem;

116 CAPÍTOL 7. APUNTADORS I MEMÒRIA DINÀMICAtelem

*telem**telem

34.5Figura 7.3: Efe te de l'assigna ió ∗ ∗ telem = 34.5; .també es pot interpretar om una taula d'apuntadors de taules d'elements de tipus float. Ésa dir, és equivalent a la de lara iófloat telem[℄[℄;D'aquesta manera es poden fer reserves de taules semidinàmiques en temps d'exe u ió.telem

na

i

ne

telem[i][j]j

Figura 7.4: Taula semidinàmi a.La sentèn ia:telem = (float **)mallo (na * sizeof (float *));fa la reserva d'una taula de na apuntadors de float.telem[i℄ indi a l'i-èsim apuntador que apunta la i-èsima taula d'elements de tipus float.Per reservar memòria per a totes aquestes taules de float al fer el següent:i = 0;while (i != na) {telem[i℄ = (float *)mallo (ne * sizeof(float));i = i + 1;} On ne és el nombre d'elements de les taules de float esmentades.La forma d'a edir als elements de la taula és la mateixa que en una matriu estàti a:telem[i℄[j℄ designa l'element de la �la i i la olumna j, que també es pot designar mitjançantla expressió *(*(telem + i) + j)).

7.4. VECTORS I MATRIUS SEMIDINÀMICS 1177.4 Ve tors i matrius semidinàmi sAl apítol 6 s'han vist les espe i� a ions dels tipus Ve tor i Matriu així om diverses imple-menta ions d'aquests tipus. En aquest apítol hem estudiat una nova eina de la programa ió,que és la gestió de memòria dinàmi a. Aquesta eina ens permet fer noves implementa ionsdels tipus Ve tor i Matriu que, en llo de ser estàtiques, seran semidinàmiques.Les espe i� a ions per estru tures semidinàmiques varien una mi a ja que al tenir en ompte l'opera ió de Destruir les variables d'aquests tipus.En aquest apartat es fa una amplia ió de l'espe i� a ió del tipus matriu i es veuen dues for-mes d'implementar matrius semidinàmiques. Aquestes implementa ions es veuen dire tamenten el llenguatge de programa ió C ja que així és om s'ha estudiat tot aquest apítol.Aquesta amplia ió de l'espe i� a ió del tipus Matriu, així om les dues implementa ions,tenen un obje tiu doble: per una banda serveixen d'exer i i de om es treballa amb apuntadorsi memòria dinàmi a; de l'altra, permetran resoldre de forma més e� ient alguns algoritmes deresolu ió de sistemes d'equa ions lineals que es veuran al apítol 8.L'espe i� a ió del tipus Ve tor semidinàmi és al apítol 10 de [7℄ (és la mateixa que lavista al apítol 6 amb l'opera ió Destruir i a l'apèndix A.29 s'hi mostra una implementa ióamb gestió dinàmi a de memòria.7.4.1 Espe i� a ió de les noves opera ions del tipus MatriuL'espe i� a ió del tipus Matriu vista a l'apartat 6.2 s'amplia amb tres opera ions més.La primera, DestruirMatriu, és ne essaria pel fet de treballar amb memòria dinàmi a.{Pre : cert}a ió DestruirMatriu(entsor m : Matriu){Post: m destruïda}Les altres dues, IntFilesMatriu i IntColsMatriu, permeten inter anviar �les i olumnesd'una matriu, respe tivament. Són dues opera ions que al fer en alguns mètodes de resolu ióde sistemes d'equa ions lineals, i per això s'in louen om a opera ions del tipus matriu.{Pre : 0 ≤ i, j < FilesMatriu(m) ∧ m = M}a ió IntFilesMatriu(entsor m : Matriu, ent i, j : enter){Post: (∀α, β : 0 ≤ α < FilesMatriu(m) ∧ α 6= i ∧ α 6= j ∧

0 ≤ β < ColsMatriu(m) : m[α, β] = M [α, β])(∀β : 0 ≤ β < ColsMatriu(m) : m[i, β] = M [j, β] ∧ m[j, β] = M [i, β])}

{Pre : 0 ≤ i, j < ColsMatriu(m) ∧ m = M}a ió IntColsMatriu(entsor m : Matriu, ent i, j : enter){Post: (∀α, β : 0 ≤ α < ColsMatriu(m) ∧ α 6= i ∧ α 6= j ∧

0 ≤ β < FilesMatriu(m) : m[α, β] = M [α, β])(∀β : 0 ≤ β < FilesMatriu(m) : m[β, i] = M [β, j] ∧ m[β, j] = M [β, i])}

118 CAPÍTOL 7. APUNTADORS I MEMÒRIA DINÀMICA7.4.2 Implementa ió M4. Primera implementa ió d'una matriu semidinà-mi aAquesta implementa ió onstrueix una matriu de la forma om s'indi a a la �gura 7.5. Lade�ni ió de tipus i la implementa ió són als apèndixs A.14 i A.15 de [7℄.telem

nfnc

fila 1 fila nf

element fila i columna jnc

fila2 fila i

Figura 7.5: Taula semidinàmi a. Primera implementa ió.7.4.3 Implementa ió M5. Segona implementa ió d'una matriu semidinà-mi aAquesta implementa ió onstrueix una matriu de la forma om s'indi a a la �gura 7.6. L'a-vantatge d'aquesta implementa ió és que no al fer l'opera ió d'inter anvi de �les elementa element om és habitual, sinó que, en aquest as, només al fer un inter anvi entre elsapuntadors de les dues �les a inter anviar.telem

na

i

ne

telem[i][j]j

Figura 7.6: Taula semidinàmi a. Segona implementa ió.A ontinua ió es presenta aquesta implementa ió. És interessant omparar la implemen-ta ió de l'opera ió d'inter anvi de �les en les implementa ions M4 i M5.typedef stru t {float **telem; /* Taula d'apuntadors de taules d'elements */int nf; /* Nombre de files */int n ; /* Nombre de olumnes */} Matriu;int FilesMatriu(Matriu m) {return m.nf; }int ColsMatriu(Matriu m){return m.n ; }

7.4. VECTORS I MATRIUS SEMIDINÀMICS 119Matriu CrearMatriu(int nf, int n ) {Matriu m;int i;assert(nf > 0 && n > 0);m.nf = nf;m.n = n ;m.telem = (float **)mallo (nf * sizeof (float *));assert(m.telem != NULL);i = 0;while (i != nf) {m.telem[i℄ = (float *)mallo (n * sizeof (float));assert(m.telem[i℄ != NULL);i = i + 1;}return m;}void DestruirMatriu(Matriu * onst m) {int i;i = 0;while (i != (*m).nf) {free((*m).telem[i℄);i = i + 1;}free((*m).telem);}void AssigMatriu(Matriu * onst m, int i, int j, float f) {assert(0 <= i && i < (*m).nf && 0 <= j && j < (*m).n );(*m).telem[i℄[j℄ = f;}float ConsMatriu(Matriu m, int i, int j) {assert(0 <= i && i < m.nf && 0 <= j && j < m.n );return m.telem[i℄[j℄;}void IntFilesMatriu(Matriu * onst m, int i, int j) {assert(0 <= i && i < (*m).nf && 0 <= j && j < (*m).nf);InterApReal(&(*m).telem[i℄, &(*m).telem[j℄);}void IntColsMatriu(Matriu * onst m, int i, int j) {int k;assert(0 <= i && i < (*m).n && 0 <= j && j < (*m).n );k = 0;while (k != (*m).nf) {

120 CAPÍTOL 7. APUNTADORS I MEMÒRIA DINÀMICAInterReal(&(*m).telem[k℄[i℄, &(*m).telem[k℄[j℄);k = k + 1;}}void InterApReal (float ** onst a, float ** onst b) {float *aux;aux= *a; *a= *b; *b= aux;}void InterReal (float * onst a, float * onst b) {float aux;aux= *a; *a= *b; *b= aux;}7.5 Bibliogra�a rela ionadaAquest tema es pot omplementar amb el apítol 10 del llibre de prà tiques [7℄ i es pot ampliaramb el apítol 5 del llibre [5℄.

Capítol 8Apli a ions al àl ul numèri 8.1 Resolu ió de sistemes d'equa ions lineals. Introdu ió8.1.1 Càl ul numèri L'obje tiu del àl ul numèri és l'estudi de mètodes onstru tius, és a dir, pro ediments quepermeten obtenir la solu ió d'un problema amb una pre isió arbitrària en un nombre �nit depassos. Aquest mètodes resolen problemes del tipus:• obten ió de l'arrel d'una fun ió• resolu ió de sistemes d'equa ions• interpola ió• integra ió• . . .En aquesta assignatura ens on entrarem només en un tipus de problema, el de la resolu ióde sistemes d'equa ions lineals.8.1.2 Errors de trun ament i d'arrodonimentEls errors d'arrodoniment són els que es produeixen en els pro essos de àl ul pel fet detreballar amb pre isió �nita. Els omputadors representen els valors reals en base 2 i usen larepresenta ió de oma �otant,

mantissa× 2exponentla longitud de la mantissa indi a la pre isió, mentre que la de l'exponent indi a la magnituddel valor que es representa. Les mantisses poden ser de 24 bits (pre isió simple) o de 56 bits(pre isió doble), que equivalen a uns 6 o 10 dígits de pre isió en base 10, respe tivament.Evidentment, la pre isió es podria augmentar, però sempre serà �nita i, per tant, sempre esproduiran errors d'arrodoniment.L'error de trun ament o error del mètode és l'error teòri del mètode. Hi ha mètodes queno tenen error de trun ament, és a dir, que amb una màquina de pre isió in�nita el resultatseria exa te. Però hi ha mètodes que donen un resultat aproximat i en ara que s'usés unamàquina de pre isió in�nita, el resultat no seria exa te. Tots els mètodes d'aquest tipus, però,donen una ota màxima de l'error que produeixen.121

122 CAPÍTOL 8. APLICACIONS AL CÀLCUL NUMÈRIC8.1.3 Resolu ió de sistemes d'equa ions linealsPer resoldre un sistema d'equa ions lineals Ax = b hi ha mètodes dire tes i mètodes iteratius.Els mètodes dire tes apliquen un pro ediment a les dades (matriu de oe� ients A i ve torde termes independents b) i obtenen una solu ió exa ta. L'error de trun ament és nul. Elsmètodes més oneguts són el de Gauss i l'LR (o LU).Els mètodes iteratius parteixen d'una solu ió x0 i obtenen una su essió d'aproxima ionsmillorades, el límit de la qual és la solu ió bus ada. Els mètodes més oneguts són el de Ja obii el de Gauss-Seidel. Aquests mètodes tenen error de trun ament.8.2 Mètode de Gauss8.2.1 Introdu ióEl mètode de Gauss onsta de dos passos:1. Conversió del sistema ini ial en un sistema triangular superior: elimina ió gaussiana.a11x1 + a12x2 + a13x3 + · · ·+ a1nxn = b1

a21x1 + a22x2 + a23x3 + · · ·+ a2nxn = b2

a31x1 + a32x2 + a33x3 + · · ·+ a3nxn = b3. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .an1x1 + an2x2 + an3x3 + · · ·+ annxn = bn

=⇒ Ax = bα11x1 + α12x2 + α13x3 + · · ·+ α1nxn = β1

α22x2 + α23x3 + · · ·+ α2nxn = β2

+α33x3 + · · ·+ α3nxn = β3. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .αnnxn = βn

=⇒ αx = β2. Resolu ió del sistema triangular superior resultant.xn = βn

αnn

xi =βi−

Pnj=i+1 αij xj

αii, i = n− 1 . . . 18.2.2 Pro és d'elimina ió gaussianaConsisteix en una sèrie de passos: tants om el nombre de �les-1. Al pas k-èssim s'eliminenels oe� ients de la olumna k-èssima de les �les a partir de la k-èssima.Pas 1: s'eliminen a21, a31, . . . , an1 (1a olumna)Pas 2: s'eliminen a32, a42, . . . , an2 (2a olumna). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .Pas k: s'eliminen ak+1,k, ak+2,k, . . . , an,k (ka olumna). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .Pas n-1: s'elimina an n−1Per a onseguir-ho es de�neixen uns valors per a ada pas i per a ada equa ió:

8.2. MÈTODE DE GAUSS 123Pas 1: de�nim els valors mi1 = ai1

a11i = 2 . . ni sumem −mi1 vegades la 1a equa ió a la i-èssima equa ió.Pas 2: de�nim els valors mi2 = ai2

a22i = 3 . . ni sumem −mi2 vegades la 2a equa ió a la i-èssima equa ió.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .Pas k: de�nim els valors mik = aik

akki = k + 1 . . ni sumem −mi2 vegades la 2a equa ió a la i-èssima equa ió.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .Pas n-1: de�nim el valor mn n−1 = an n−1

an−1 n−1i sumem −mn n−1 vegades l'equa ió n − 1 al'equa ió n.Totes les opera ions que es fan a ada pas usen els valors a tualitzats en el pas anterior.8.2.3 Estratègies de pivotPer a l'elimina ió gaussiana hem usat uns pivots aii, que hem suposat no nuls. Si algun d'a-quest pivots és 0, el mètode no es pot apli ar dire tament. Aleshores al es ollir un pivot queno doni aquest problema. De fet, el pivotatge és onvenient apli ar-lo sempre perquè aportaestabilitat numèri a a l'algorisme resultant, ja que la divisió per un nombre real extremada-ment petit o gran en un omputador pot donar llo a errors numèri s (errors d' over�ow iunder�ow).Don s, una manera de garantir la millor estabilitat numèri a del mètode és apli ant unaestratègia de pivot adequada a ada pas, en ara que aii no sigui nul ni ex essivament petito gran. En veurem dues, el pivotatge par ial i el pivotatge total. L'estratègia de pivotatgepar ial onsisteix a inter anviar les �les i-èssima i j-èssima a ada pas de la triangula ió. Elpivotatge total no només inter anvia �les, sinó també olumnes.En el pas k-èssim de la triangula ió1. Pivotatge par ial: en el pas k-èssim de la triangula ió triem r om el menor enter que

| ark |= maxk≤i≤n

| aik | el maxim de la columnai inter anviem les �les k i r.2. Pivotatge total: en el pas k-èssim de la triangula ió triem r i s om els menors entersque| ars |= max

k≤i,j≤n| aij |i inter anviem les �les k i r i les olumnes k i s.Notem que quan un aii = 0, si el sistema és ompatible determinat (det(A) 6= 0) ⇒

∃ aji, j = i+1 . . n | aji 6= 0.Alguns sistemes tenen la garantia de ser numèri ament estables i aleshores no al ferpivotatge. Un sistema és numèri ament estable si es ompleix alguna de les dues propietatssegüents:1. La matriu A és diagonalment dominant per �les:| aii |>

∑

j 6=i

| aij | i = 1 . . n

124 CAPÍTOL 8. APLICACIONS AL CÀLCUL NUMÈRIC2. A és simètri a A = AT i de�nida positiva xtAx > 0,x 6= 0Fixem-nos que inter anviar dues �les d'un sistema d'equa ions equival a inter anviar l'or-dre de dues de les equa ions del sistema, per tant en aquest as aldrà anviar no sols lamatriu A sinó també dos dels termes independents del ve tor b.D'altra banda, inter anviar dues olumnes d'un sistema d'equa ions equival a iner anviard'ordre dues in ògnites � i en aquest as no aldrà per tant modi� ar el terme independent.No obstant, notem que en general qui utilitzi un subprograma de resolu ió d'un sistema linealdesitjarà onèixer no tant sols el valor numèri de les in ògnites (de forma desordenada), sinóque voldrà saber en on ret per ada in ògnita el valor que li orrespon. Aquesta ir umstàn ia al tenir-la, don s, en ompte a l'hora de dissenyar el subprograma de resolu ió del sistemaquan s'utilitzi el pivotatge par ial, que inter anvia olumnes.8.2.4 Algorismes orresponents al mètode de GaussA ontinua ió s'enun ien uns subprogrames ne essaris per implementar el mètode de Gauss.Aquests programes s'han de dissenyar usant les espe i� a ions de ve tors i matrius orrespo-nents.• Subprograma que implementi l'estratègia de pivotatge par ial.• Subprograma que implementi l'estratègia de pivotatge total.• Subprogrames que triangulin un sistema apli ant el mètode d'elimina ió gaussiana ambuna de les dues estratègies de pivotatge anteriors.• Subprograma que resolgui un sistema lineal triangular superior.• Subprograma que resolgui un sistema apli ant la triangula ió per elimina ió gaussiana iresolent el sistema triangular.8.2.5 Subprograma de resolu ió d'un sistema amb pivotatge par ialA ontinua ió es mostra l'algorisme de resolu ió orresponent a l'elimina ió gaussiana ambl'estratègia de pivotatge par ial. Usarem les opera ions dels tipus Ve tor iMatriu espe i� adesa 6.1.1, 6.2.1 i 7.4.1. Cal re ordar que, en la seva espe i� a ió, els rangs de les �les i les olumnes van de 0 al nombre de �les i olumnes menys 1, respe tivament.L'algorisme prin ipal rebrà una matriu A de oe� ients i un ve tor de termes independentsb, resoldrà el sistema i retornarà un ve tor x amb els valors de les in ògnites.

{Pre : FilesMatriu(a) = ColsMatriu(a) = DimV ector(b) = DimV ector(x)}a ió ResolSistemaPivotP (ent a : Matriu, ent b : V ector, entsor x : V ector){Post: x és tal que a · x = b}a ió ResolSistemaPivotP (ent a : Matriu, ent b : V ector, entsor x : V ector)

EliminacioGaussianaPivotP (a, b)ResolSistemaTriangularSup(a, b, x)fa ió

8.2. MÈTODE DE GAUSS 125El primer subprograma, el que efe tua l'elimina ió gaussiana, està resolt al següent apartat.El subprograma de resolu ió d'un sistema triangular l'espe i� arem i resolem tot seguit.{Pre : n = FilesMatriu(a) = ColsMatriu(a) = DimV ector(b) = DimV ector(x) ∧

∀i, j : 0 ≤ j < i < ColsMatriu(a) : ai,j = 0}a ió ResolSistemaTriangularSup(ent a : Matriu, ent b : V ector, entsor x : V ector){Post: x és tal que a · x = b}a ió ResolSistemaTriangularSup(ent a : Matriu, ent b : V ector, entsor x : V ector)var

i, j : enters : realfvar

i := FilesMatriu(a)− 1mentre ¬(i < 0) fer{Cal ulem s =

∑nj=i+1 ai,jxj}

s := 0.0j := i + 1mentre ¬(j ≥ FilesMatriu(a)) fer

s := s + ConsMatriu(a, i, j) ∗ ConsV ector(x, j)j := j + 1fmentre

AssigV ector(x, i, (ConsV ector(b, i) − s)/ConsMatriu(a, i, i))i := i− 1fmentrefa ió

126 CAPÍTOL 8. APLICACIONS AL CÀLCUL NUMÈRIC8.2.6 Subprograma d'elimina ió gaussiana amb pivotatge par ial{Pre : FilesMatriu(a) = ColsMatriu(a) = DimV ector(b)}a ió EliminacioGaussianaPivotP (entsor a : Matriu, entsor b : V ector){Post: a, b són el resultat d'apli ar l'elimina ió gaussiana}a ió EliminacioGaussianaPivotP (entsor a : Matriu, entsor b : V ector)var

i, j, k : enterm,aij, akj, bi, bk : realfvar

{itera ions per a ada pas}k := 0mentre ¬(k > FilesMatriu (a) - 2) fer

PivotatgeParcial(a, b, k){itera ions per a ada �la}i := k + 1mentre ¬(i ≥ FilesMatriu(a)) fer

aik := ConsMatriu(a, i, k)akk := ConsMatriu(a, k, k)mik := aik/akk{itera ions per a ada olumna}j := k + 1mentre ¬(j ≥ ColsMatriu(a)) fer

aij := ConsMatriu(a, i, j)akj := ConsMatriu(a, k, j)aij := aij −mik ∗ akjAssigMatriu(a, i, j, aij)j := j + 1fmentre

bi := ConsV ector(b, i)bk := ConsV ector(b, k)bi := bi−mik ∗ bkAssigV ector(b, i, bi)AssigMatriu(a, i, k, 0.0)i := i + 1fmentre

k := k + 1fmentreNOTA: La darrera rida a AssigMatriu de l'a ió posa un zero a els elements de sota ladiagonal en la matriu A. No obstant, aquests elements justament no es onsulten per resoldreun sistema triangular superior. Observem don s que, en realitat, aquesta assigna ió no ésindispensable.

8.2. MÈTODE DE GAUSS 127L'a ió pivotatge par ial apli a l'estratègia orresponent.{Pre : FilesMatriu(a) = ColsMatriu(a) = DimV ector(b) ∧ det(a) 6= 0

∧ a = A ∧ b = B ∧ 0 ≤ k ≤ FilesMatriu(a)− 2}a ió PivotatgeParcial(entsor a : Matriu, entsor b : V ector, ent k : enter){Post: ∃r : k ≤ r < FilesMatriu(a) : ∀i : k ≤ i < FilesMatriu(a) :| Ar,k | ≥ | Ai,k |

∧ a, b s'obtenen inter anviant les �les k, r de A,B respe tivament }a ió PivotatgeParcial(entsor a : Matriu, entsor b : V ector, ent k : enter)varmax, el : reali, r : enterfvar

{Obten ió de r :| ark |= maxk≤i≤n | aik |}max := Abs(ConsMatriu(a, k, k)); r := ki := k + 1mentre ¬(i ≥ FilesMatriu(a)) fer

el := Abs(ConsMatriu(a, i, k))si el > max → max := el; r := i⊓⊔ el ≤ max →fsii := i + 1fmentre

{Inter anviem �les k i r}si r = k →⊓⊔ r > k → IntF ilesMatriu(a, k, r)

IntF ilesV ector(b, k, r)fsifa ióEn aquesta a ió apareix l'opera ió sobre el tipus Ve tor, IntFilesVe tor, la qual inter anviados elements del ve tor. La seva implementa ió es deixa om a exer i i.8.2.7 Subprograma de resolu ió d'un sistema amb pivotatge totalRe ordem que el pivotatge total inter anvia olumnes de la matriu, i per tant aquesta estra-tègia altera l'ordre de les in ògnites del sistema.En aquest as, l'estratègia que seguim onsisteix en utilitzar un ve tor d'enters que ensindiqui les permuta ions que haurem de fer per tal de re uperar l'ordre original de les in ògni-tes. Ini ialment aquest ve tor ontindrà els índexos de les in ògnites ordenades i ada op queinter anviem dues olumnes inter anviarem també els dos índexos orresponents dins aquestve tor de permuta ions. Finalment, un op resolt el sistema triangular superior, alterareml'ordre dels valors in ògnita (ara ja resolts) segons ens indiqui el ve tor de permuta ions. La�gura 8.1 il.lustra el pro és que a abem d'expli ar, així om la forma de re uperar l'ordre deles in ògnites en fun ió del ve tor de permuta ions.

128 CAPÍTOL 8. APLICACIONS AL CÀLCUL NUMÈRIC1 2 3 4 5 6

X1 X2 X3 X4 X5 X6 X7 X2 X3 X5 X6 X7X4 X1 X4 X2 X3 X1X6 X5 X7

X4 X6 X2 X5 X7 X3 X1

X1 X2 X3 X4 X5 X6 X7

x=

Valor inicial Intercanvi de columnes Valor final

. . .

permut= 7 72 3 5 64 1 4 2 3 156 7

x=

xaux=

Forma de recuperar

l’ordre original :xaux[permut[i]] = x[i]Figura 8.1: Ús del ve tor de permuta ions per re uperar l'ordre de les in ògnites alterat pelpivotage total.L'espe i� a ió del subprograma que resol un sistema utilitzant el pivotatge par ial no anvia respe te al as del pivotatge par ial, però la seva implementa ió sí perquè ha de treballaramb el ve tor de permuta ions segons hem des rit.a ió ResolSistemaPivotT (ent a : Matriu, ent b : V ector, entsor x : V ector)var

xaux : V ectorpermut : V ectorEi, lloc : enterfvar

permut := CrearV ectorE(DimV ector(x))i := 0mentre ¬(i ≥ Dimvector(x)) fer

AssigV ectorE(permut, i, i)i := i + 1fmentre

EliminacioGaussianaPivotT (a, b, permut)ResolSistemaTriangularSup(a, b, x)xaux := CrearV ector(DimV ector(x))i := 0mentre ¬(i ≥ Dimvector(x)) fer

lloc := ConsV ectorE(permut, i)AssigV ector(xaux, lloc, ConsV ector(x, i))i := i + 1fmentre

i := 0mentre ¬(i ≥ Dimvector(x)) ferAssigV ector(x, i, ConsV ector(xaux, i))i := i + 1

8.2. MÈTODE DE GAUSS 129fmentrefa ióEl tipus Ve torE és un ve tor de omponents enteres amb opera ions anàlogues al tipusVe tor. La primera itera ió de l'algorisme ini ialitza el ve tor de permuta ions, la penúltima opia els valors de les in ògnites x al llo orresponent del ve tor auxiliar i la darrera itera iósimplement opia el ve tor auxiliar sobre x.

130 CAPÍTOL 8. APLICACIONS AL CÀLCUL NUMÈRIC8.2.8 Subprograma d'elimina ió gaussiana amb pivotatge totalEl subprograma d'elimina ió gaussiana amb pivotatge total és gairebé anàleg a l'anterior peròutilitzant l'a ió PivotatgeTotal en llo de PivotatgePar ial i què rebrà i passarà om a parà-metre a PivotatgeTotal el ve tor de permuta ions. L'a ió PivotatgeTotal apli a l'estratègia orresponent i s'espe i� a i dissenya a ontinua ió.{Pre : FilesMatriu(a) = ColsMatriu(a) = DimV ector(b) = DimV ectorE(p)

det(a) 6= 0 ∧ a = A ∧ b = B ∧ p = P ∧ 0 ≤ k ≤ FilesMatriu(a)− 2}a ió PivotatgeTotal(entsor a : Matriu, entsor b : V ector, entsor p : V ectorE,ent k : enter){Post: ∃r : k ≤ r < FilesMatriu(a) ∧ ∃s : k ≤ s < FilesMatriu(a) :

∀i : k ≤ i < FilesMatriu(a),∀j : k ≤ j < ColsMatriu(a) | ar,s |≥| ai,j |∧ a s'obté inter anviant les �les k, r i les olumnes k, s de A∧ b s'obté inter anviant les �les k, r de B∧ p s'obté inter anviant les �les k, r de P}a ió PivotageTotal(entsor a : Matriu, entsor b : V ector, entsor p : V ectorE,ent k : enter)var

max, el : reali, j, r, s : enterfvar

{Obten ió de r i s | | ars |= maxk≤i,j≤n | aij |}max := Abs(ConsMatriu(a, k, k)); r := k; s := ki := kmentre ¬(i ≥ FilesMatriu(a)) fer

j := kmentre ¬(j ≥ ColsMatriu(a)) ferel := Abs(ConsMatriu(a, i, j))si

el > max → max := elr := is := j

⊓⊔ el ≤ max →fsij := j + 1fmentre

i := i + 1fmentresi {Intercanviem files k i r}r = k →

⊓⊔ r > k → IntF ilesMatriu(a, k, r)IntF ilesV ector(b, k, r)fsisi {Intercanviem columnes k i s}

s = k →⊓⊔ s > k → IntColsMatriu(a, k, s)

8.3. MÈTODES ITERATIUS 131IntF ilesV ectorE(p, k, s)fsifa ió8.3 Mètodes iteratius8.3.1 Introdu ióEls mètodes iteratius parteixen d'una aproxima ió ini ial que es va re�nant �ns a obteniruna solu ió prou aproximada. Són adequats per a matrius grans disperses, ja que llavors fanpoques opera ions.Donat un sistema lineal Ax = b, se li asso ia un sistema equivalent anomenat sistemalineal reduit

Ax = b → x = B x+ que es resol de forma iterativa: x(k+1) = B x(k) + k ≥ 0Si aquesta su essió de ve tors (x(k)), k ≥ 0 és onvergent a un ve tor v, quan k → ∞ es omplirà que x(k) = x(k+1)i aleshores x = Bx+ i serà x la solu ió bus ada.El sistema lineal reduït s'expressa sovint omxi =

−∑j=n

j=1,j 6=i aijxj + bi

aiii = 1 . . nEl pro és iteratiu es pot dur a terme de diverses maneres:1. Mètode de Ja obiA ada itera ió es fan servir tots els omponents de x de la itera ió anterior. El àl ulque es duu a terme és:

x(k+1)i =

−∑j=n

j=1,j 6=i aijx(k)j + bi

aiii = 1 . . nSovint x(0) = 0. Se suposa que aii 6= 0, i = 1..n2. Mètode de Gauss-SeidelEls omponents de x al ulades en una itera ió es fan servir per al ular els omponentsposteriors de la mateixa itera ió.

x(k+1)i =

−∑i−1

j=1 aijx(k+1)j −

∑ni+1 aijx

(k)j + bi

aii, i = 1 . . n

132 CAPÍTOL 8. APLICACIONS AL CÀLCUL NUMÈRICExemplea11x1 + a12x2 + a13x3 = b1

a21x1 + a22x2 + a23x3 = b2

a31x1 + a32x2 + a33x3 = b3

El mètode de Ja obi al ularia els omponents de la següent manera:x

(k+1)1 =

−a12x(k)2 − a13x

(k)3 + b1

a11

x(k+1)2 =

−a21x(k)1 − a23x

(k)3 + b2

a22

x(k+1)3 =

−a31x(k)1 − a32x

(k)2 + b3

a33I el mètode de Gauss-Seidel de la següent manera:x

(k+1)1 =

−a12x(k)2 − a13x

(k)3 + b1

a11

x(k+1)2 =

−a21x(k+1)1 − a23x

(k)3 + b2

a22

x(k+1)3 =

−a31x(k+1)1 − a32x

(k+1)2 + b3

a338.3.2 Algorismes orresponents als mètodes iteratiusA ontinua ió s'enun ien uns programes ne essaris per implementar els mètodes iteratius vis-tos. Aquests programes s'han de dissenyar usant les espe i� a ions de ve tors i matrius semi-dinàmiques orresponents.• Subprograma que implementi el mètode iteratiu.• Subprograma que implementi el àl ul d'una itera ió segons el mètode de Ja obi.• Subprograma que implementi el àl ul d'una itera ió segons el mètode de Gauss-Seidel.8.3.3 Subprograma que implementa el mètode iteratiuL'algorisme per al ular la solu ió de manera iterativa és el següent:

{Pre : DimV ector(b) = FilesMatriu(a) = ColsMatriu(a) ∧ espilon > 0}fun ió SolucioIterativa(ent a : Matriu, ent b : V ector, ent epsilon : real) retorna V ector{Post: x = SolucioIterativa(a, b, epsilon) ∧ DimV ector(x) = DimV ector(b)

∧ xant és la solu ió a la itera ió anterior a x ∧ | xant− x |≤ epsilon}

8.3. MÈTODES ITERATIUS 133fun ió SolucioIterativa(ent a : Matriu, ent b : V ector, ent epsilon : real) retorna V ectorvar x0, x1 : V ector fvarx0 := V ector0(DimV ector(b))x1 := CalculaIteracio(x0, a, b)mentre ModulV ector(DiferenciaV ectors(x0, x1)) > epsilon fer

x0 := x1x1 := CalculaIteracio(x0, a, b)fmentreretorna x1{x1 es la solucio}�un ióA 8.3.4 es mostra la implementa ió de l'opera ió Diferen iaVe tors. A ontinua ió esdesenvolupa el subprograma que fa el àl ul d'una itera ió segons el mètode de Ja obi.

{Pre : DimV ector(x0) = FilesMatriu(a) = ColsMatriu(a) = DimV ector(b) = n∧ ∀i : 0 ≤ i < n : aii 6= 0}fun ió CalculaIteracio(ent x0 : V ector, ent a : Matriu, ent b : V ector) retorna V ector

{Post: x = CalculaIteracio(x0, a, b) ∧ DimV ector(x) = n

∧ ∀i, 0 ≤ i < n, xi =−

Pj<n

j=0,j 6=iaijx0j+bi

aii}fun ió CalculaIteracio(ent x0 : V ector, ent a : Matriu, ent b : V ector) retorna V ectorvar

i, j : enteraij, aii, bi, x0j, x1i, sum : realx1 : V ectorfvar

x1 := CrearV ector(DimV ector(x0))i := 0mentre ¬(i ≥ FilesMatriu(a)) fer

sum := 0j := 0mentre ¬(j ≥ ColsMatriu(a)) fersi j 6= i → aij := ConsMatriu(a, i, j)

x0j := ConsV ector(x0, j)sum := sum− aij ∗ x0j

⊓⊔ j = i →fsij := j + 1fmentre

bi := ConsV ector(b, i)sum := sum + biaii := ConsMatriu(a, i, i)x1i := sum/aiiAssigV ector(x1, i, x1i)i := i + 1

134 CAPÍTOL 8. APLICACIONS AL CÀLCUL NUMÈRICfmentreretorna x1�un ióFinalment es mostra el subprograma que implementa el àl ul d'una itera ió segons elmètode de Gauss-Seidel.fun ió CalculaIteracio(ent x0 : V ector, ent a : Matriu, ent b : V ector) retorna V ectorvari, j : enteraij, aii, bi, x0j, x1i, x1j, sum : realx1 : V ectorfvar

x1 := CrearV ector(DimV ector(x0))i := 0mentre ¬(i ≥ FilesMatriu(a)) fer

sum := 0j := 0mentre ¬(j ≥ i) fer

aij := ConsMatriu(a, i, j)x1j := ConsV ector(x1, j)sum := sum− aij ∗ x1jj := j + 1fmentre

j := i + 1mentre ¬(j ≥ ColsMatriu(a)) feraij := ConsMatriu(a, i, j)x0j := ConsV ector(x0, j)sum := sum− aij ∗ x0jj := j + 1fmentre

bi := ConsV ector(b, i)sum := sum + biaii := ConsMatriu(a, i, i)x1i := sum/aiiAssigV ector(x1, i, x1i)i := i + 1fmentreretorna x1�un ió8.3.4 Altres subprogrames rela ionatsEls subprogrames• Ve tor0• ModulVe tor

8.3. MÈTODES ITERATIUS 135• Diferen iaVe tors• IntFilesVe tores poden dissenyar de dues maneres. La primera és onsiderant-los om opera ions del tipusVe tor, i la segona onsiderant-los a ions independents que usen les opera ions bàsiquesde�nides del tipus Ve tor.A ontinua ió es mostra la implementa ió de Diferèn iaVe tors seguint la segona op ióper tal de pra ti ar més l'ús del tipus Ve tor.

{Pre : DimV ector(a) = DimV ector(b)}fun ió DiferenciaV ectors(ent a, b : V ector) retorna V ector{Post: DiferenciaV ectors(a, b) = a− b}fun ió DiferenciaV ectors(ent a, b : V ector) retorna V ectorvar

c : V ectorn : enterfvar

n := DimV ector(a)c := CrearV ector(n)i := 0mentre ¬(i ≥ n) fer

AssigV ector(c, i, ConsV ector(a, i) − ConsV ector(b, i))i := i + 1fmentreretorna c�un ióEs deixa om a exer i i per a l'estudiant la implementa ió de la resta d'opera ions i tambéla implementa ió seguint l'op ió primera, és a dir, implementant-les om opera ions del tipusVe tor semidinàmi (vegeu l'apèndix A.29 de [7℄).8.3.5 Implementa ions amb gestió dinàmi a de memòriaLes implementa ions vistes als apartats anteriors són adequades per treballar amb variablesde tipus Ve tor estàti . Si es volgués treballar amb ve tors semidinàmi s, s'haurien de poderdestruir totes les variables d'aquest tipus, un op ja no es fessin servir. Les variables lo alsdels subprogrames vistos es poden rear i destruir dins el mateix subprograma. Ara bé, en el as de fun ions que retornen una variable de tipus Ve tor, la fun ió ha de rear una variabled'aquest tipus, però no la pot destruir ja que l'ha de retornar. Per això, al que aquestssubprogrames s'implementin om a ions, de manera que sigui el subprograma que les ridael que reï i destrueixi aquestes variables.A ontinua ió es mostra l'a io SolucioIterativa que rea i destrueix dues variables detipus Ve tor.

136 CAPÍTOL 8. APLICACIONS AL CÀLCUL NUMÈRICa ió SolucioIterativa(ent a : Matriu, ent b : V ector, ent epsilon : realentsor x1 : V ector)varx0, xd : V ectorfvar

x0 := CrearV ector(DimV ector(b))xd := CrearV ector(DimV ector(b))V ector0(x0)CalculaIteracio(x0, a, b, x1)DiferenciaV ectors(x0, x1, xd)mentre ModulV ector(xd)) > epsilon fer

x0 := x1CalculaIteracio(x0, a, b, x1)DiferenciaV ectors(x0, x1, xd)fmentre

{x1 es la solucio}DestruirV ector(x0); DestruirV ector(xd);fa ióLa matriu a i els ve tors b i x1 seran reats i destruits pel subprograma que ridi a l'a io

SolucioIterativa.L'a ió CalculaIteracio no fa servir ap variable lo al de tipus Ve tor i, per tant, la im-plementa ió és la mateixa, tant pel mètode de Ja obi om pel de Gauss-Seidel. A ontinua ióes mostra la orresponent a ió pel mètode de Ja obi.a ió CalculaIteracio(ent x0 : V ector, ent a : Matriu, ent b : V ector,entsor x1 : V ector)vari, j : enteraij, aii, bi, x0j, x1i, sum : realfvar

i := 0mentre ¬(i ≥ FilesMatriu(a)) fersum := 0j := 0mentre ¬(j ≥ ColsMatriu(a)) fersi j 6= i → aij := ConsMatriu(a, i, j)

x0j := ConsV ector(x0, j)sum := sum− aij ∗ x0j

⊓⊔ j = i →fsij := j + 1fmentre

bi := ConsV ector(b, i)sum := sum + biaii := ConsMatriu(a, i, i)x1i := sum/aii

8.3. MÈTODES ITERATIUS 137AssigV ector(x1, i, x1i)i := i + 1fmentrefa ióEl subprograma que al ula la diferèn ia entre dos ve tors també anvia només en el fetque passa a ser una a ió.

138 CAPÍTOL 8. APLICACIONS AL CÀLCUL NUMÈRICa ió DiferenciaV ectors(ent a, b : V ector, entsor d : V ector)varn : enterfvar

n := DimV ector(a)i := 0mentre ¬(i ≥ n) fer

AssigV ector(c, i, ConsV ector(a, i) − ConsV ector(b, i))i := i + 1fmentrefa ió8.4 Bibliogra�a rela ionadaAl llibre [1℄ s'hi expliquen diversos mètodes de àl ul numèri . Alguns d'ells també estanrela ionats amb sistemes d'equa ions lineals om és el àl ul de valors i ve tors propis i elsproblemes d'optimitza ió amb programa ió lineal. Aquest mètodes es poden implementarusant els tipus Ve tor i Matriu vistos. També hi ha altres temes om interpola ió, aproxima iói integra ió numèri a on es presenten mètodes que es poden implementar dissenyant un tipusPolinomi adient.Com a llibres de àl ul numèri també es re omanen els següents [3℄ i [9℄.

Capítol 9Problemes Resolts1. Ús del sòlEnun iatEs vol estudiar l'ús del sòl d'una zona determinada d'un muni ipi. Per fer-ho es disposadel plànol del terme muni ipal, que està dividit en par el.les. Les par el.les es lassi�quensegons l'ús que té el sòl en agrí oles, industrials i urbanes. Es demana al ular el tantper ent d'àrea de sòl d'ús agrí ola, industrial i urbà de la zona estudiada.U

U

AI

A

I

U

Zona a estudiar Parcel.les afectadesFigura 9.1: Exemple de muni ipi i zona.El anal estàndard d'entrada de l'algoritme ontindrà la zona a estudiar seguida d'unaseqüèn ia de par el.les que des riuen el terme muni ipal. La zona és un polígon. Elspolígons són determinats per la seqüèn ia ordenada en sentit horari dels seus vèrtexs ia abada amb la repeti ió del primer. Una par el.la està formada per un identi� adord'ús del sòl ( arà ter A, I o U) i un polígon que delimita l'àrea de la par el.la. Al �nalhi ha una par ela sentinella amb un identi� ador Z. L'algoritme haurà d'es riure pel anal estàndard de sortida tres reals que orresponguin, respe tivament, als tants per ent d'àrea d'ús agrí ola, industrial i urbà de les par el.les ompletament in loses dinsla zona a estudiar.NOTA. Podeu suposar l'existèn ia dels següents pro ediments:139

140 CAPÍTOL 9. PROBLEMES RESOLTS{Pre : cert}fun ió InicialitzaPoligon() retorna Poligon{Post: InicialitzaPoligon() és un polígon buit}{Pre : pol = P}a ió AfegeixPuntPoligon(ent pt : punt, entsor pol : Poligon){Post: pol = P.pt}{Pre : parcela, zona són polígons no buits}fun ió PoligonInterior(ent parcela : Poligon, ent zona : Poligon) retorna booleà{Post: PoligonInterior(parcela, zona) ≡ parcela ⊆ zona}{Pre : cert}fun ió AreaPoligon(ent parcela : Poligon) retorna real{Post: AreaPoligon(parcela)és l'àrea del polígon}Resolu ióDisseny de l'algoritme:algorisme UsdelSolvar

zona, parcela : Poligonarea, areaA, areaI, areaU, areaT : realus : arà terfvar

zona := ObtenirPoligon()areaA := 0.0; areaI := 0.0areaU := 0.0LlegirCaracter(us)parcela := ObtenirPoligon()mentre us 6= `Z' fersi PoligonInterior(parcela, zona) →

area := AreaPoligon(parcela)si us = `A' → areaA := areaA + area⊓⊔ us = `I' → areaI := areaI + area⊓⊔ us = `U' → areaU := areaU + areafsi

⊓⊔ ¬PoligonInterior(parcela, zona) →fsiLlegirCaracter(us)parcela := ObtenirPoligon()fmentre

areaT := areaA + areaI + areaUEscriureReal(areaA/AreaT ∗ 100.)EscriureReal(areaI/AreaT ∗ 100.)EscriureReal(areaU/AreaT ∗ 100.)falgorismePer implementar la fun ió ObtenirPoligon suposarem l'existèn ia del tipus Punt.

141fun ió ObtenirPoligon() retorna Poligonvarpol : Poligonx, y : realpunt, puntini : Puntfvar

pol := InicialitzaPoligon()puntini := LlegirPunt()AfegeixPuntPoligon(puntini, pol)punt := LlegirPunt()mentre ¬PuntsIguals(punt, puntini) fer

AfegeixPuntPoligon(punt, pol)punt := LlegirPunt()fmentreretorna (pol)�un ióA ontinua ió al de�nir el tipus Punt i implementar les opera ions LlegirPunt i Punt-sIguals (vegeu l'apartat 1.4).Se suggereix de�nir també el tipus Poligon i implementar les opera ions indi ades sobreaquest tipus. Les opera ions Ini ialitzaPoligon i AfegeixPuntPoligon són molt senzilles.L'opera ió AreaPoligon es pot implementar apli ant el mètode dels trapezis. L'opera ióPoligonInterior és més ompli ada i al onsultar algun text de geometria omputa io-nal.2. CamíEnun iatÉs el del problema 6.17 de [10℄.Resolu ióEspe i� a ióL'algoritme rep una seqüèn ia de punts (p1p2 . . . p10) del CSE i es riu una determinadapermuta ió d'aquesta seqüèn ia (q1q2 . . . q10) al CSS.

{Pre : CSE = p1p2 . . . p10}algorisme Cami{Post: CSS = q1q2 . . . q10 ∧ EsPermutacio(CSS,CSE) ∧

∀i, j : 1 ≤ i, j ≤ 10 : Distancia(q1, q2) ≤ Distancia(qi, qj) ∧∀i, j : 2 ≤ i < j ≤ 10 : Distancia(qi, qi+1) ≤ Distancia(qi, qj)}

EsPermutacio(CSS,CSE) ≡ (∀i : 1 ≤ i ≤ 10 : (∃j : 1 ≤ j ≤ 10 : qi = pj))La fun ió Distancia és la distàn ia eu lidiana entre dos punts.Disseny de l'algoritme prin ipal

142 CAPÍTOL 9. PROBLEMES RESOLTSSeguirem el mètode suggerit a l'enun iat que proposa primer al ular una matriu dedistàn ies i, després, apli ar el pro ediment indi at al punt 2.Per de al ular la matriu de distàn ies al disposar de tots els punts a memòria i, pertant, aldrà usar el tipus TauPunts. La matriu de distàn ies serà del tipus TauDist.L'algoritme de prin ipi és:algorisme Camivarp : TauPuntsd : TauDistfvar

p := LlegirPunts()d := CalculaDist(p)ObteCami(p, d)falgorismeEspe i� a ió dels subprogrames de l'algoritmeEls tipus TauPunts i TauDist seran respe tivament una taula de Punts i una matriu dedistàn ies.Ara espe i� arem els tres pro ediments:

{Pre : CSE = p1p2 . . . p10 S}fun ió LlegirPunts() retorna TauPunts{Post: LlegirPunts() = (p1, p2, . . . p10) ∧ CSE = S}skip{Pre : p = (p1, p2, . . . p10)}fun ió CalculaDist(ent p : TauPunts) retorna TauDist{Post: CalculaDist() = D ∧ D = (dij), 1 ≤ i, j ≤ 10, i 6= j : dij = Distancia(pi, pj)}skip{Pre : p = (p1, p2, . . . p10) ∧ d = D ∧ CSS = S}a ió ObteCami(ent p : TauPunts, ent d : TauDist){Post: CSS = S q1q2 . . . q10 ∧ EsPermutacio(CSS, p) ∧

∀i, j : 1 ≤ i < j ≤ 10 : Distancia(qi, qi+1) ≤ Distancia(qi, qj)}Diseny dels subprogrames de l'algoritme prin ipal. 2n nivell d'anàlisi des- endentLa fun ió LlegirPunts només ha de llegir la seqüèn ia de punts i guardar-los a la taula.fun ió LlegirPunts() retorna TauPuntsvarv : TauPuntsp : Punti : enterfvar

i := 1mentre ¬(i > 10) fer

143p := LlegirPunt()AssigPunt(v, i, p)i := i + 1fmentreretorna (v)�un ióLa fun ió Cal ulaDist al ularà distàn ies entre tots els punts. Cal tenir en ompte quela fun ió és simètri a i que no té sentit al ular la distàn ia d'un punt a ell mateix.fun ió CalculaDist(ent p : TauPunts) retorna TauDistvard : TauDisti, j : enterfvar

i := 1mentre ¬(i > 9) ferj := i + 1mentre ¬(j > 10) fer

dis := Distancia(ConsPunt(p, i), ConsPunt(p, j))AssigDist(d, i, j, dis)j := j + 1fmentre

i := i + 1fmentreretorna d�un ióL'a ió ObteCami al ula i es riu la seqüèn ia de punts que ompleix l'espe i-� a ió. Per ara teritzar aquesta seqüèn ia hem de seguir l'estratègia que se'ns indi a a l'enun iat.Els dos primers punts de la seqüèn ia seran els que es troben a la distàn ia mínima;els següents els trobarem de manera que adas un sigui, d'entre els que resten, el queés més a prop de l'anterior. Per dur a terme aquesta estratègia, aldrà gestionar unobje te, nt, on hi guardarem informa ió sobre quins punts s'han tra tat i quins no. Laseqüèn ia s'a aba quan ja s'han obtingut els 10 punts, és a dir quan s'hagin tra tat totsels punts.a ió ObteCami(ent p : TauPunts, ent d : TauDist)vari, j, k : enternt : NoTractatsfvar

nt := IniNoTractats()DosMesPropers(d, i, j, nt)EscriuPunt(ConsPunt(p, i))mentre QuedinNoTractats(nt) fer

EscriuPunt(ConsPunt(p, j)i := j

144 CAPÍTOL 9. PROBLEMES RESOLTSMesProper(d, i, j, nt)fmentre

EscriuPunt(ConsPunt(p, j))fa ióEspe i� a ió i disseny dels subprogrames d'ObteCami. 3r nivell de l'anàlisides endentEspe i� a ió{Pre : d = D ∧ nt = N = {1, . . . .10}}a ió DosMesPropers(ent d : TauDist, sor i, j : enter, entsor nt : NoTractats){Post: i 6= j ∧ ∀k, l : (1 ≤ k, l ≤ 10 ∧ k 6= l) : dij ≤ dkl ∧ nt = N − {i, j}}skip{Pre : d = D ∧ nt = N ∧ i 6∈ N}a ió MesProper(ent d : TauDist, ent i : enter, sor j : enter,entsor nt : NoTractats){Post: j ∈ N ∧ ∀k : k ∈ N : dij ≤ dik ∧ nt = N − {j}}}DissenyAquestes a ions s'implementaran fent servir el tipus NoTra tats amb les opera ions Ini-NoTra tants, que ini ialitza l'estru tura, QuedinNoTra tats, que indi a si queden puntsque en ara no s'han tra tat, Tra tat, que indi a si un determinat punt s'ha tra tat o no,i Esborrar, que esborra un punt del onjunt de NoTra tats (és a dir, passa a ser un puntja tra tat). Aquestes opera ions s'espe i�quen i implementen al �nal.a ió DosMesPropers(ent d : TauDist, sor imin, jmin : enter,entsor nt : NoTractats)var

i, j : enterdis, dismin : realfvar

dismin := ConsDist(d, 1, 2)imin := 1; jmin := 2i := 1mentre ¬(i > 9) fer

j := i + 1mentre ¬(j > 10) ferdis := ConsDist(d, i, j)si dis < dismin → dismin := dis

imin := i; jmin := j⊓⊔ dis >= dismin →fsij := j + 1fmentre

i := i + 1fmentre

145Esborrar(nt, imin); Esborrar(nt, jmin)fa ióskipa ió MesProper(ent d : TauDist, ent i : enter, sor jmin : enter,entsor nt : NoTractats)var

j : enterdis, dismin : realfvar

dismin := INFINITjmin := 0j := 1mentre ¬(j > 10) fersi Tractat(nt, j) →⊓⊔ ¬Tractat(nt, j) → dis := ConsDist(d, i, j)si dis < dismin → dismin := dis

jmin := j⊓⊔ dis >= dismin →fsifsi

j := j + 1fmentreEsborrar(nt, jmin)fa ióCal notar que aquestes dues a ions, quan riden ConsDist, mai onsulten la distàn iad'un punt a ell mateix; és a dir, sempre es ompleix que i 6= j. La onstant INFINIT ésun valor su� ientment gran.En el disseny de tots aquests algoritmes han sortit diversos tipus amb les seves opera i-ons.Espe i� a ió i diseny de les opera ions del tipus TauPuntEl tipus TauPunt i les opera ions ConsPunt i AssigPunt es poden implementar de formaanàloga al tipus Ve tor vist a l'apartat 6.1.2. El tipus pot ser un ve tor estàti ambdimensió �xa (sempre és 10, tal om diu l'enun iat). En aquest as on ret, no all'opera ió de rear el ve tor.tipusTauPunt = taula [1 . . 10] de Puntftipusskipfun ió ConsPunt(ent v : TauPunt, ent i : enter) retorna Puntretorna v[i]�un ióskipa ió AssigPunt(entsor v : TauPunt, ent i : enter, ent r : Punt)

146 CAPÍTOL 9. PROBLEMES RESOLTSv[i] := rfa ióEspe i� a ió i disseny de les opera ions del tipus PuntEspe i� a ió

{Pre : CSE = x y S}fun ió LlegirPunt() retorna Punt{Post: LlegirPunt() = (x, y) ∧ CSE = S}skip{Pre : CSS = α}}a ió EscriuPunt(ent p : Punt){Post: CSS = α.p}skip{Pre : }fun ió Distancia(ent , p1, p2 : Punt) retorna real{Post: Distancia(p1, p2) = DistanciaEuclidea(p1, p2)}La implementa ió es pot veure a l'apartat 1.4 ex epte la de l'a ió Es riuPunt que esdeixa om a exer i i.Espe i� a ió i disseny de les opera ions del tipus TauDistEspe i� a ió{Pre : i 6= j ∧ dist = Distancia(pi, pj)}a ió AssigDist(entsor d : TauDist, ent i, j : enter, ent dist : real){Post: dij = dist ∧ dji = dist}skip{Pre : i 6= j ∧ dij = Distancia(pi, pj)}fun ió ConsDist(ent d : TauDist, ent i, j : enter) retorna real{Post: ConsDist(d, i, j) = Distancia(pi, pj)}L'espe i� a ió, om es pot veure, és similar a les opera ions d'assigna ió i onsulta d'unamatriu.Disseny 1En aquest disseny usem una taula de dues dimensions per guardar les distàn ies. Seràuna matriu estàti a de dimensió �xa. En aquesta taula tots els omponents, ex epteels de la diagonal prin ipal, tindran un valor asso iat. La matriu serà, evidentment,simètri a.

147tipus TauDist = taula [1..10][1..10] de real ftipusa ió AssigDist(entsor d : TauDist, ent i, j : enter, ent dist : real)d[i, j] := dist; d[j, i] := distfa iófun ió ConsDist(ent d : TauDist, ent i, j : enter) retorna realretorna (d[i, j])�un ióAquesta implementa ió és pra ti ament igual que la implementa ió M1 vista per al tipusMatriu a l'apartat 6.2.3. Com que la dimensió és �xa, 10× 10, tampo al una opera ióde rea ió. Cal tenir en ompte que la matriu és simètri a i que sempre que s'hi posa unvalor, al posar també el simètri . A més, els elements de la diagonal no es faran servir:ni s'ini ialitzaran ni es onsultaran.Disseny 2Amb aquest disseny es pretén estalviar memòria; les distàn ies es guardaran en unataula unidimensional i només un op adas una. En llo de les 100 posi ions que esne essiten al disseny anterior, en aldran (10 ∗ 10 − 10)/2 = 45, que és la mida d'undels dos triangles de la matriu. La distàn ia entre els punts pi i pj serà al omponent

k = (i− 1) ∗ 10 + j − 1.Aquest segon disseny estaria més justi� at si el nombre de punts fos molt més gran que10.tipus TauDist = taula [1..45] de real ftipusa ió AssigDist(entsor d : MatDist, ent i, j : enter, ent dist : real)var k : enter fvarsi i < j → k := (i− 1) ∗ 10 + j − 1⊓⊔ i > j → k := (j − 1) ∗ 10 + i− 1fsid[k] := distfa iófun ió ConsDist(ent d : MatDist, ent i, j : enter) retorna realvar

k : enterdist : realfvarsi i < j → k := (i− 1) ∗ 10 + j − 1

⊓⊔ i > j → k := (j − 1) ∗ 10 + i− 1fsidist := d[k]retorna (dist)�un ió

148 CAPÍTOL 9. PROBLEMES RESOLTSEspe i� a ió i disseny de les opera ions del tipus NoTra tatsEspe i� a ió{Pre : nt = ∅}fun ió IniNoTractats() retorna NoTractats{Post: nt = [1, . . . 10]}skip{Pre : ert}fun ió QuedinNoTractats(ent nt : NoTractats) retorna booleà{Post: QuedinNoTractats(nt) ≡ nt 6= ∅}skip{Pre : }fun ió Tractat(ent nt : NoTractats, ent i : enter) retorna booleà{Post: Tractat(nt, i) ≡ (i 6∈ nt)}skip{Pre : nt = N}a ió Esborrar(entsor nt : NoTractats, ent i : enter){Post: nt = N − {i}}Implementa ióImplementarem el tipus NoTra tats mitjançant una taula de booleans.tipus NoTractats = taula [1..10] de booleà ftipusfun ió IniNoTractats() retorna NoTractatsvar

nt : NoTractatsi : enterfvar

i := 1mentre ¬(i > 10) fernt[i] := erti := i + 1fmentreretorna (nt)�un iófun ió QuedinNoTractats(ent nt : NoTractats) retorna booleàvari : entertrobat : booleàfvar

i := 1; trobat := falsmentre i ≤ 10 ∧ ¬trobat fertrobat := nt[i]i := i + 1fmentreretorna (trobat)

149�un iófun ió Tractat(ent nt : NoTractats, ent i : enter) retorna booleàretorna (¬nt[i])�un ióa ió Esborrar(entsor nt : NoTractats, ent i : enter)nt[i] := falsfa ió3. El nombre misteriós.Enun iatÉs el problema 6.14 del llibre [10℄.Resolu ióSeqüèn ia: El primer element el llegim, la resta d'elements s'obtenen amb la fun ió

dif . La seqüèn ia s'a aba quan s'arriba a un element k tal que k = dif(k). La fun iódiferèn ia s'apli a usant les fun ions gran i petit que també aldrà desenvolupar. Calgenerar tota la seqüèn ia esmentada ja que ens interessa el darrer element.1r nivell d'anàlisi des endent:{Pre : CSE = n ∧ n té 4 xifres totes diferents}algorisme NombreMisterios{Post: CSS = k ∧ k = 6174}skipalgorisme NombreMisteriosvar

n, k, l : enterfvarLlegirEnter(n)k := nl := dif(k)mentre k 6= l fer

k := ll := dif(k)fmentre

EscriureEnter(k)falgorisme2n nivell anàlisi des endent(Només hi ha la fun ió dif):{Pre : a > 0 ∧ té 4 xifres totes diferents}fun ió Dif(ent a : enter) retorna enter{Post: dif(a) > 0 ∧ dif(a) té 4 xifres totes diferents}skipfun ió Dif(ent a : enter) retorna entervar

x0, x1, x2, x3 : enter

150 CAPÍTOL 9. PROBLEMES RESOLTSfvarObteXifres(a, x3, x2, x1, x0)retorna gran(x3, x2, x1, x0) − petit(x3, x2, x1, x0)�un ió3r nivell anàlisi des endent:

{Pre : a > 0 ∧ a té 4 xifres totes diferents}a ió ObteXifres(ent a : enter, sor x3, x2, x1, x0 : enter){Post: a = x3 ∗ 103 + x2 ∗ 102 + x1 ∗ 10 + x0 ∧ 0 ≤ x3 ≤ 9 ∧ 0

≤ x2 ≤ 9 ∧0 ≤ x1 ≤ 9 ∧ 0 ≤ x0 ≤ 9 ∧ x3, x2, x1, x0 són diferents}skipa ió ObteXifres(ent a : enter, sor x3, x2, x1, x0 : enter)

x0 := a mod 10aux := a div 10x1 := aux mod 10aux := aux div 10x2 := aux mod 10x3 := aux div 10fa ióskip

{Pre : 0 ≤ x3 ≤ 9 ∧ 0 ≤ x2 ≤ 9 ∧0 ≤ x1 ≤ 9 ∧ 0 ≤ x0 ≤ 9 ∧ x3, x2, x1, x0 són diferents}fun ió Gran(x3, x2, x1, x0) retorna enter

{Post: (y3, y2, y1, y0) = EsPermutacio(x3, x2, x1, x0) ∧ y3 > y2 ∧ y2 > y1∧ y1 > y0 ∧ Gran(x3, x2, x1, x0) = y3 ∗ 103 + y2 ∗ 102 + y1 ∗ 10 + y0}Implementa ió de Gran La implementa ió requereix ordenar les 4 xifres. Ordenardos o tres valors es pot fer dire tament però a partir de 4 valors és més òmode usaruna taula. Per tant utilitzarem una taula de 4 elements que ordenarem amb qualsevolmètode d'ordena ió:tipus

T4 : taula [0 . . . 3] de enterftipusfun ió Gran(x3, x2, x1, x0) retorna entervartx : T4fvar

PasATaula(x3, x2, x1, x0, tx)OrdenaGranAPetit(tx)retorna (valor(tx))�un ióL'espe i� a ió i implementa ió de Petit és anàloga a la de Gran.4t nivell d'anàlisi des endent

151{Pre : x3, x2, x1, x0 són diferents ∧ 0 ≤ x3 ≤ 9 ∧ 0 ≤ x2 ≤ 9 ∧

0 ≤ x1 ≤ 9 ∧ 0 ≤ x0 ≤ 9}a ió PasATaula(ent x3, x2, x1, x0 : enter, sor tx : T4){Post: tx0 = x0 ∧ tx1 = x1 ∧ tx2 = x2 ∧ tx3 = x3}skip{Pre : ∀i : 0 ≤ i ≤ 3 : (0 ≤ txi ≤ 9 ∧ txi són diferents)}a ió OrdenaGranAPetit(entsor tx : T4){Post: tx3 > tx2 ∧ tx2 > tx1 ∧ tx1 > tx0}skip{Pre : ∀i : 0 ≤ i ≤ 3 : (0 ≤ txi ≤ 9}fun ió V alor(ent tx : T4) retorna enter{Post: V alor(tx) = tx3 ∗ 103 + tx2 ∗ 102 + tx1 ∗ 10 + tx0}Les implementa ions es deixen om exer i i.4. IVAEnun iatDonat un �txer de nom Preus on apareix una seqüèn ia de tuples formades per un odide produ te i un preu, obteniu un altre �txer PreusIva on aparegui la mateixa seqüèn iaamb els preus augmentats amb un IVA que es llegirà pel CSE. La seqüèn ia a aba ambuna tupla sentinella on el odi és 0.Resolu ió{Pre : Preus = c1p1c2p2 . . . 0ps ∧ CSE = iva}algorisme AplicaIV A{Post: PreusIva = c1ps1c2ps2 . . . 0 ∧ ∀i : psi = pi ∗ (1. + iva/100.)}skipalgorisme AplicaIV Avar

fe, fs : FSTiva, preuc, preus : realcodi : enterfvar

LlegirReal(iva)fe := ObrirFST (lecturaFST, �Preus�)fs := ObrirFST (escripturaFST, �PreusIva�)LlegirProducteFST (fe, codi, preuc)mentre codi 6= 0 fer

preus := preuc ∗ (1. + iva/100.)EscriureProducteFST (fs, codi, preus)LlegirProducteFST (fe, codi, preuc)fmentre

TancarFST (fe); TancarFST (fs)falgorismea ió LlegirProducteFST (entsor f : FST, sor codi : enter, sor preu : real)

152 CAPÍTOL 9. PROBLEMES RESOLTSLlegirEnterFST (f, codi)LlegirRealFST (f, preu)fa ióskipa ió EscriureProducteFST (entsor f : FST, sor codi : enter, sor preu : real)EscriureEnterFST (f, codi)EscriureRealFST (f, preu)fa ió5. Avalua ió d'assignaturesEnun iatDissenyeu un algorisme que al uli la nota �nal dels alumnes d'una assignatura de l'ET-SEIB. La nota �nal es al ula segons la fórmula

n = r ∗ nef + (1− r) ∗ nac

nac = q ∗ nl + (1− q) ∗max(nc, nef)Pel CSE es rep una seqüèn ia formada pel odi d'una assignatura (enter) i una seqüèn iade 4-tuples onstituïdes per un nom d'alumne (nom), una nota d'examen �nal (nef), unanota de laboratori (nl) i una nota de urs (n ). La seqüèn ia a aba amb una 4-tuplasentinella on el nom de l'alumne és "zzz"(l'alumne més dormilega). Els noms són adenesde arà ters i les notes són reals.CSE = odi_assignatura nom1 nef1 nl1 n 1 nom2 nef2 nl2 n 2 ... "zzz"nefs nls ntsEl �txer seqüen ial de text Qretseib onté una seqüèn ia de ternes formada per un odid'assignatura (enter), un paràmetre q (real) i un paràmetre r (real) que denoten elsparàmetres q i r de la fórmula de àl ul de la nota �nal. La seqüèn ia a aba amb unaterna on el odi d'assignatura és -1.qretseib.txt = odi_assig1 q1 r1 odi_assig2 q2 r2 ... -1 qM rMS'ha de produir al CSS una seqüèn ia formada pel odi de l'assignatura seguit d'unaseqüèn ia de parells onstituïts per un nom d'alumne i la seva nota �nal de l'assignatura.CSS = odi_assignatura nom1 n1 nom2 n2 ...Resolu ióalgorisme Avaluaciovarnom : tParaulacodi : enternef, nl, nt, nf, nac, q, r : realfvar

LlegirEnter(codi)EscriureEnter(codi)

153ObteCoeficients(codi, q, r)LlegirAvaluacio(nom,nef, nl, nc)mentre ComparaParaules(nom, �ZZZ�) 6= 0 fer

max := ncsi nef > nc → nc := nef⊓⊔ nef ≤ nc →fsinac := q ∗ nl + (1− q) ∗ ncnf := r ∗ nef + (1− r) ∗ nacEscriureNota(nom,nf)LlegirAvaluacio(nom,nef, nl, nc)fmentrefalgorisme

{Pre : ∃ codi1 ∈ Qretseib | codi1 = codi}a ió ObteCoeficients(ent codi : enter, sor q, r : real)varf : FSTcodi1 : entertrobat : booleàfvar

f := ObrirFST (lecturaFST,Qretseib)LlegirAssigFST (f, codi1, q, r)trobat := falsmentre ¬trobat fersi codi = codi1 → trobat := ert⊓⊔ codi 6= codi1 → LlegirAssigFST (f, codi1, q, r)fsifmentre

TancarFST (f)fa ióa ió LlegirAssigFST (entsor f : FST, sor codi1 : enter, sor q, r : real)LlegirEnterFST (f, codi1)LlegirRealFST (f, q)LlegirRealFST (f, r)fa ió6. Comar aEnun iatUn �txer anomenat � omar a� onté un determinat nombre de registres orresponentsa persones. A ada registre hi onsta el nom, l'edat, el sexe i el sou d'una persona. El

154 CAPÍTOL 9. PROBLEMES RESOLTS�txer a aba amb un registre sentinella on el nom és �zzz�. Dissenyeu un algorisme quees rigui pel CSS el sou promig en la omar a de:• els homes menors de 45 anys,• les dones menors de 45 anys,• els homes de 45 anys o més,• les dones de 45 anys o més.Resolu ió

{Pre : � omar a� = nom1, edat1, sexe1, sou1, . . . , zzz, edatn, sexen, soun}algorisme Estadistiques{Post: CSS = phj, phg, pdj, pdg ∧

phj =∑nhj

i=1 soui/nhj ∧ ∀i : 1 ≤ i ≤ nhj : (sexe = h ∧ edat < 45) ∧nhj és el nombre d'homes menors de 45 anys ∧phg =

∑nhgi=1 soui/nhg ∧ ∀i : 1 ≤ i ≤ nhg : (sexe = h ∧ edat ≥ 45) ∧

nhg és el nombre d'homes de 45 anys o més ∧pdj =

∑ndji=1 soui/ndj ∧ ∀i : 1 ≤ i ≤ ndj : (sexe = d ∧ edat < 45) ∧

ndj és el nombre de dones menors de 45 anys ∧pdg =

∑ndgi=1 soui/ndg ∧ ∀i : 1 ≤ i ≤ ndg : (sexe = d ∧ edat ≥ 45) ∧

ndg és el nombre de dones de 45 anys o més}algorisme Estadistiquesvarf : FSTnom : paraulaedat : entersexe : arà tersou : realphj, phg, pdj, pdg : realnhj, nhg, ndj, ndg : enterfvar

nhj := 0; nhg := 0; ndj := 0; ndg := 0phj := 0; phg := 0; pdj := 0; pdg := 0f := ObrirFST (lectura, � omar a�)LlegirRegistreFST (f, nom, edat, sexe, sou)mentre ¬ParaulesIguals(nom, �zzz�) fersi edat < 45 ∧ sexe = h → nhj := nhj + 1; phj := phj + sou⊓⊔ edat ≥ 45 ∧ sexe = h → nhg := nhg + 1; phg := phg + sou⊓⊔ edat < 45 ∧ sexe = d → ndj := ndj + 1; pdj := pdj + sou⊓⊔ edat ≥ 45 ∧ sexe = d → ndg := ndg + 1; pdg := pdg + soufsiLlegirRegistreFST (f, nom, edat, sexe, sou)

155fmentrephj := phj/Real(nhj); phg := phg/Real(nhg)pdj := pdj/Real(ndj); pdg := pdg/Real(ndg)EscriureReal(phj)EscriureReal(phg)EscriureReal(pdj)EscriureReal(pdg)falgorismea ió LlegirRegistreFST (entsor f : FST, sor nom : paraula, sor edat : enter, sorsexe : arà ter, sor sou : real)LlegirParaulaFST (f, nom)LlegirEnterFST (f, edat)LlegirCaracterFST (f, sexe)LlegirRealFST (f, sou)fa ióNota: L'espe i� a ió i la implementa ió de la fun ió ParaulesIguals es poden trobar alapartat 2.5.7. Capgirament.Enun iatDissenyeu un algoritme que apgiri una seqüèn ia d'enters positius que ve donada pelCSE i s'a aba en el 0. Cal fer servir l'espe i� a ió del tipus PilaEnter que es dóna totseguit:Espe i� a ió tipus PilaEnter

{Pre : ert}a ió CrearP ilaEnter(sor p : PilaEnter){Post: p = ∅}{Pre : p = P}a ió EmpilarEnter(entsor p : PilaEnter, ent e : enter){Post: p = e.P}{Pre : p = e.P}fun ió CimPilaEnter(ent p : PilaEnter) retorna enter{Post: e = CimPilaEnter(p) ∧ p = e.P}{Pre : p = e.P}a ió DesempilarEnter(entsor p : PilaEnter){Post: p = P}{Pre : ert}fun ió BuidaP ilaEnter(ent p : PilaEnter) retorna booleà{Post: BuidaP ilaEnter(p) ≡ p = ∅}Resolu ió

156 CAPÍTOL 9. PROBLEMES RESOLTS{Pre : CSE = e1 e2 . . . en 0 ∧ ei > 0}algorisme Capgirar{Post: CSS = en en−1 . . . e2 e1}skipalgorismevar

e : enterp : PilaEnterfvar

CrearP ilaEnter(p)LlegirEnter(e)mentre e 6= 0 fer

EmpilarEnter(p, e)LlegirEnter(e)fmentrementre ¬BuidaP ilaEnter(p) ferEscriureEnter(CimPilaEnter(p))DesempilarEnter(p)fmentrefalgorisme8. Memòria dinàmi aEnun iatEs riviu un programa en C que fa i la reserva de memòria per una estru tura amb na�les de manera que per ada �la es reservi un nombre d'elements que s'indiquen als omponents d'una taula d'enters donada.Resolu ió#in lude�entsort.h�..............float **telem;int i, na, nb;na = LLegirEnter();telem = (float **) mallo (na * sizeof (float *));i = 0;while (i != na){ na = LLegirEnter();telem[i℄ = (float *) mallo (nb * sizeof (float));i = i + 1;}...............

Capítol 10Enun iats de problemes1. In rement.Pel CEE ens donen un text format per una seqüèn ia de arà ters a abada en un punt '.'dins la que hi ha una subseqüèn ia de arà ters numèri s que representen una quantitat.Es demana rees riure el text pel CSS de forma que la quantitat aparegui in rementada enun 15%. Es pot omençar suposant que la quantitat ini ial és entera i que la al uladaes pot arrodonir a enter i després es pot generalitzar l'algorisme al as de quantitatsreals.2. Longitud de paraules.Pel CEE ens donen un text format per una seqüèn ia de arà ters a abada en un punt'.' Es pot suposar que el text té més d'una paraula. Dissenyeu un algorisme que al ulii es rigui la longitud de la paraula més urta que hi ha darrera de la més llarga.3. Cir uits.Un fabri ant de ir uits impresos els dissenya de tal manera que ada tros de ouresobre el ir uit està format per un onjunt de segments els extrems dels quals tenen oordenades enteres. Cada ir uit té un nombre de segments menor que un ert nombre�x. No és infreqüent que errors en les espe i� a ions d'aquests segments introdueixin onta tes no desitjats o deixin trossos sense onne tar. Per fa ilitar la veri� a ió d'und'aquests dissenys al un programa que llisti les parelles de segments que s'intersequen�en un punt diferent d'un extrem� i els onjunts de vèrtexs que estan onne tats entresi. Es riviu un algorisme que llegeixi un seguit de segments (de�nits per les oordenadesx i y dels dos extrems) a abat per un segment nul (per al qual els dos extrems tenen lesmateixes oordenades), i produeixi om a resultat dos llistats:(a) Un que indiqui quines parelles de segments s'intersequen en un punt diferent d'unextrem.(b) Un altre que llisti els grups de vèrtexs que queden onne tats entre si. En aquestsegon llistat no s'han de tenir en ompte les onnexions que resulten de segmentsque s'intersequen en punts diferents dels extrems.Per exemple, si el programa llegeix la llista de segments157

158 CAPÍTOL 10. ENUNCIATS DE PROBLEMES(5, 10)

(6, 16)

15, 10)

(22, 18)

(25, 6)

(12, 5)Figura 10.1: Exemple de ir uit.22 18 15 10 6 16 12 5 15 10 5 10 25 6 15 10 8 9 8 9que orrespon al ir uit de la �gura 10.1, el programa ha de produir els següents resultats:Interse ions:

(6, 16) - (12, 5) i (5, 10) - (15, 10)Grups inter onne tats:{(6, 16), (12, 5)}

{(5, 10), (15, 10), (22, 18), (25, 6)}Nota: A la llista de vèrtexs que onne ten entre si, ada vèrtex hi hauria d'aparèixer unsol op.4. Rota ions.Dissenyeu un subprograma que, donades dues seqüèn ies d'enters en dues taules, indiquisi una és una rota ió de l'altre (vegeu problema 6.31 de [10℄). Podem suposar donadesles següents de�ni ions onstN : enter = 50f onsttipusTaulaE = tupla

melem : TauEntern : enterftupla

TauEnter = taula [0 . .N-1] de enterftipus5. Cir umferèn ies Cir uns ritesEn un FST anomenat �Cir umferèn ies� hi ha un parell de ir umferèn ies a ada regis-tre. Una ir umferèn ia ve donada per tres reals (les oordenades x i y del entre i el

159radi). Al �nal del �txer hi ha un registre sentinella amb dues ir umferèn ies de radi0. Ens asseguren que les dues ir umferèn ies de ada parell són disjuntes. Dissenyeuun algorisme que, a partir del �txer Cir umferèn ies, en reï un altre anomenat �Cir- ums rites� on hi hagi el entre i radi de la ir umferèn ia ir ums rita a ada parell i ladiferèn ia d'àrees entre la ir umferèn ia ir ums rita i les dues a les que irs ums riu.Es disposa del següent pro ediment:{Pre : cert}fun ió CircumfCircums(ent c1, c2 : Circumferencia) retorna Circumferencia{Post: CircumfCircums(c1, c2) = c3 ∧ c3 és la ir umferèn ia ir ums rita a

c1 i c2}Es re omana treballar amb opera ions del tipus Circumferencia i, a ontinua ió, de�niraquest tipus i implementar-ne les opera ions.6. Interse ió entre �txers.Donats dos �txers de paraules, Text1 i Text2, ordenats, reeu un ter er �txer, Text3,que ontingui tots els registres que són a la vegada a Text1 i a Text2. Es pot suposar l'e-xistèn ia dels pro ediments LlegirParaulaFST, Es riureParaulaFST i ComparaParaulesespe i� ats a l'apartat 3.6.2.7. Diferèn ia entre �txers.Donats dos �txers de paraules, Text1 i Text2, ordenats, reeu un ter er �txer, Text3,que ontingui tots els registres de Text1 ex epte els que també són a Text2. Es potsuposar l'existèn ia dels pro ediments LlegirParaulaFST, Es riureParaulaFST i Com-paraParaules espe i� ats l'apartat 3.6.2.8. Notes.Donada una seqüèn ia amb les notes �nals dels estudiants d'una assignatura de l'ET-SEIB, es vol al ular la nota arrodonida al mig punt més proper. També es vol sele ionarels estudiants que tinguin notes �nals entre 4.5 i 5.Pel CSE es rep una seqüèn ia amb un odi d'assignatura seguit d'una seqüèn ia deparells formats per un nom d'estudiant i una nota �nal. L'estudiant dormilega torna aser el sentinella.CSE = odi_assignatura nom1 n1 nom2 n2 ... "zzz"nN El CSS haurà de ontenir unaseqüèn ia amb el mateix format que el CSE, però en llo de la nota �nal, hi hauràd'aparèixer la nota �nal arrodonida segons la fórmula següent.EnterReal(truncar(2.0 ∗ n + 0.5))/2.0El �txer Perpo haurà de ontenir una seqüèn ia en apçalada pel odi d'assig-natura iseguida d'una seqüèn ia de parelles formades per un nom d'estudiant i una nota �nalque ha d'estar entre el 4.5 i el 5.Dissenyeu l'algorisme orresponent.

160 CAPÍTOL 10. ENUNCIATS DE PROBLEMES9. Problema del CupraboEls supermer ats Cuprabo volen un programa que al uli la fa tura ió per se ions(alimenta ió, neteja, llibreria, et .) a partir dels produ tes detallats. Aquest problematé om a obje tiu dissenyar (implementar) un programa que al uli totals per se ions orresponents a diferents on eptes de fa tura ió, donades les partides de despeses ambel nom del produ te on ret per a ada ompra. El programa rebrà pel anal estàndardd'entrada (CSE) una seqüèn ia de parells separats per salts de línia i a abada amb unparell espe ial. Cada parell, tret del parell espe ial, ontindrà:• Un identi� ador del on epte, format per lletres majús ules, minús ules, dígits,guionets, et .• Un real, eventualment sense part fra ionària.Els omponents de ada parell estaran separats per un o més blan s. El parell espe ialnomés té l'identi� ador de on epte #. Per exemple, si la seqüèn ia d'entrada éspatates 3.750perfum 4.000detergent 350perfum 900pa 240revista 500vi 600patates 250pa 200...#s'hauria de produir a la sortida (CSS) alguna osa semblant a:alimenta ió 5.040neteja 5.250papereria 500...Per exemple, per al ular el total de fa tura ió de neteja fem

4.000 perfum +

350 detergent +

900 perfum = 5250 pessetesEl programa haurà d'obtenir les dades sobre les se ions llegint el ontingut del �txer detext anomenat Se ions. Aquest �txer onté parells separats per salts de línia i a abatsper un parell espe ial, on ada parell indi a a quina se ió pertany ada produ te. Perexemple:

161patates alimenta ióperfum netejadetergent netejallibre papereriapa alimenta iórevista papereriavi alimenta ió...#Podeu suposar el següent:(a) Que no hi ha més de 300 arti les diferents.(b) Que no hi ha més de 50 se ions diferentes.( ) Que la longitud dels identi� adors d'arti le i de se ió no és superior a 15.(d) Que tot arti le que es fa tura es pot trobar a l'estru tura de orrespondèn ia arti le-se ió.10. Hisenda som tots.La delega ió d'Hisenda de Bar elona ens ha enviat dues intes per fer-ne el tra tamentinformàti :El �txer ontingut a la primera inta, anomenat Propietaris, onté tants registres ompisos hi ha a Bar elona. Cada registre és:propietari = tupla

DNI : enternom : taula [1...30] de arà terpis : taula [1...30] de arà terus : arà terftuplaL'ús pot ser de tres tipus: habitatge habitual (H), pis de lloguer (L) o pis deshabitat(D).El �txer ontingut a la segona inta, anomenat Llogaters, onté tants registres om pisosllogats hi ha a Bar elona. Cada registre és:

llogater = tuplaDNIprop : enterDNIllog : enterpis : taula [1...30] de arà terftuplaEls registres dels dos �txers estan ordenats pel DNI del propietari, i l'últim registre ésel que té DNI = 0. Els propietaris tenen, om a molt, 20 pisos.Dissenyeu un algorisme que tregui la següent informa ió:

162 CAPÍTOL 10. ENUNCIATS DE PROBLEMES(a) Llistat dels propietaris de més d'un pis, indi ant el nombre de pisos de què sónpropietaris.(b) Llistat de propietaris que tenen pisos llogats, però que no han de larat om a talso bé ni tan sols els han de larat.11. Capses.Es disposa d'un �txer seqüen ial Capses on hi ha una seqüèn ia de parells de apses(re tangles amb els ostats paral.lels als eixos oordenats). Cada apsa queda determi-nada per dos vèrtexs, l'inferior esquerre amb les oordenades (x, y) mínimes i el superiordret amb les oordenades (x, y) màximes. En aquesta seqüèn ia hi ha, om a mínim,dues apses. La seqüèn ia a aba amb un parell de apses sentinella que tenen tots dosvèrtexs oin idents amb el punt (0., 0.).Capses = xm1, ym1, xM1, yM1, xm2, ym2, xM2, yM2, . . . xmn, ymn, xMn, yMn,0., 0., 0., 0., 0., 0., 0., 0.Per a ada parella de apses es vol al ular la apsa interse ió i la apsa unió. Lesprimeres s'han d'es riure en un �txer seqüen ial que es dirà Interse io i les segones, enun que es dirà Unio. Aquests dos �txers tindran el mateix format que el �txer Capses.Els dos vèrtexs d'una apsa C = A ∩B s'obtenen:xCm = max(xAm, xBm, yCm = max(yAm, yBm xCM = min(xAM , xBM , yCM = min(yAM , yBMEls dos vèrtexs d'una apsa C = A ∪B s'obtenen:xCm = min(xAm, xBm, yCm = min(yAm, yBm xCM = max(xAM , xBM , yCM = max(yAM , yBMDissenyeu l' algorisme orresponent.12. Problema del MagatzemUn magatzem informatitzat guarda la següent informa ió per ada produ te: nom ( a-dena de arà ters), odi_llo (real), nombre_unitats (enter), nmin_unitats (enter), IVA(real).El odi_llo està format per nom_magatzem ( ara ter), num_estanteria (enter), inum_prestatge (enter). Nombre d'unitats indi a les existèn ies del produ te i nmin_unitatsindi a el nombre mínim d'unitats que hi ha d'haver al magatzem per tal de garantir elservei.Quan es serveix una determinada quantitat d'un produ te, es fa un albarà, en el que hi onsta el nom del produ te i el nombre d'unitats servides (per simpli� ar es suposa quea ada albarà només hi �gura un produ te).Es vol implementar una apli a ió que pro essi un onjunt d'albarans.Per ada albarà s'haurà de treure la orresponent fa tura i restar del magatzem laquantitat del produ te servit. A la fa tura hi ha de onstar la següent informa ió: nomdel produ te, preu, nombre d'unitats servides, IVA i total a pagar.Un op pro essats tots els albarans, al treure una llista de tots els produ tes, el nombred'unitats dels quals hagi quedat per sota del llindar mínim estalert, és a dir, aquells quenombre_unitats < nmin_unitats. Cal es riure el nom del produ te, el odi_llo i lesquantitats nombre_unitats i nmin_unitats.

163La informa ió del magatzem es troba en un FST anomenat �Magatzem� i amb un re-gistre sentinella on el nom del produ te és �ZZZ�. Els albarans són en un FST de nom�Albarans�. Els �txers �Magatzem� i �Albarans� estan ordenats per nom de produ te.Les fa tures s'han d'anar es rivint en el �txer �Fa tures� i el llistat de produ tes sotamínims al �txer �Sto ks�. A més al obtenir un nou �txer amb el magatxem a tualitzatque s'anomenarà �Magatzemnou�.Dissenyeu un algorisme que a partir dels �txers �Magatzem� i �Albarans� obtingui els�txers �Fa tures�, �Sto ks� i �Magatzemnou� segons les espe i� a ions indi ades.13. Complexitat: er a binària.Cal ula la omplexitat del següent algorisme (l'algorisme de er a binària). Aquestalgorisme donada una taula de n enters A, la qual està ordenada de forma reixent idonat un enter x, ens retorna 0 si no hi ha ap valor de la taula igual a x i ens retornam si la omponent A[m] = x.fun ió Cer aBinaria ( ent A: tau_ent, ent n: enter, ent x: enter) retorna entervarl, u, m: entertrobat: booleafvarl := 1u := ntrobat := falsmentre l ≤ u i no trobat ferm := (l +u ) div 2siA[m℄ < x → l:= m + 1A[m℄ > x → u:= m - 1A[m℄ = x → trobat := ertfsifmentresi trobat → retorna mno trobat → retorna 0fsi�un io14. Complexitat: avalua ió d'un polinomiCal uleu el temps de ost i l'ordre de omplexitat del següent algorisme per avaluarun polinomi i ompareu-lo amb els algorismes vistos al apítol 4. Aquest algorisme és

164 CAPÍTOL 10. ENUNCIATS DE PROBLEMESuna versió diferent de la usual en la que es genera la seqüèn ia de les potèn ies de x enparal.lel amb la dels termes.tipuspolinomi = taula [0 . . . MAX] de realftipusfun ió AvaluacioUsual2(ent a : polinomi, ent n : enter, ent x : real) retorna realvar

p, px : reali : enterfvar

p := a[0]; px := 1i := 1mentre ¬(i > n) fer

px := px ∗ xp := p + a[i] ∗ pxi := i + 1fmentreretorna p�un ió15. Complexitat: produ te d'un ve tor olumna per un ve tor �la de n elementsDonats els tipus:tipus vector = taula [1 . . . MAX] de enter ftipustipus matriu = taula [1 . . . MAX, 1 . . . MAX] de enter ftipusCal uleu el temps de ost i la omplexitat del següent algorisme:a ió Producte1(ent v1, v2 : vector, ent n : enter, sor m : matriu)var i, j : enter fvar

i := 1mentre ¬(i > n) ferj := 1mentre ¬(j > n) fer

m[i, j] := v1[i] ∗ v2[j]j := j + 1fmentre

i := i + 1fmentrefa ió16. Complexitat: produ te de dues matrius quadrades de m x m elementsCal uleu el temps de ost i l'ordre de omplexitat del següent algorisme, donats els tipusdel problema anterior.

165a ió Producte2(ent m1,m2 : matriu, ent n : enter, sor m : matriu)var i, j, k : enter fvari := 1mentre ¬(i > n) fer

j := 1mentre ¬(j > n) ferm[i, j] := 0mentre ¬(k > n) fer

m[i, j] := m[i, j] + m1[i, k] ∗m2[k, j]k := k + 1fmentre

j := j + 1fmentrei := i + 1fmentrefa ió17. Complexitat: matrius tridiagonalsUna matriu tridiagonal és un tipus espe ial de matriu que té tots els elements diferentsde zero ex epte els de la diagonal prin ipal i els de les dues diagonals que estan per sobrei per sota de la prin ipal.Es demana:(a) Dissenyeu un algorisme que fa i la suma de dues d'aquestes matrius de la formamés e� ient. Cal uleu-ne el temps de ost i l'ordre de omplexitat.(b) Dissenyeu un algorisme que fa i el produ te de dues d'aquestes matrius de la formamés e� ient. Cal uleu-ne el temps de ost i l'ordre de omplexitat.18. Complexitat: àl ul de l'arrel d'una fun ióA ontinua ió es mostren dos algorismes que al ulen l'arrel d'una fun ió f(x) dins d'unintèrval [x1, x2] amb una pre isió eps (quan es troba un subintèrval, dins de l'intèrvalini ial, d'amplada eps, que onté l'arrel, es dóna om arrel el punt mig d'aquest subin-tèrval. Es garanteix que a l'intèrval ini ial hi ha una i només una arrel. Cal uleu eltemps de ost i l'ordre de omplexitat de tots dos i ompareu-los.Versió 1fun ió Arrel1(ent x1, x2, eps : real) retorna realvar

a, b, x : reali : enterfvar

a := x1; b := x2x := (a + b)/2.mentre abs(b− a) > eps fersi Hiharrel(a, x) → b := x⊓⊔ ¬Hiharrel(a, x) → a := x

166 CAPÍTOL 10. ENUNCIATS DE PROBLEMESfsix := (a + b)/2.fmentreretorna x�un iófun ió Arrel(ent a, b : real) retorna booleàretorna f(a) > 0. ∧ f(b) < 0. Of(a) < 0. ∧ f(b) > 0.�un ióVersió 2fun ió Arrel1(ent x1, x2, eps : real) retorna realvara, x : realfvar

a := x1; x := x1 + epsmentre ¬Hiharrel(a, x) fera := x; x := a + epsfmentre

x := (a + x)/2.retorna x�un iófun ió Hiharrel(ent a, b : real) retorna booleàretorna f(a) > 0. ∧ f(b) < 0. Of(a) < 0. ∧ f(b) > 0.�un ióNOTA: Aquests dos algorismes no tra ten el as possible (però po probable) que algundels valors x al ulats a ada itera ió fossin exa tament l'arrel, és a dir, que es omplísque f(x) = 0.. Com aldria modi� ar els algorismes per tal que tra tés aquest as ?19. Ve tor de dimensió �xa.Implementeu el tipus Ve tor onsiderant el as de dimensió �xa.20. Opera ions amb ve torsEspe i�queu i implementeu els següents subprogrames usant l'espe i� a ió del tipusVe tor de la se ió 6.1.1:• Suma de dos ve tors.• Diferèn ia de dos ve tors.• Produ te es alar de dos ve tors.• Produ te entre un es alar i un ve tor21. Produ te d'un ve tor per una matriuEspe i�queu i implementeu un subprograma que al uli el produ te d'un ve tor per unamatriu usant l'espe i� a ió Ve tor de la se ió 6.1.1 i l'espe i� a ió Matriu de la se ió6.2.1.

16722. Estadístiques de notes d'una assignaturaEn un �txer seqüen ial de text de nom �NOTES� hi ha tants registres om estudiantsque ursen 2n. i a ada registre hi ha la nota d'una assignatura. El valor d'una notapertany al rang [0, 10℄ i està arrodonida a mig punt, és a dir, hi pot haver 21 valorsdiferents: 0, 0.5, 1, . . ., 9.5, 10. Al �nal hi ha un registre sentinella amb una nota devalor 11.Es vol obtenir un altre �txer seqüen ial de text de nom RESULTATS on hi apareguin21 parells (nota, nombre) on nombre indiqui el nombre de notes de valor nota.NOTA: Es re omana l'ús d'una taula de freqüèn ies.23. Hisenda II.És una variant del problema d'Hisenda (problema 10 de la ol.le ió), ara sense que el�txer Llogaters estigui ordenat pel DNI del propietari.24. Temps.Espe i�queu un onjunt d'opera ions que permeti sumar, restar i omparar temps donatsen hores, minuts i segons. Penseu una apli a ió que l'utilitzi i dissenyeu el orresponentalgoritme.25. Colors.Espe i�queu un onjunt d'opera ions que ens permeti manipular una taula de olorsdonats per sistema HLS (Hue, Lightness, Saturation) i per un nom que pretén des rure'ls.Aquestes opera ions han de permetre saber om li diem a un olor donat pel seu HLS,quin HLS té un olor donat pel seu nom i modi� ar el nom asso iat a un determinatHLS.26. Polinomis(a) Espe i�queu un onjunt d'opera ions amb polinomis que permetin:• Crear un polinomi• Consultar-ne el grau• Afegir-hi un terme• Consultar el oe� ient orresponent a un terme amb un determinat exponent(b) Espe i�queu i dissenyeu un pro ediment per sumar polinomis, usant l'anterior es-pe i� a ió.( ) Espe i�queu i dissenyeu un pro ediment per restar polinomis, usant l'anterior es-pe i� a ió.(d) Espe i�queu i dissenyeu un pro ediment per multipli ar polinomis, usant l'anteriorespe i� a ió(e) Espe i�queu i dissenyeu un pro ediment per derivar un polinomi.(f) Espe i�queu i dissenyeu un pro ediment per dividir un polinomi per un binomi.(g) De�niu un tipus per representar un polinomi on es guardin tots els oe� ients(tant els que no són nuls om els que ho són). Implementeu totes les opera ionsesmentades usant aquest tipus.

168 CAPÍTOL 10. ENUNCIATS DE PROBLEMES(h) De�niu un tipus per representar un polinomi on es guardin només aquells oe� ientsque no són nuls. Implementeu totes les opera ions esmentades usant aquest tipus.27. Problema de les bibliotequesLa UPC vol fer un estudi de les biblioteques que hi ha a adas ún dels seus entres,tenint en ompte que els llibres estan agrupats per matèries. Per això ha de disposar dela següent informa ió: el odi del entre, el nombre de matèries de les que hi ha llibresen aquell entre i, per ada matèria, el nom de la matèria i el nombre de llibres que hiha.La informa ió dels entres es troba al �txer �Biblioteques� estru turada de la següentforma:• Primer hi ha el odi del entre.• A ontinua ió hi ha la informa ió de les matèries: nombre de llibres d'aquellamatèria i nom de la matèria.• S'indi a que no hi ha més matèries d'aquell entre amb un 0 (zero).• S'indi a que no hi ha més entres amb un altre 0 (zero).Exemple: odi entre 1 10001num. llibres 33nom matèria bioestadísti anum. llibres 41nom matèria àlgebra...... ......0 0 odi entre 2 10002num. llibres 46nom matèria àlgebra...... ......0 0...... ...... odi entre n 10037num. llibres 38nom matèria àl ul numèri ...... ......0 00 0A més a més, també disposem d'un �txer �Materies� que onté una llista amb totes lesmatèries possibles a abada amb la paraula 'XXX', que fa de sentinella.Disenyeu un algoritme que a partir d'aquest �txer, obtingui un altre �txer de nom�Global� on a ada registre hi hagi el nom d'una matèria i el nombre total de llibresd'aquell matèria a tota la UPC. Aquest algoritme també ha d'obtenir un �txer similaral �txer �Biblioteques� on, al ostat del nombre de llibres de ada matèria hi �guri el

169per entatge que aquest nombre representa respe te el nombre de llibres que hi ha a totala UPC d'aquella matèria. Aquest nou �txer es pot dir �Biblioteques1�.NOTA: Espe i�queu i useu una taula de freqüèn ies adient per resoldre aquest problema.28. Músi a.Una ompanyia dis ogrà� a organitza una enquesta per onèixer l'èxit de diverses an-çons. A ada persona se li demanarà el sexe, l'edat, i in noms de an ó per ordre depreferèn ia, noms que estaran identi� ats per nombres enters (n = 1 . . . 30). L'esmenta-da ompanyia vol al ular la següent informa ió:• Una llista de ançons en ordre de popularitat que presenti l'identi� ador de la ançói el nombre de vegades que ha estat votada. No han d'aparèixer les ançons que nohan estat votades. Dues llistes més, similars, que indiquin els ordres de popularitatentre les persones de sexe femení i mas ulí.• Una llista que presenti el nom i ognom de les persones que tenen menys de vintanys i han votat en primer llo la ançó que més vots ha obtingut.• Una llista que presenti el nom i ognom de les persones de menys de vint anys quehan votat en primer llo una ançó que és alguna de les tres menys votades.Dissenyeu l'algoritme ne essari per a dur a terme la omanda de l'esmentada ompanyia,usant els tipus de dades adients.29. Expressió ben parentitzada.Dissenyeu un algoritme tal que, donada una expressió, indiqui si és una expressió benparentitzada. A l'expressió hi pot haver parèntesis, '(', ')', laus, '', '' i laudàtors '[', '℄'i s'a aba en un punt, '.'. Es re omana usar el tipus PilaCara ter en el disseny.Espe i� a ió tipus PilaCara ter

{Pre : ert}a ió CrearP ilaCaracter(sor p : PilaCaracter){Post: p = ∅}{Pre : p = P}a ió EmpilarCaracter(entsor p : PilaCaracter, ent e : arà ter){Post: p = e.P}{Pre : p = e.P}fun ió CimPilaCaracter(ent p : PilaCaracter) retorna arà ter{Post: e = CimPilaCaracter}{Pre : p = e.P}a ió DesempilarCaracter(entsor p : PilaCaracter){Post: p = P}{Pre : ert}fun ió BuidaP ilaCaracter(ent p : PilaCaracter) retorna booleà{Post: BuidaP ilaCaracter(p) ≡ p = ∅}30. Matriu dominant diagonal per �les.

170 CAPÍTOL 10. ENUNCIATS DE PROBLEMESDissenyeu un pro ediment que determini si una matriu és diagonalment dominant per�les. Una matriu és diagonalment dominant per �les si| aii |>

j=n∑

j=1,j 6=i

| aij |, i = 1 . . . nNOTA. Cal usar les opera ions del tipus Matriu indi ades a 6.2.1.31. Matriu simètri a.Dissenyeu un pro ediment que determini si una matriu és simètri a.NOTA: Cal usar les opera ions del tipus Matriu indi ades a 6.2.1.32. Mètode LU (o LR).Donat el mètode LR [1℄, [3℄, que des ompon la matriu d'un sistema lineal en el produ teentre dues matrius, una de triangular inferior (L) i una de triangular superior (R),dissenyeu els següents subprogrames:• Subprograma que des ompon una matriu A en LR usant alguna de les estratègiesde pivotatge.• Subprograma que resol un sistema lineal triangular inferior Lz = y.• Subprograma que al ula el determinant d'una matriu a què s'ha apli at la des- omposi ió LR.• Subprograma que obté la inversa d'una matriu a què s'ha apli at la des omposi ióLR.NOTA. Cal usar les opera ions dels tipus Ve tor i Matriu indi ades a 6.1.1 i 6.2.1.33. eA.Dissenyeu un algorisme per al ular

eA = I +

∞∑

k+1

1

k!AKusant l'espe i� a ió del tipus Matriu.34. Mètode de Ja obi.El mètode de Ja obi serveix per trobar els valors propis d'una matriu. Parteix d'unamatriu real i simètri a A. Aquest tipus de matrius ompleixen que:

• tots els seus valors propis són reals,• existeix A1 tal que A1 = OT ∗A ∗O i A1 és una matriu diagonal.Com que A1 i A tenen els mateixos valors propis, aquests es troben a la diagonal de A1.El pro ediment a seguir per apli ar aquest mètode es des riu tot seguit. Cal trobar unaseqüèn ia de matrius O1, O2, . . . , On de forma que O = O1 ∗O2 ∗ .... ∗ On i tals que Oiés la matriu que fa que s'anul.li l'element extradiagonal més gran.

171Sigui aij aquest element, donada la submatriu (aii aij

aji ajj

), ∃ϕ tal queG−1 ∗

(aii aij

aji ajj

)

∗G =

(dii 00 djj

),on G =

(cos ϕ − sin ϕsin ϕ cos ϕ

)Plantejant les orresponents equa ions, tenim que ϕ = arctan(2aij

aii−ajj)

Aleshores la matriu Oi serà:

1 0 · · · · · · · · · 0

0. . . · · · · · · · · · 0... · · · oii oij · · ·

...... · · · oij ojj · · ·

...... · · · · · · · · · . . . ...0 · · · · · · · · · · · · 1

on oii = ojj = cos ϕ i oji = −oij = sin ϕ i la matriu A serà igual a l'anterior ex epte enels elements de les �les i olumnes i, j: a′ik, a

′jk, a

′ki, a

′kj, k = 1 . . . n on n és la mida dela matriu.

a′ii = dii

a′jj = djj

a′ij = a′ji = dij = 0a′ik = a′ki = aik ∗ cos ϕ + aik ∗ sin ϕ, k = 1 . . . n, k 6= i, k 6= ja′jk = a′kj = −aik ∗ sin ϕ + ajk cos ϕ, k = 1 . . . n, k 6= i, k 6= j

172 CAPÍTOL 10. ENUNCIATS DE PROBLEMES

Bibliogra�a[1℄ C. Bonet et al. Càl ul numèri . Edi ions UPC, 1994.[2℄ A. B. Tu ker et al. Fundamentos de Informati a. M GrawHill, 1994.[3℄ C. Froberg. Introdu ión al análisis numéri o. Vi ens-Vives, 1977.[4℄ L. Golds hlager i A. Lister. Computer S ien e. A Modern Introdu tion. Prenti e Hall.Segona edi ió, 1988.[5℄ B. Kernighan i D. Rit hie. The C Programming Language. Prenti e Hall, 1992.[6℄ A. V. Aho i J. D. Ullman. Foundations of Computer S ien e. Computer S ien e Press,1992.[7℄ S. Vila i N. Pla i L. Solano i A. Soto. Programa ió fonamental. Prà tiques de laboratori.Edi ions UPC, 1996.[8℄ R. Pe na. Diseño de Programas: Formalismo y Abstra ión. Prenti e-Hall, 1993.[9℄ A. Ralston. Introdu ión al anàlisis numéri o. Limusa-Wiley, S.A., 1970.[10℄ S. Vila. Programa ió fonamental. Problemes. Edi ions UPC, 1995.[11℄ J. Vilaplana. Programa ió fonamental. Edi ions CPDA, 2001.

173