L'nformtqu u lycé Chptr 8 http//ow.ly/35jlt Chptr 8 Structurs d donnés vncés Un structur d donnés st un orgnston logqu ds donnés prmttnt d smplfr ou d'ccélérr lur trtmnt. 8.1. Pl En nformtqu, un pl (n ngls stck) st un structur d donnés fondé sur l prncp «drnr rrvé, prmr sort» (ou LIFO pour Lst In, Frst Out), c qu vut dr qu ls drnrs élémnts joutés à l pl sront ls prmrs à êtr récupérés. L fonctonnmnt st donc clu d'un pl d'sstts on jout ds sstts sur l pl, t on ls récupèr dns l'ordr nvrs, n commnçnt pr l drnèr jouté. Prmtvs Voc ls prmtvs communémnt utlsés pour mnpulr ds pls «mplr» jout un élémnt sur l pl. Trm ngls corrspondnt «Push». «déplr» nlèv un élémnt d l pl t l rnvo. En ngls «Pop» «vd» rnvo vr s l pl st vd, fux snon «rmplssg» rnvo l nombr d'élémnts dns l pl. Applctons Dns un nvgtur wb, un pl srt à mémorsr ls pgs Wb vstés. L'drss d chqu nouvll pg vsté st mplé t l'utlstur dépl l'drss d l pg précédnt n clqunt l bouton «Affchr l pg précédnt». L'évluton ds xprssons mthémtqus n notton post-fxé (ou polons nvrs) utls un pl. L foncton «Annulr l frpp» (n ngls «Undo») d'un trtmnt d txt 8-1
Structurs d donnés vncés mémors ls modfctons pportés u txt dns un pl. Un lgorthm d rchrch n profondur utls un pl pour mémorsr ls nœuds vstés. Ls lgorthms récursfs dms pr crtns lnggs (LISP, Algol, Pscl, C, tc.) utlsnt mplctmnt un pl d'ppl. Dns un lngg non récursf (FORTRAN pr xmpl), on put donc toujours smulr l récurson n crént ls prmtvs d gston d'un pl. Exrcc 8.1 Implémntz n Python un clss «pl» vc cs qutr méthods, ns qu'un méthod «ffchr» qu lst tous ls élémnts d l pl, du drnr ntré u prmr ntré. 8.2. Fl Un fl (quu n ngls ) st un structur d donnés bsé sur l prncp «Prmr ntré, prmr sort», n ngls FIFO (Frst In, Frst Out), c qu vut dr qu ls prmrs élémnts joutés à l fl sront ls prmrs à êtr récupérés. L fonctonnmnt rssmbl à un fl d'ttnt ls prmèrs prsonns à rrvr sont ls prmèrs prsonns à sortr d l fl. Prmtvs Voc ls prmtvs communémnt utlsés pour mnpulr ds fls «joutr» jout un élémnt dns l fl. Trm ngls corrspondnt «Enquu» «nlvr» rnvo l prochn élémnt d l fl, t l rtr d l fl. Trm ngls corrspondnt «Dquu» «vd» rnvo «vr» s l fl st vd, «fux» snon «rmplssg» rnvo l nombr d'élémnts dns l fl. Applctons En générl, on utls ds fls pour mémorsr tmporrmnt ds trnsctons qu dovnt ttndr pour êtr trtés. Ls srvurs d'mprsson, qu dovnt trtr ls rquêts dns l'ordr dns lqul lls rrvnt, t ls nsèrnt dns un fl d'ttnt (ou un quu). Crtns moturs multtâchs, dns un systèm d'xplotton, qu dovnt ccordr du tmps-mchn à chqu tâch, sns n prvlégr ucun. Un lgorthm d prcours n lrgur utls un fl pour mémorsr ls nœuds vstés. On utls uss ds fls our crér touts sorts d mémors tmpons (n ngls buffrs). Exrcc 8.2 Implémntz n Python un clss «fl» vc cs qutr méthods, ns qu'un méthod «ffchr» prmttnt d vor tous ls élémnts d l fl, du prmr ntré u drnr ntré. Fls à prortés Un fl à prortés st un typ bstrt élémntr sur lqull on put ffctur tros opértons nsérr un élémnt supprmr l plus grnd élémnt tstr s l fl à prortés st vd ou ps Ls prncpls mplémnttons d cs fls à prortés sont l ts (vor 8.9), l ts bnoml t l ts d Fboncc. 8-2
L'nformtqu u lycé 8.3. Donld Knuth, profssur émért à Stnford, utur d l'ouvrg d référnc sur l'lgorthmqu, n plusurs volums, nttulé «Th Art of Computr Progrmmng», consdèr ls rbrs comm «l structur l plus fondmntl d l'nformtqu». Chptr 8 Arbrs Un rbr st un grph sns cycl, où ds nœuds sont rlés pr ds rêts. On dstngu tros sorts d nœuds ls nœuds ntrns, qu ont ds fls ; ls fulls, qu n'ont ps d fls ; l rcn d l'rbr, qu st l'unqu nœud n possédnt ps d pèr. Trdtonnllmnt, on dssn toujours l rcn n hut t ls fulls n bs. L profondur d'un nœud st l dstnc,.. l nombr d'rêts, d l rcn u nœud. L hutur d'un rbr st l plus grnd profondur d'un full d l'rbr. L tll d'un rbr st son nombr d nœuds (n comptnt ls fulls ou non). Ls rbrs puvnt êtr étqutés. Dns c cs, chqu nœud possèd un étqutt, qu st n qulqu sort l «contnu» du nœud. L'étqutt put êtr très smpl (un nombr ntr, pr xmpl) ou plus complx un objt, un nstnc d'un structur d donnés, tc. Ls rbrs sont n ft rrmnt utlsés n tnt qu tls, ms d nombrux typs d'rbrs vc un structur plus rstrctv xstnt t prmttnt lors ds rchrchs rpds t ffccs. Nous n rprlrons bntôt. 8.3.1. Prcours Prcours n lrgur L prcours n lrgur corrspond à un prcours pr nvu d nœuds d l'rbr. Un nvu st un nsmbl d nœuds ou d fulls stués à l mêm profondur. Ans, s l'rbr c-contr st utlsé, l prcours sr A, B, C, D, E, F, G. Prcours n profondur L prcours n profondur st un prcours récursf sur un rbr. Il xst tros ordrs pour ctt méthod d prcours. L prcours n profondur préfxé st l plus cournt. Prcours n profondur préfxé Dns c mod d prcours, l nœud cournt st trté vnt l trtmnt ds nœuds guch t drot. Ans, s l'rbr précédnt st utlsé, l prcours sr A, B, D, E, C, F, G. Prcours n profondur suffxé Dns c mod d prcours, l nœud cournt st trté près l trtmnt ds nœuds guch t drot. Ans, s l'rbr précédnt st utlsé, l prcours sr D, E, B, F, G, C, A. C mod d prcours corrspond à un notton polons nvrs, utlsé pr ls clcultrcs HP. 8-3
Structurs d donnés vncés Prcours n profondur nfxé Dns c mod d prcours, l nœud cournt st trté ntr l trtmnt ds nœuds guch t drot. Ans, s l'rbr précédnt st utlsé, l prcours sr D, B, E, A, F, C pus G. Exrcc 8.3 Prcourz l'rbr c-dssous slon ls qutr méthods vus précédmmnt. 8.4. Arbrs bnrs Dns un rbr bnr, chqu nœud possèd u plus dux fls, hbtullmnt pplés «guch» t «drot». Du pont d vu ds fls, l'élémnt dont ls sont ssus u nvu supérur st logqumnt pplé pèr. 8.4.1. Typs d'rbrs bnrs Un rbr bnr ntr st un rbr dont tous ls nœuds possèdnt zéro ou dux fls. Un rbr bnr prft st un rbr bnr ntr dns lqul touts ls fulls sont à l mêm hutur. L'rbr bnr prft st prfos nommé rbr bnr complt. Cpndnt crtns défnssnt un rbr bnr complt comm étnt un rbr bnr ntr dns lqul ls fulls ont pour profondur n ou n-1 pour un n donné. 8-4
L'nformtqu u lycé 8.4.2. Chptr 8 Méthods pour stockr ds rbrs bnrs Structur à 3 nœuds Ls rbrs bnrs puvnt êtr construts d dfférnts mnèrs. Dns un lngg vc structurs t ponturs (ou référncs), ls rbrs bnrs puvnt êtr conçus n ynt un structur à tros nœuds qu contnnnt qulqus donnés t ds ponturs vrs son fls drot t son fls guch. Prfos, l contnt églmnt un pontur vrs son unqu prnt. S un nœud possèd mons d dux fls, l'un ds dux ponturs put êtr ffcté d l vlur spécl null. L'rbr consrvr un pontur vrs l rcn, un pontur vrs l nœud cournt (qu prmt d smplfr l'jout t l consultton) t évntullmnt l nombr d nœuds du grph. Avntgs Conçu pour contnr un nombr vrbl d nœuds. Ps d gspllg d mémor. Inconvénnts Implémntton délct à rélsr qund on st débutnt n progrmmton. Ps d'ccès drct à un nœud d l'rbr. Tblu L foncton floor(x) rtourn l'ntr nférur ou égl à x. Ls rbrs bnrs puvnt uss êtr rngés dns ds tblux, t s l'rbr st un rbr bnr complt, ctt méthod n gspll ps d plc, t l donné structuré résultnt st pplé un ts. Dns ct rrngmnt compct, un nœud un ndc, t ss fls s trouvnt ux ndcs 2+1 t 2+2, tnds qu son pèr s trouv à l'ndc floor(( 1)/2), s'l xst. L rcn (nœud 0) pour fls ls nœuds 1 t 2. L nœud 1 pour fls 3 t 4, tc. Avntgs Implémntton fcl à rélsr. Possblté d'ccès drct à un nœud d l'rbr (un sul ccès n mémor). Inconvénnts Conçu pour contnr un nombr fx d nœuds. S l'rbr st profond ms contnt pu d nœuds, l s produt un gspllg mportnt d mémor. 8-5
Structurs d donnés vncés Exrcc 8.4 Progrmmz n Python ls tros lgorthms d prcours n profondur vus u 8.3.1 pus xécutz-ls sur un tblu rprésntnt l'rbr bnr c-dssous 8.5. L notton O(f(n)) Dns ls nnés 1960 t u début ds nnés 1970, lors qu'on n étt à découvrr ds lgorthms fondmntux, on n msurt ps lur ffccté. On s contntt d dr, pr xmpl «Ct lgorthm s déroul n 6 sconds vc un tblu d 50'000 ntrs choss u hsrd n ntré, sur un ordntur IBM 360/91. L lngg d progrmmton PL/I été utlsé vc ls optmstons stndrds.» Un tll démrch rndt dffcl l comprson ds lgorthms ntr ux. L msur publé étt dépndnt du procssur utlsé, ds tmps d'ccès à l mémor vv t d mss, du lngg d progrmmton t du compltur utlsé, tc. Comm l st très dffcl d comprr ls prformncs ds ordnturs, un pproch ndépndnt ds fcturs mtérls étt nécssr pour évlur l'ffccté ds lgorthms. Donld Ervn Knuth (1938-) fut un ds prmrs à l'pplqur systémtqumnt dès ls prmrs volums d s fmus sér Th Art of Computr Progrmmng. L notton grnd O (vc l lttr mjuscul O, t non ps l chffr zéro) st un symbol utlsé n mthémtqus, notmmnt n théor d l complxté, pour décrr l comportmnt symptotqu ds fonctons. Un foncton g(n) st dt O(f(n)) s'l xst un ntr N t un constnt réll postv c tls qu pour n > N on t g(n) c f(n). En d'utrs trms, O(f(n)) st l'nsmbl d touts ls fonctons g(n) bornés supérurmnt pr un multpl rél postf d f(n), pour utnt qu n sot suffsmmnt grnd. Attnton, g(n) st O(f(n)) n vut ps dr qu g(n) s'pproch symptotqumnt d f(n), ms sulmnt qu'u-dlà d crtns vlurs d son rgumnt, g(n) st domné pr un crtn multpl d f(n). 8.5.1. Exmpls g(n) = n3 + 2n2 + 4n + 2 = O(n3) g(n) = n3 + 10100n2 = O(n3) g(n) = n log(n) + 12n + 888 = O(n log(n)) g(n) = 1000n10 n7 + 12n4 + 2n = O(2n) 8-6
L'nformtqu u lycé Chptr 8 8.5.2. Qulqus clsss d complxté Notton Typ d complxté O(1) complxté constnt (ndépndnt d l tll d l donné) O(log(n)) complxté logrthmqu O(n) complxté lnér O(n log(n)) complxté qus-lnér O(n2) complxté qudrtqu O(n3) complxté cubqu O(np) complxté polynoml O(2n) complxté xponntll O(n!) complxté fctorll Ls complxtés sont donnés d l mllur, O(1), à l pr, O(n!). Qulqus courbs d complxté Exrcc 8.5 Un progrmm résout un problèm d tll n n n! sconds. Combn d tmps st nécssr pour résoudr un problèm d tll n = 12? 8.6. Arbrs bnrs d rchrch Un rbr bnr d rchrch (ABR) st un rbr bnr dns lqul chqu nœud possèd un étqutt, tll qu chqu nœud du sous-rbr guch t un étqutt nférur ou égl à cll du nœud consdéré, t qu chqu nœud du sous-rbr drot possèd un étqutt supérur ou égl à cll-c (slon l ms n œuvr d l'abr, on pourr ntrdr ou non ds étqutts d vlur égl). 8-7
Structurs d donnés vncés 8.6.1. Rchrch L rchrch dns un rbr bnr d'un nœud ynt un étqutt prtculèr st un procédé récursf. On commnc pr xmnr l rcn. S l'étqutt d l rcn st l'étqutt rchrché, l'lgorthm s trmn t rnvo l rcn. S l'étqutt chrché st nférur, lors ll st dns l sous-rbr guch, sur lqul on ffctu lors récursvmnt l rchrch. D mêm, s l'étqutt rchrché st strctmnt supérur à l'étqutt d l rcn, l rchrch contnu sur l sous-rbr drot. S on ttnt un full dont l'étqutt n'st ps cll rchrché, on st lors qu ctt étqutt n'st ps dns l'rbr. Ctt opérton rqurt un tmps n O(log(n)) dns l cs moyn, ms O(n) dns l pr ds cs où l'rbr st complètmnt déséqulbré où chqu pèr un sul fls. 8.6.2. Insrton L'nsrton d'un nœud commnc pr un rchrch on chrch l'étqutt du nœud à nsérr ; lorsqu'on rrv à un full, on jout l nœud comm fls d l full n comprnt son étqutt à cll d l full s ll st nférur, l nouvu nœud sr à guch ; snon l sr à drot. Ans, chqu nœud jouté sr un full. L complxté d l'nsrton st O(log(n)) dns l cs moyn t O(n) dns l pr ds cs. Exrcc 8.6 Insérz dns l'rbr bnr d rchrch c-dssous ls vlurs 11 t 5. 8-8
L'nformtqu u lycé 8.6.3. Chptr 8 Supprsson Plusurs cs sont à consdérr, un fos qu l nœud à supprmr été trouvé Pour llr l plus à guch dns l sous-rbr drot, on prt d l rcn, on s déplc un fos à drot, pus toujours à guch, tnt qu'on l put. Supprsson d'un full Il sufft d l'nlvr d l'rbr étnt donné qu'll n' ps d fls. Supprsson d'un nœud vc un sul fls On l'nlèv d l'rbr t on l rmplc pr son fls. Supprsson d'un nœud vc dux fls Supposons qu l nœud à supprmr sot pplé N (l nœud d vlur 7 dns l schém cdssous). On l rmplc lors pr son succssur l plus proch, donc l nœud l plus à guch du sous-rbr drot (c-près, l nœud d vlur 9) ou son plus proch prédécssur, donc l nœud l plus à drot du sous-rbr guch (c-dssous, l nœud d vlur 6). Cl prmt d grdr un structur d'rbr bnr d rchrch. Pus on pplqu à nouvu l procédur d supprsson à N, qu st mntnnt un full ou un nœud vc un sul fls. Pour un mplémntton ffcc, l st déconsllé d'utlsr unqumnt l succssur ou l prédécssur cr cl contrbu à déséqulbrr l'rbr. 8-9
Structurs d donnés vncés Dns tous ls cs, un supprsson rqurt d prcourr l'rbr d l rcn jusqu'à un full l tmps d'xécuton st donc proportonnl à l profondur d l'rbr qu vut n dns l pr ds cs, d'où un complxté mxml n O(n). 8.7. Arbrs AVL L dénomnton «rbr AVL» provnt ds noms d ss dux nvnturs russs, Gorgy Mxmovch Adlson-Vlsky t Evgn Mkhlovch Lnds, qu l'ont publé n 1962 sous l ttr An lgorthm for th orgnzton of nformton. Ls rbrs AVL ont été hstorqumnt ls prmrs rbrs bnrs d rchrch utomtqumnt équlbrés. Dns un rbr AVL, ls huturs ds dux sous-rbrs d'un mêm nœud dffèrnt u plus d un. L rchrch, l'nsrton t l supprsson sont touts n O(log(n)) dns l pr ds cs. L fctur d'équlbrg d'un nœud st l dfférnc ntr l hutur d son sous-rbr drot t cll d son sous-rbr guch. Un nœud dont l fctur d'équlbrg st +1, 0, ou -1 st consdéré comm équlbré. Un nœud vc tout utr fctur st consdéré comm déséqulbré t rqurt un rééqulbrg. Chqu fos qu'un nœud st nséré ou supprmé d'un rbr AVL, l fctur d'équlbrg d chqu nœud l long du chmn dpus l rcn jusqu'u nœud nséré (ou supprmé) dot êtr rclculé. S l'rbr st rsté équlbré, l n'y rn à fr. S c n'st ps l cs, on ffctur ds rottons d'équlbrg d mnèr à obtnr à nouvu un rbr AVL. 8.7.1. Rottons d'équlbrg Un rotton st un modfcton locl d'un rbr bnr. Ell consst à échngr un nœud vc l'un d ss fls. Dns l rotton drot, un nœud dvnt l fls drot du nœud qu étt son fls guch. Dns l rotton guch, un nœud dvnt l fls guch du nœud qu étt son fls drot. Ls rottons guchs t drots sont nvrss l'un d l'utr. Ls rottons ont l proprété d pouvor êtr mplémntés n tmps constnt, t d présrvr l'ordr nfx. En d'utrs trms, s A st un rbr bnr d rchrch, tout rbr obtnu à prtr d A pr un sut d rottons guch ou drot d'un sous-rbr d A rst un rbr bnr d rchrch. Un rotton smpl drot st utlsé qund un nœud un fctur d'équlbrg nférur à -1 t qu son fls guch un fctur d'équlbrg d -1. 8-10
L'nformtqu u lycé Chptr 8 Un rotton doubl drot st utlsé qund un nœud un fctur d'équlbrg nférur à -1 t qu son fls guch un fctur d'équlbrg d +1. L doubl rotton drot st un rotton smpl guch du sous-rbr guch, suv d'un rotton smpl drot du nœud déséqulbré. Ctt opérton st uss pplé prfos un rotton guch-drot. Un rotton smpl guch st utlsé qund un nœud un fctur d'équlbrg supérur à +1 t qu son fls drot un fctur d'équlbrg d +1. Un rotton doubl guch st utlsé qund un nœud un fctur d'équlbrg supérur à +1 t qu son fls guch un fctur d'équlbrg d -1. L doubl rotton guch st un rotton smpl drot du sous-rbr drot, suv d'un rotton smpl guch du nœud déséqulbré. Ctt opérton st uss pplé prfos un rotton drot-guch. 8-11
Structurs d donnés vncés 8.7.2. Insrton dns un rbr AVL L'nsrton dns un rbr AVL s déroul n dux étps 1. tout d'bord, on nsèr l nœud xctmnt d l mêm mnèr qu dns un rbr bnr d rchrch ; 2. pus on rmont dpus l nœud nséré vrs l rcn n ffctunt un rotton sur chqu sous-rbr déséqulbré. On put montrr qu'l sufft d'un rotton smpl ou d'un doubl rotton pour rééqulbrr un rbr AVL près un nsrton. L hutur d l'rbr étnt n O(log(n)), t ls rottons étnt à tmps constnt, l'nsrton s ft fnlmnt n O(log(n)). 8.7.3. Supprsson L supprsson dns un rbr AVL put s fr pr rottons succssvs du nœud à supprmr jusqu'à un full (n chosssnt cs rottons d sort qu l'rbr rst équlbré), t nsut n supprmnt ctt full drctmnt. L supprsson s ft uss n O(log(n)). 8.7.4. Rchrch L rchrch dns un rbr AVL s déroul xctmnt comm pour un rbr bnr d rchrch, t comm l hutur d'un rbr AVL st n O(log(n)), ll s ft donc n O(log(n)). Exrcc 8.7 Insérz dns l'rbr AVL c-dssous ls vlurs 20 t 70. Exrcc 8.8 Obsrvz sur l'pplt du st compgnon commnt nsérr, supprmr t rchrchr un vlur dns un rbr AVL. 8.8. Ts On dt qu'un rbr bnr complt st ordonné n ts1 (on dt uss prfos «moncu») lorsqu l proprété suvnt st vérfé Pour tous ls nœuds d l'rbr, étqutt(pèr) étqutt(fls). Ctt proprété mplqu qu l plus grnd étqutt st stué à l rcn du ts. Ils sont ns très utlsés pour mplémntr ls fls à prortés2 cr ls prmttnt ds nsrtons n tmps 1 2 Hp n ngls Vor 8.2. L mot «fl» st ml chos, cr un fl d prorté n rssmbl ps à un fl, n pr son spct, n pr son comportmnt. 8-12
L'nformtqu u lycé Chptr 8 logrthmqu t un ccès drct u plus grnd élémnt. L ft qu'un ts sot un rbr bnr complt prmt d l rprésntr d'un mnèr ffcc pr un tblu undmnsonnl. En fft, dns un tblu ndcé à prtr d 0, l pèr d'un nœud n poston pour poston 1 l'ntr nférur ou égl à ; ls nfnts d'un nœud n poston sont stués à 2+1 pour l fls 2 guch t 2+2 pour l fls drot (vor 8.4.2). 8.8.1. Prmtvs Un crctérstqu fondmntl d ctt structur d donnés st qu l proprété du ts put êtr rsturé ffccmnt près l modfcton d'un nœud. S l vlur du nœud st ugmnté t qu'll dvnt d c ft supérur à cll d son pèr, l sufft d l'échngr vc cll-c, pus d contnur c procssus vrs l hut jusqu'u rétblssmnt d l proprété du ts. Nous drons qu l vlur modfé été prcolé jusqu'à s nouvll poston. Invrsmnt, s l vlur du nœud st dmnué t qu'll dvnt d c ft nférur à cll d'u mons un d ss fls, l sufft d l'échngr vc l plus grnd ds vlurs d ss fls, pus d contnur c procssus vrs l bs jusqu'u rétblssmnt d l proprété du ts. Nous drons qu l vlur modfé été tmsé jusqu'à s nouvll poston. Plus formllmnt, l modfcton d'un nœud s ft pr ls lgorthms suvnts PROCEDURE prcolr(t[0..n-1], ) Donnés tblu T, noud Résultt T st d nouvu un ts k = REPETER j = k SI j > 0 ET T[(j-1) dv 2] < T[k] ALORS k = (j-1) dv 2 chngr T[j] t T[k] JUSQU'A j = k 8-13
Structurs d donnés vncés PROCEDURE tmsr(t[0..n-1], ) Donnés tblu T, noud Résultt T st d nouvu un ts k = REPETER j = k (* rchrch du plus grnd fls du noud j *) SI 2j+1 <= n-1 ET T[2j+1] > T[k] ALORS k = 2j+1 SI 2j+1 < n-1 ET T[2j+2] > T[k] ALORS k = 2j+2 chngr T[j] t T[k] JUSQU'A j = k PROCEDURE modfr_ts(t[0..n-1],, v) (* on vut chngr l vlur v du noud n présrvnt l proprété du ts *) Donnés tblu T, noud, vlur v Résultt T st d nouvu un ts x = T[] T[] = v SI v < x ALORS tmsr(t, ) SINON prcolr(t, ) Ctt proprété du ts n ft un structur d donnés dél pour trouvr l mxmum, élmnr l rcn, joutr un nœud t modfr un nœud. C sont précsémnt ls opértons voulus pour l'mplémntton ffcc d'un lst d prorté dynmqu l vlur d'un nœud ndqu l prorté d l'événmnt corrspondnt. L'événmnt l plus prortr s trouv toujours à l rcn t l st toujours possbl d modfr dynmqumnt l prorté d'un événmnt. PROCEDURE lmnr_rcn(t[0..n-1]) Donnés tblu T Résultt T[0..n-2] st d nouvu un ts T[0] = T[n-1] tmsr(t,0) supprmr(t[n-1]) PROCEDURE joutr_noud(t[0..n-1], v) Donnés tblu T, vlur v Résultt T[0..n] st d nouvu un ts T[n] = v prcolr(t,n) Exrcc 8.9 Écrvz un progrmm Python qu gèr un ts rprésntz l ts pr un tblu. pus progrmmz ls procédurs ou fonctons suvnts prcolr, tmsr, modfr_ts, mxmum, lmnr_rcn, joutr_noud. Écrvz nfn un procédur qu cré un ts d n vlurs trés létormnt. 8-14
L'nformtqu u lycé Chptr 8 8.9. L trm vnt d rtrvbl mmory, ms l'usg dns l lttértur frncophon st d'utlsr l msculn. Tr Un tr ou rbr préfx st un rbr numérqu ordonné qu st utlsé pour stockr un tbl ssoctv où ls clés sont générlmnt ds chîns d crctèrs. Contrrmnt à un rbr bnr d rchrch, ucun nœud dns l tr n stock l chîn à lqull l st ssocé. C'st l poston du nœud dns l'rbr qu détrmn l chîn corrspondnt. Pour tout nœud, ss dscndnts ont n commun l mêm préfx. L rcn st ssocé à l chîn vd. Ds vlurs n sont ps ttrbués à chqu nœud, ms unqumnt ux fulls t à crtns nœuds ntrns s trouvnt à un poston qu désgn l'ntégrlté d'un chîn corrspondnt à un clé. Tr construt vc ls mots br, brs, brté, brté, brtés, brog, brogr, brogs, s, ssut t ssuts. Ls logcls d trtmnt d txt présntnt souvnt un fonctonnlté d'uto-compléton ds mots u cours d l frpp. Crtns édturs d txt l'étndnt ux commnds d'un lngg d progrmmton. Dns tous ls cs, l'uto-compléton st grndmnt fclté pr l rprésntton ds mots sous form d tr l sufft n fft d'xtrr l sous-rbr corrspondnt à un préfx donné pour connîtr touts ls suggstons n rpport vc l txt ss! 8.9.1. Un tr n Python clss Tr df nt (slf, lttr="") # u début, l'rbr st vd slf.brnchs = {} slf.lttr = lttr slf.s_word_nd = Fls 8-15
Structurs d donnés vncés df gttm (slf, lttr) # prmt d'ccédr à un vlur rturn slf.brnchs.gt(lttr, Non) df swordend(slf) # st-c l fn d'un mot? rturn slf.s_word_nd df stwordend(slf, vlu=tru) # mrqur qu c'st l fn d'un mot slf.s_word_nd = vlu df gtlttr(slf) # lr un lttr rturn slf.lttr df ddbrnch(slf, brnch) # joutr un brnch à l'rbr slf.brnchs[brnch.gtlttr()] = brnch df mktr(slf, lst_mots) # cré un tr à prtr d'un lst d mots for un_mot n lst_mots noud = slf # on s plc u début mot = un_mot.rstrp() f ln(mot)>1 for lttr n mot # lt ls lttrs f not noud[lttr] # on cré un nouvll brnch noud.ddbrnch(tr(lttr)) noud = noud[lttr] # on vnc noud.stwordend() # mrqu d rturn slf d l'rbr un à un dns l'rbr fn d mot df ntr(slf, mot) # mot st-l dns l Tr? noud = slf for lttr n mot f noud[lttr]!= Non noud = noud[lttr] ls rturn Fls ls f noud.swordend() rturn Tru ls rturn Fls 8.9.2. Utlston d'un tr comm dctonnr L progrmm c-dssous, utls l tr défn u 8.10.1 t un fchr «dctonnr.txt». C dctonnr contnt 328'465 mots frnçs non ccntués ntr 2 t 16 lttrs, sns trt t sns postroph. On ntr smplmnt un mot frnçs (sns ccnt) t l progrmm dt s'l st frnçs ou non. from tr_fr mport Tr # ---------------------------------------------------df crr_tr(dco) prnt("lctur du dctonnr") fchr = opn(dco, 'r') lst_mots = fchr.rdlns() fchr.clos() prnt("créton du Tr") tr = Tr() tr.mktr(lst_mots) 8-16
L'nformtqu u lycé Chptr 8 prnt("tr trmné") rturn tr # -------------- progrmm prncpl -------------------tr = crr_tr('dctonnr.txt') whl Tru donns = nput("entrz un mot frnçs ") f donns=="" brk f tr.ntr(donns) prnt(donns,"st dns l dctonnr") ls prnt(donns,"n'st ps dns l dctonnr") Comm vous pourrz l consttr n tstnt c progrmm, l créton du tr prnd un pu d tmps (qulqus sconds). Pr contr, un fos l tr créé, l répons à l quston st nstntné. 8.10. Rprésntton ds grphs Un grph fn G = (V, E) st défn pr l'nsmbl fn V = {v1, v2,..., vn} dont ls élémnts sont pplés sommts, t pr l'nsmbl fn E = {1, 2,..., m} dont ls élémnts sont pplés rêts. Un rêt d l'nsmbl E st défn pr un pr non-ordonné d sommts, pplés ls xtrémtés d. S l'rêt rl ls sommts t b, on dr qu cs sommts sont djcnts. Prnons un xmpl Ensmbl ds sommts V = {1, 2, 3, 4, 5, 6} Ensmbl ds rêts E = {(1, 2), (1, 5), (2, 5), (2, 3), (3, 4), (4, 5), (4, 6)} C grph put s rprésntr grphqumnt comm ccontr (l y un nfnté d rprésnttons possbls). 8.10.1. Lsts d'djcncs On put uss rprésntr un grph n donnnt pour chcun d ss sommts l lst ds sommts uxquls l st djcnt. C'st l méthod qu st utlsé pour mplémntr un grph sur ordntur. Ls lsts d'djcncs du grph c-contr sont 1 2 3 4 5 6 2, 5 1, 5 2, 4 3, 5, 6 1, 2, 4 4 8.10.2. Trouvr tous ls mots d'un grll d Ruzzl Ruzzl st un ju d lttrs ux règls smpls un grll d qutr fos qutr lttrs, t dux mnuts pour trouvr l plus d mots possbls, vc pour sul mpértf qu ls css s touchnt. On n put ps utlsr dux fos l mêm cs, c qu ft qu l longuur mxml d'un mot sr d 16. 8-17
Structurs d donnés vncés Pour pmntr l ju, Ruzzl rprnd églmnt ls css bonus «lttr compt doubl», «lttr compt trpl», «mot compt doubl» t «mot compt trpl» du Scrbbl. Pour ggnr, l fudr obtnr l plus gros totl d ponts! Dns l vrson qu nous llons vor, on n tndr ps compt d cs bonus, n d l vlur ds lttrs ; on s contntr d trouvr tous ls mots possbls, du plus long u plus court. Voc l progrmm complt qu nos llons décortqur from tr_fr mport Tr # --------- cs d l grll d Ruzzl ------------clss Cs df nt (slf, vlu) slf.vlu = vlu slf.nghbors = [] df ddnghbor(slf, nghbor) # jout un vosn à l lst slf.nghbors.ppnd(nghbor) df gtnghbors(slf) # rnvo l lst ds vosns d'un cs rturn slf.nghbors df gtvlu(slf) # rnvo l lttr d'un cs rturn slf.vlu # ---------------------------------------------------df crr_tr(dco) prnt("lctur du dctonnr") fchr = opn(dco, 'r') lst_mots = fchr.rdlns() fchr.clos() prnt("créton du Tr") tr = Tr() tr.mktr(lst_mots) prnt("tr trmné") rturn tr df crr_connxons(grll) # cré ls lsts d'djcncs du grph for m n rng(16) cs = grll[m], j = m//4, m%4 for n n rng(16) 8-18
L'nformtqu u lycé Chptr 8 x, y = n//4, n%4 f bs(-x)<=1 nd bs(j-y)<=1 nd m!= n cs.ddnghbor(grll[n]) df chrchr(noud, cs, vus=[]) # chrch ls mots frnçs dns l Tr trouvs = [] f noud == Non rturn trouvs f noud.swordend() trouvs.ppnd(noud.gtlttr()) vus.ppnd(cs) for vosn n cs.gtnghbors() f vosn not n vus rsults = chrchr(noud[vosn.gtvlu()], vosn, vus) trouvs.xtnd([noud.gtlttr()+ndng for ndng n rsults]) vus.rmov(cs) rturn trouvs # -------------- progrmm prncpl -------------------tr = crr_tr('ruzzl_dctonnr.txt') whl Tru donns = nput("entrz l grll lgn pr lgn ") whl ln(donns)!=16 nd ln(donns)!=0 donns = nput("entrz l grll lgn pr lgn ") f donns=="" # tpr 'rturn' pour sortr d l boucl nfn brk donns = donns.lowr() grll = [Cs(lttr) for lttr n donns] crr_connxons(grll) rsultts = [] for cs n grll # prmèr lttr du mot à chrchr noud = tr # on s plc u début du Tr mots_trouvs = chrchr(noud[cs.gtvlu()], cs) f ln(mots_trouvs) > 0 rsultts.xtnd(mots_trouvs) rsultts = lst(st(rsultts)) # élmn ls doublons output = sortd(rsultts, ky=lmbd mot [ln(mot)], rvrs=tru) prnt(ln(output),"mots trouvés") prnt(output) prnt() On vot sur l prmèr lgn qu l progrmm mport l clss Tr du 8.9.1. L procédur crr_tr déjà été utlsé u 8.9.2 On créé un clss cs. Un cs contnt un lttr t l lst ds lttrs qu sont sur ds css vosns (ps vosn, on ntnd qu jouxt horzontlmnt, vrtclmnt ou n dgonl). clss Cs df nt (slf, vlu) slf.vlu = vlu slf.nghbors = [] df ddnghbor(slf, nghbor) # jout un vosn à l lst slf.nghbors.ppnd(nghbor) df gtnghbors(slf) # rnvo l lst ds vosns d'un cs rturn slf.nghbors df gtvlu(slf) # rnvo l lttr d'un cs rturn slf.vlu 8-19
Structurs d donnés vncés L lst ds lttrs vosns d'un cs st créé pr l procédur crr_connxons(grll). L grll st mplémnté pr un lst d 16 élémnts. Pour chcun ds 16 lttrs d l grll, on clcul s lgn t s colonn j n foncton d l poston m dns grll. On prcourt nsut ls 15 utrs css d l grll t on clcul lur lgn x t lur colonn y. Pour êtr vosn d ctt cs, l fut qu -x sot nférur ou égl à 1 t d mêm pour j-y. df crr_connxons(grll) # cré ls lsts d'djcncs du grph for m n rng(16) cs = grll[m], j = m//4, m%4 for n n rng(16) x, y = n//4, n%4 f bs(-x)<=1 nd bs(j-y)<=1 nd m!=n cs.ddnghbor(grll[n]) Voc ls lsts qu l'on obtnt pour l grll u s l r u o t s y u u u s s l r s r l l r u l s l u l r r u t s u s o l t r s u y l r r u s l o s r u t y o t s t s y o s t y L foncton l plus délct à nlysr st évdmmnt chrchr, cr ll st récursv. On vu commnt chrchr un mot dns l tr ( 8.9.2). Ic, l problèm st un pu dfférnt. En fft, l n srt ps très ffcc d chrchr touts ls suts d lttrs possbls (l y n 12'029'624 slon [7]) t vérfr nsut lsquls sont ds mots frnçs dns l tr. Pr xpérnc, l y générlmnt ntr 250 t 400 mots vlds dns un grll. On v fr l'nvrs on v prcourr l tr n utlsnt ls vosns. On prt du sommt du tr vc l prmèr lttr d l grll (cll n hut à guch). On chost son prmr vosn dns l grll t on rgrd s l sut d cs dux lttrs xst dns l tr. S l sut n'xst ps, on bndonn ctt brnch du tr, on mrqu c vosn comm vu t on ss un utr vosn. S l sut xst, on rgrd s c'st un mot complt. S ou, on l mémors. S non, on prnd un vosn d l duxèm lttr t on nlys l sut ds tros lttrs. Et ns d sut... df chrchr(noud, cs, vus=[]) # chrch ls mots frnçs dns l Tr trouvs = [] f noud == Non rturn trouvs f noud.swordend() trouvs.ppnd(noud.gtlttr()) vus.ppnd(cs) 8-20
L'nformtqu u lycé Chptr 8 for vosn n cs.gtnghbors() f vosn not n vus rsults = chrchr(noud[vosn.gtvlu()], vosn, vus) trouvs.xtnd([noud.gtlttr()+ndng for ndng n rsults]) vus.rmov(cs) rturn trouvs On prcourt slon c prncp l tr 16 fos, cr l y 16 css possbls pour l prmèr lttr. On élmn fnlmnt ls doublons dns l lst ds mots trouvés t on ffch tous ls mots du plus long u plus court. for cs n grll # prmèr lttr du mot à chrchr noud = tr # on s plc u début du Tr mots_trouvs = chrchr(noud[cs.gtvlu()], cs) f ln(mots_trouvs) > 0 rsultts.xtnd(mots_trouvs) rsultts = lst(st(rsultts)) # élmn ls doublons output = sortd(rsultts, ky=lmbd mot [ln(mot)], rvrs=tru) prnt(ln(output),"mots trouvés") prnt(output) 8.11. Tbl d hchg Un tbl d hchg (hsh tbl n ngls) st un structur d donné prmttnt d'ssocr un vlur à un clé. Il s'gt d'un tblu n comportnt ps d'ordr (un tblu st ndxé pr ds ntrs). L'ccès à un élémnt s ft n trnsformnt l clé n un vlur d hchg (ou smplmnt hchg) pr l'ntrmédr d'un foncton d hchg. L hchg st un nombr qu prmt l loclston ds élémnts dns l tblu, typqumnt l hchg st l'ndc d l'élémnt dns l tblu. Un cs dns l tblu st pplé lvéol. Un tbl d hchg mplémntnt un nnur téléphonqu Dfférnts opértons puvnt êtr ffctués sur un tbl d hchg créton d'un tbl d hchg nsrton d'un nouvu coupl (clé, vlur) supprsson d'un élémnt rchrch d l vlur ssocé à un clé (dns l'xmpl d l'nnur, rtrouvr l numéro d téléphon d'un prsonn) dstructon d'un tbl d hchg (pour lbérr l mémor occupé) Tout comm ls tblux, ls tbls d hchg prmttnt un ccès n O(1) n moynn, qul qu sot l nombr d'élémnts dns l tbl. Toutfos, l tmps d'ccès dns l pr ds cs put êtr d O(n). Comprés ux utrs tblux ssoctfs, ls tbls d hchg sont surtout utls lorsqu l nombr d'ntrés st très mportnt. 8-21
Structurs d donnés vncés L poston ds élémnts dns un tbl d hchg st létor. Ctt structur n'st donc ps dpté pour ccédr à ds donnés trés. 8.11.1. Chox d'un bonn foncton d hchg L ft d crér un hchg à prtr d'un clé put ngndrr un problèm d collson, c'st-à-dr qu'à prtr d dux clés dfférnts, l foncton d hchg pourrt rnvoyr l mêm vlur d hchg, t donc pr conséqunt donnr ccès à l mêm poston dns l tblu. Pour mnmsr ls rsqus d collsons, l fut donc chosr sognusmnt s foncton d hchg. Ls collsons étnt n générl résolus pr ds méthods d rchrch lnér, un muvs foncton d hchg,.. produsnt bucoup d collsons, v fortmnt dégrdr l rpdté d l rchrch. L clcul du hchg s ft prfos n 2 tmps 1. un foncton d hchg prtculèr à l'pplcton st utlsé pour produr un nombr ntr à prtr d l donné d'orgn 2. c nombr ntr st convrt n un poston possbl d l tbl, n générl n clculnt l rst modulo l tll d l tbl. Ls tlls ds tbls d hchg sont souvnt ds nombrs prmrs, fn d'évtr ls problèms d dvsurs communs, qu crérnt un nombr mportnt d collsons. Un ltrntv st d'utlsr un pussnc d dux, c qu prmt d rélsr l'opérton modulo pr d smpls déclgs, t donc d ggnr n rpdté. Un problèm fréqunt t surprnnt st l phénomèn d «clustrng» qu désgn l ft qu ds vlurs d hchg s rtrouvnt côt à côt dns l tbl, formnt ds «clustrs» («grpps» n frnçs). Cc st très pénlsnt pour ls tchnqus d résoluton ds collsons pr drssg ouvrt (vor c-près). Ls fonctons d hchg rélsnt un dstrbuton unform ds hchgs sont donc ls mllurs, ms sont n prtqu dffcl à trouvr. L foncton d hsh prmr (l flèch n hut) clcul un drss t génèr un collson. L prmèr cs lbr n ordr crossnt, c n blu, st trouvé t utlsé, consoldnt ns dux clustrs, provoqunt un congston supplémntr. Exrcc 8.10 Progrmmz n Python l foncton hshcod(s) d l chîn s d longuur n, qu rnvo l hchg ord(s[0])*32^(n 1) + ord(s[1])*32^(n 2) +... + ord(s[n 1]) mod N, où ord st l foncton qu rnvo l cod ASCII d'un crctèr t N l tll d l tbl d hchg. Tstz ctt foncton vc ls noms «Chco», «Groucho», «Gummo», «Hrpo», «Zppo» t N=5, pus N=11, pus N=12. 8.11.2. Résoluton ds collsons Lorsqu dux clés ont l mêm vlur d hchg, cs clés n puvnt êtr stockés à l mêm poston, on dot lors mployr un strtég d résoluton ds collsons. Pour donnr un dé d l'mportnc d'un bonn méthod d résoluton ds collsons, consdérons c résultt ssu du prdox ds nnvrsrs 3. Mêm s nous somms dns l cs l plus fvorbl où l foncton d hchg un dstrbuton unform, l y 95% d chncs d'vor un collson dns un tbl d tll 1 mllon vnt qu'll n contnn 2500 élémnts. 3 L prdox ds nnvrsrs st à l'orgn un stmton probblst du nombr d prsonns qu l'on dot réunr pour vor un chnc sur dux qu dux prsonns d c group nt lur nnvrsr l mêm jour d l'nné. Il s trouv qu c nombr st 23, c qu choqu l'ntuton. À prtr d'un group d 57 prsonns, l probblté st supérur à 99 %. 8-22
L'nformtqu u lycé Chptr 8 D nombruss strtégs d résoluton ds collsons xstnt ms ls plus connus t utlsés sont l chîng t l'drssg ouvrt. Chîng Ctt méthod st l plus smpl. Chqu cs d l tbl st n ft un lst chîné ds clés qu ont l mêm hchg. Un fos l cs trouvé, l rchrch st lors lnér n l tll d l lst chîné. Dns l pr ds cs où l foncton d hchg rnvo toujours l mêm vlur d hchg qull qu sot l clé, l tbl d hchg dvnt lors un lst chîné, t l tmps d rchrch st n O(n). L'vntg du chîng st qu l supprsson d'un clé st fcl ns qu l rchrch. D'utrs structurs d donnés qu ls lsts chînés puvnt êtr utlsés. En utlsnt un rbr équlbré, l coût théorqu d rchrch dns l pr ds cs st n O(log(n)). Cpndnt, l lst étnt supposé êtr court, ctt pproch st n générl pu ffcc à mons d'utlsr l tbl à s pln cpcté, ou d'vor un fort tux d collsons. Résoluton ds collsons pr chîng Adrssg ouvrt L'drssg ouvrt consst, dns l cs d'un collson, à stockr ls vlurs d hchg dns d'utrs lvéols vds. On ppll c procédé un méthod d sondg on ss ls lvéols h(k,0), h(k,1),..., jusqu'à c qu'on trouv un lvéol vd. Il y tros méthods d sondg Sondg lnér Sot H U {0,... N 1} un foncton d hchg uxlr. L foncton d sondg lnér sr h(k,) = (H(k) + ) mod N, vc = 0, 1,..., N 1 Résoluton ds collsons pr drssg ouvrt t sondg lnér 8-23
Structurs d donnés vncés Sondg qudrtqu Sot H U {0,... N 1} un foncton d hchg uxlr. L foncton d sondg qudrtqu sr h(k,) = (H(k) + c1 + c2 2) mod N, vc = 0, 1,..., N 1, c1 t c2 0 Doubl hchg Sont H1 t H2 U {0,... N 1} dux fonctons d hchg uxlrs. L foncton d sondg pr doubl hchg sr h(k,) = (H1(k) + H2(k)) mod N, vc = 0, 1,..., N 1, c1 t c2 0 Rchrch Lors d'un rchrch, s l'lvéol obtnu pr hchg drct n prmt ps d'obtnr l bonn clé, un rchrch sur ls css obtnus pr un méthod d sondg st ffctué jusqu'à trouvr l clé, ou tombr sur un lvéol vd, c qu ndqu qu'ucun clé d c typ n'pprtnt à l tbl. Supprsson Ctt mnèr d fr s'ppll n ngls «lzy dlton», supprsson prssus. Dns un drssg ouvrt, l supprsson d'un élémnt d l tbl d hchg st délct. Dns l schém c-près, s l'on supprm «John Smth» sns précuton, on n rtrouvr plus «Sndr D». L mnèr l plus smpl d s'n sortr st d n ps vdr llvéol où s trouvt «John Smth», ms d'y plcr l mot «Supprmé». On dstngur ns ls lvéols vds ds lvéols où un nom été ffcé un lvéol contnnt «Supprmé» sr consdéré comm occupé lors d'un supprsson, ms vd lors d'un nsrton. Fctur d chrg Un ndcton crtqu ds prformncs d'un tbl d hchg st l fctur d chrg qu st l proporton d css utlsés dns l tbl. Plus l fctur d chrg st proch d 100%, plus l nombr d sondgs à ffctur dvnt mportnt. Lorsqu l tbl st prsqu pln, ls lgorthms d sondg puvnt mêm échour ls puvnt n plus trouvr d'lvéol vd, lors qu'l y n ncor. L fctur d chrg st n générl lmté à 80%, mêm n dsposnt d'un bonn foncton d hchg. Ds fcturs d chrg fbls n sont ps pour utnt sgnfctfs d bonn prformnc, n prtculr s l foncton d hchg st muvs t génèr du clustrng. Exrcc 8.11 On souht stockr ds nombrs ntrs postfs n utlsnt un tbl d hchg. L tbl possédnt N mplcmnts (d 0 à N 1), on utls l clf suvnt h(x)=x modulo N. 1. Clculz l vlur d l clé pour chcun ds élémnts d l lst suvnt (N=12) 15, 24, 125, 4, 26, 6, 78, 55, 89, 16, 124 2. En supposnt qu ls élémnts sont nclus dns l tbl d hchg dns l'ordr d l lst t qu l résoluton ds collsons sot ft pr chîng, dssnz l tbl obtnu. 3. En supposnt qu ls élémnts sont nclus dns l tbl d hchg dns l'ordr d l lst t qu l résoluton ds collsons sot ft pr un sondg lnér, dssnz l tbl obtnu. Exrcc 8.12 Utlsz l foncton d hchg progrmmé dns l'xrcc 8.8 dns un tbl d tll N=12. Implémntz un clss «tbl_d_hchg». Écrvz un méthod «nsrr», qu nsèr un nouvl bonné (nom t numéro d téléphon) dns l'nnur. Écrvz un méthod «rchrchr», qu ffch l numéro d téléphon d'un bonné. S plusurs bonnés portnt l mêm nom, l méthod ffchr ls dfférnts numéros. Écrvz un méthod «supprmr», qu rtr un bonné d l'nnur. Tstz nsut votr progrmm vc ls donnés suvnts 8-24
L'nformtqu u lycé Chco Groucho Gummo Hrpo Zppo Zppo Chptr 8 0324661193 0324667543 0324664578 0324668501 0324660031 0324660032 Fts ct xrcc dux fos un fos n résolvnt ls collsons pr chîng t l'utr fos n ls résolvnt pr drssg ouvrt (vc un sondg lnér). Sourcs [1] Wkpéd, «Structurs d donnés», <http//fr.wkpd.org/wk/ctégorstructur_d_donnés> [2] Wkpéd, «Arbr (Structurs d donnés)», <http//fr.wkpd.org/wk/ctégorarbr_(structur_d_donnés)> [3] Wkpéd, «Arbr bnr», <http//fr.wkpd.org/wk/arbr_bnr> [4] Wkpéd, «Arbr bnr d rchrch», <http//fr.wkpd.org/wk/arbr_bnr_d_rchrch> [5] Wkpéd, «Arbr AVL», <http//fr.wkpd.org/wk/arbr_avl> [6] Frrro Tylr, «Ruzzl-Solvr», <https//gthub.com/tylrfrrro/ruzzl-solvr> [7] Mnnno Mro, «Ruzzl Solvr Algorthm», <http//mromnnno.com/ruzzl-solvr-lgorthm/> [8] Wkpéd, «Tbl d hchg», <http//fr.wkpd.org/wk/tbl_d_hchg> [9] Wkpéd, «Foncton d hchg», <http//fr.wkpd.org/wk/foncton_d_hchg> [10] Ncod Jn-Mrc, «Ls tbls d hchg», <http//fc.unv-fcomt.fr/~ncod/sldshshtbll3.pdf> [11] Wkpéd, «Théor d l complxté ds lgorthms», <http//fr.wkpd.org/wk/théor_d_l_complxté_ds_lgorthms> 8-25