Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found
Select Git revision
  • main
1 result

Target

Select target project
  • algorithmique/cours
  • aurelien.boyer/cours
  • jeremy.meissner/cours
  • radhwan.hassine/cours
  • yassin.elhakoun/cours-algo
  • gaspard.legouic/cours
  • joachim.bach/cours
  • gabriel.marinoja/algo-cours
  • loic.lavorel/cours
  • iliya.saroukha/cours
  • costanti.volta/cours
  • jacquesw.ndoumben/cours
12 results
Select Git revision
  • master
1 result
Show changes
Show whitespace changes
Inline Side-by-side
Showing
with 4814 additions and 760 deletions
slides/figs/kruskal_cycle.png 0 → 100644
View file @ febfc3f8
slides/figs/kruskal_cycle.png

61.1 KiB

slides/figs/kruskal_enonce.png 0 → 100644
View file @ febfc3f8
slides/figs/kruskal_enonce.png

184 KiB

slides/figs/kruskal_exercice.png 0 → 100644
View file @ febfc3f8
slides/figs/kruskal_exercice.png

185 KiB

slides/figs/kruskal_solution.png 0 → 100644
View file @ febfc3f8
slides/figs/kruskal_solution.png

312 KiB

slides/figs/kruskal_solution_exercice.png 0 → 100644
View file @ febfc3f8
slides/figs/kruskal_solution_exercice.png

218 KiB

slides/figs/matrix_qr.png 0 → 100644
View file @ febfc3f8
slides/figs/matrix_qr.png

1.93 KiB

slides/figs/stack_data_structure.svg 0 → 100644
View file @ febfc3f8
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!-- Created with Inkscape (http://www.inkscape.org/) -->
<svg xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:cc="http://creativecommons.org/ns#" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:svg="http://www.w3.org/2000/svg" xmlns="http://www.w3.org/2000/svg" xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd" xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape" width="900" height="300" id="svg2" sodipodi:version="0.32" inkscape:version="0.46" sodipodi:docname="Stack (data structure) - Kopia.svg" inkscape:output_extension="org.inkscape.output.svg.inkscape" version="1.0">
<defs id="defs4">
<marker inkscape:stockid="Arrow1Lstart" orient="auto" refY="0" refX="0" id="Arrow1Lstart" style="overflow:visible">
<path id="path3595" d="M 0,0 L 5,-5 L -12.5,0 L 5,5 L 0,0 z" style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;marker-start:none" transform="matrix(0.8,0,0,0.8,10,0)"/>
</marker>
<inkscape:perspective sodipodi:type="inkscape:persp3d" inkscape:vp_x="0 : 526.18109 : 1" inkscape:vp_y="0 : 1000 : 0" inkscape:vp_z="744.09448 : 526.18109 : 1" inkscape:persp3d-origin="372.04724 : 350.78739 : 1" id="perspective10"/>
<inkscape:perspective id="perspective2390" inkscape:persp3d-origin="372.04724 : 350.78739 : 1" inkscape:vp_z="744.09448 : 526.18109 : 1" inkscape:vp_y="0 : 1000 : 0" inkscape:vp_x="0 : 526.18109 : 1" sodipodi:type="inkscape:persp3d"/>
<inkscape:perspective id="perspective2397" inkscape:persp3d-origin="372.04724 : 350.78739 : 1" inkscape:vp_z="744.09448 : 526.18109 : 1" inkscape:vp_y="0 : 1000 : 0" inkscape:vp_x="0 : 526.18109 : 1" sodipodi:type="inkscape:persp3d"/>
</defs>
<sodipodi:namedview id="base" pagecolor="#ffffff" bordercolor="#666666" borderopacity="1.0" gridtolerance="10000" guidetolerance="10" objecttolerance="10" inkscape:pageopacity="0.0" inkscape:pageshadow="2" inkscape:zoom="1.979899" inkscape:cx="312.8503" inkscape:cy="205.85154" inkscape:document-units="px" inkscape:current-layer="layer1" showgrid="true" inkscape:window-width="1196" inkscape:window-height="702" inkscape:window-x="-8" inkscape:window-y="-8" inkscape:snap-bbox="true" inkscape:object-paths="true">
<inkscape:grid type="xygrid" id="grid2396" visible="true" enabled="false"/>
</sodipodi:namedview>
<metadata id="metadata7">
<rdf:RDF>
<cc:Work rdf:about="">
<dc:format>image/svg+xml</dc:format>
<dc:type rdf:resource="http://purl.org/dc/dcmitype/StillImage"/>
</cc:Work>
</rdf:RDF>
</metadata>
<g inkscape:label="Layer 1" inkscape:groupmode="layer" id="layer1" transform="translate(-11.994905,-782.85675)">
<g id="g5578" transform="translate(-23.246306,-18.180276)">
<path id="rect2392" d="M 61.055945,1044.6512 L 196.05595,1044.6512 L 196.05595,1069.3179 L 61.055945,1069.3179 L 61.055945,1044.6512 z" style="fill:none;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.5;stroke-linecap:round;stroke-linejoin:round;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;visibility:visible;display:inline;overflow:visible;enable-background:accumulate"/>
<path style="fill:none;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.5;stroke-linecap:round;stroke-linejoin:round;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;visibility:visible;display:inline;overflow:visible;enable-background:accumulate" d="M 61.055945,1019.9845 L 196.05595,1019.9845 L 196.05595,1044.6512 L 61.055945,1044.6512 L 61.055945,1019.9845 z" id="path3165"/>
<path id="path3167" d="M 61.055945,994.98453 L 196.05595,994.98453 L 196.05595,1019.6512 L 61.055945,1019.6512 L 61.055945,994.98453 z" style="fill:none;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.5;stroke-linecap:round;stroke-linejoin:round;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;visibility:visible;display:inline;overflow:visible;enable-background:accumulate"/>
<text sodipodi:linespacing="125%" id="text3169" y="1039.6512" x="46.568642" style="font-size:20px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Arial;-inkscape-font-specification:Arial" xml:space="preserve"><tspan y="1039.6512" x="46.568642" id="tspan3171" sodipodi:role="line">1</tspan></text>
<text sodipodi:linespacing="125%" id="text3173" y="1014.6512" x="46.055946" style="font-size:20px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Arial;-inkscape-font-specification:Arial" xml:space="preserve"><tspan y="1014.6512" x="46.055946" id="tspan3175" sodipodi:role="line">2</tspan></text>
<text sodipodi:linespacing="125%" id="text3177" y="989.52429" x="45.855751" style="font-size:20px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Arial;-inkscape-font-specification:Arial" xml:space="preserve"><tspan y="989.52429" x="45.855751" id="tspan3179" sodipodi:role="line">3</tspan></text>
<path style="fill:none;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.5;stroke-linecap:round;stroke-linejoin:round;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;visibility:visible;display:inline;overflow:visible;enable-background:accumulate" d="M 61.055945,969.98453 L 196.05595,969.98453 L 196.05595,994.65125 L 61.055945,994.65125 L 61.055945,969.98453 z" id="path2403"/>
<path id="path2405" d="M 61.055945,944.98453 L 196.05595,944.98453 L 196.05595,969.65125 L 61.055945,969.65125 L 61.055945,944.98453 z" style="fill:none;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.5;stroke-linecap:round;stroke-linejoin:round;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;visibility:visible;display:inline;overflow:visible;enable-background:accumulate"/>
<text xml:space="preserve" style="font-size:20px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Arial;-inkscape-font-specification:Arial" x="46.178017" y="964.62195" id="text2407" sodipodi:linespacing="125%"><tspan sodipodi:role="line" id="tspan2409" x="46.178017" y="964.62195">4</tspan><tspan id="tspan2415" sodipodi:role="line" x="46.178017" y="989.62195"/></text>
<text sodipodi:linespacing="125%" id="text2411" y="1064.1959" x="45.885048" style="font-size:20px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Arial;-inkscape-font-specification:Arial" xml:space="preserve"><tspan y="1064.1959" x="45.885048" id="tspan2413" sodipodi:role="line">0</tspan></text>
<path id="path2544" d="M 242.8671,1044.6512 L 377.8671,1044.6512 L 377.8671,1069.3179 L 242.8671,1069.3179 L 242.8671,1044.6512 z" style="fill:none;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.5;stroke-linecap:round;stroke-linejoin:round;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;visibility:visible;display:inline;overflow:visible;enable-background:accumulate"/>
<path style="fill:none;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.5;stroke-linecap:round;stroke-linejoin:round;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;visibility:visible;display:inline;overflow:visible;enable-background:accumulate" d="M 242.8671,1019.9845 L 377.8671,1019.9845 L 377.8671,1044.6512 L 242.8671,1044.6512 L 242.8671,1019.9845 z" id="path2546"/>
<path id="path2548" d="M 242.8671,994.98453 L 377.8671,994.98453 L 377.8671,1019.6512 L 242.8671,1019.6512 L 242.8671,994.98453 z" style="fill:none;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.5;stroke-linecap:round;stroke-linejoin:round;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;visibility:visible;display:inline;overflow:visible;enable-background:accumulate"/>
<text sodipodi:linespacing="125%" id="text2550" y="1039.6512" x="228.37979" style="font-size:20px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Arial;-inkscape-font-specification:Arial" xml:space="preserve"><tspan y="1039.6512" x="228.37979" id="tspan2552" sodipodi:role="line">1</tspan></text>
<text sodipodi:linespacing="125%" id="text2554" y="1014.6512" x="227.8671" style="font-size:20px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Arial;-inkscape-font-specification:Arial" xml:space="preserve"><tspan y="1014.6512" x="227.8671" id="tspan2556" sodipodi:role="line">2</tspan></text>
<text sodipodi:linespacing="125%" id="text2558" y="989.52429" x="227.6669" style="font-size:20px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Arial;-inkscape-font-specification:Arial" xml:space="preserve"><tspan y="989.52429" x="227.6669" id="tspan2560" sodipodi:role="line">3</tspan></text>
<path style="fill:none;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.5;stroke-linecap:round;stroke-linejoin:round;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;visibility:visible;display:inline;overflow:visible;enable-background:accumulate" d="M 242.8671,969.98453 L 377.8671,969.98453 L 377.8671,994.65125 L 242.8671,994.65125 L 242.8671,969.98453 z" id="path2562"/>
<path id="path2564" d="M 242.86711,944.98453 L 377.86711,944.98453 L 377.86711,969.65125 L 242.86711,969.65125 L 242.86711,944.98453 z" style="fill:none;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.5;stroke-linecap:round;stroke-linejoin:round;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;visibility:visible;display:inline;overflow:visible;enable-background:accumulate"/>
<text xml:space="preserve" style="font-size:20px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Arial;-inkscape-font-specification:Arial" x="227.98917" y="964.62195" id="text2566" sodipodi:linespacing="125%"><tspan sodipodi:role="line" id="tspan2568" x="227.98917" y="964.62195">4</tspan><tspan id="tspan2570" sodipodi:role="line" x="227.98917" y="989.62195"/></text>
<text sodipodi:linespacing="125%" id="text2572" y="1064.1959" x="227.6962" style="font-size:20px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Arial;-inkscape-font-specification:Arial" xml:space="preserve"><tspan y="1064.1959" x="227.6962" id="tspan2574" sodipodi:role="line">0</tspan></text>
<path id="path2580" d="M 424.67822,1044.6512 L 559.67822,1044.6512 L 559.67822,1069.3179 L 424.67822,1069.3179 L 424.67822,1044.6512 z" style="fill:none;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.5;stroke-linecap:round;stroke-linejoin:round;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;visibility:visible;display:inline;overflow:visible;enable-background:accumulate"/>
<path style="fill:none;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.5;stroke-linecap:round;stroke-linejoin:round;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;visibility:visible;display:inline;overflow:visible;enable-background:accumulate" d="M 424.67822,1019.9845 L 559.67822,1019.9845 L 559.67822,1044.6512 L 424.67822,1044.6512 L 424.67822,1019.9845 z" id="path2582"/>
<path id="path2584" d="M 424.67822,994.98453 L 559.67822,994.98453 L 559.67822,1019.6512 L 424.67822,1019.6512 L 424.67822,994.98453 z" style="fill:none;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.5;stroke-linecap:round;stroke-linejoin:round;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;visibility:visible;display:inline;overflow:visible;enable-background:accumulate"/>
<text sodipodi:linespacing="125%" id="text2586" y="1039.6512" x="410.19092" style="font-size:20px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Arial;-inkscape-font-specification:Arial" xml:space="preserve"><tspan y="1039.6512" x="410.19092" id="tspan2588" sodipodi:role="line">1</tspan></text>
<text sodipodi:linespacing="125%" id="text2590" y="1014.6512" x="409.67822" style="font-size:20px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Arial;-inkscape-font-specification:Arial" xml:space="preserve"><tspan y="1014.6512" x="409.67822" id="tspan2592" sodipodi:role="line">2</tspan></text>
<text sodipodi:linespacing="125%" id="text2594" y="989.52429" x="409.47803" style="font-size:20px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Arial;-inkscape-font-specification:Arial" xml:space="preserve"><tspan y="989.52429" x="409.47803" id="tspan2596" sodipodi:role="line">3</tspan></text>
<path style="fill:none;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.5;stroke-linecap:round;stroke-linejoin:round;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;visibility:visible;display:inline;overflow:visible;enable-background:accumulate" d="M 424.67822,969.98453 L 559.67822,969.98453 L 559.67822,994.65125 L 424.67822,994.65125 L 424.67822,969.98453 z" id="path2598"/>
<path id="path2600" d="M 424.67822,944.98453 L 559.67822,944.98453 L 559.67822,969.65125 L 424.67822,969.65125 L 424.67822,944.98453 z" style="fill:none;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.5;stroke-linecap:round;stroke-linejoin:round;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;visibility:visible;display:inline;overflow:visible;enable-background:accumulate"/>
<text xml:space="preserve" style="font-size:20px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Arial;-inkscape-font-specification:Arial" x="409.80029" y="964.62195" id="text2602" sodipodi:linespacing="125%"><tspan sodipodi:role="line" id="tspan2604" x="409.80029" y="964.62195">4</tspan><tspan id="tspan2606" sodipodi:role="line" x="409.80029" y="989.62195"/></text>
<text sodipodi:linespacing="125%" id="text2608" y="1064.1959" x="409.50732" style="font-size:20px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Arial;-inkscape-font-specification:Arial" xml:space="preserve"><tspan y="1064.1959" x="409.50732" id="tspan2610" sodipodi:role="line">0</tspan></text>
<path id="path2616" d="M 606.48937,1044.6512 L 741.48937,1044.6512 L 741.48937,1069.3179 L 606.48937,1069.3179 L 606.48937,1044.6512 z" style="fill:none;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.5;stroke-linecap:round;stroke-linejoin:round;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;visibility:visible;display:inline;overflow:visible;enable-background:accumulate"/>
<path style="fill:none;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.5;stroke-linecap:round;stroke-linejoin:round;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;visibility:visible;display:inline;overflow:visible;enable-background:accumulate" d="M 606.48937,1019.9845 L 741.48937,1019.9845 L 741.48937,1044.6512 L 606.48937,1044.6512 L 606.48937,1019.9845 z" id="path2618"/>
<path id="path2620" d="M 606.48937,994.98453 L 741.48937,994.98453 L 741.48937,1019.6512 L 606.48937,1019.6512 L 606.48937,994.98453 z" style="fill:none;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.5;stroke-linecap:round;stroke-linejoin:round;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;visibility:visible;display:inline;overflow:visible;enable-background:accumulate"/>
<text sodipodi:linespacing="125%" id="text2622" y="1039.6512" x="592.00208" style="font-size:20px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Arial;-inkscape-font-specification:Arial" xml:space="preserve"><tspan y="1039.6512" x="592.00208" id="tspan2624" sodipodi:role="line">1</tspan></text>
<text sodipodi:linespacing="125%" id="text2626" y="1014.6512" x="591.48938" style="font-size:20px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Arial;-inkscape-font-specification:Arial" xml:space="preserve"><tspan y="1014.6512" x="591.48938" id="tspan2628" sodipodi:role="line">2</tspan></text>
<text sodipodi:linespacing="125%" id="text2630" y="989.52429" x="591.28918" style="font-size:20px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Arial;-inkscape-font-specification:Arial" xml:space="preserve"><tspan y="989.52429" x="591.28918" id="tspan2632" sodipodi:role="line">3</tspan></text>
<path style="fill:none;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.5;stroke-linecap:round;stroke-linejoin:round;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;visibility:visible;display:inline;overflow:visible;enable-background:accumulate" d="M 606.48937,969.98453 L 741.48937,969.98453 L 741.48937,994.65125 L 606.48937,994.65125 L 606.48937,969.98453 z" id="path2634"/>
<path id="path2636" d="M 606.48937,944.98453 L 741.48937,944.98453 L 741.48937,969.65125 L 606.48937,969.65125 L 606.48937,944.98453 z" style="fill:none;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.5;stroke-linecap:round;stroke-linejoin:round;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;visibility:visible;display:inline;overflow:visible;enable-background:accumulate"/>
<text xml:space="preserve" style="font-size:20px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Arial;-inkscape-font-specification:Arial" x="591.61145" y="964.62195" id="text2638" sodipodi:linespacing="125%"><tspan sodipodi:role="line" id="tspan2640" x="591.61145" y="964.62195">4</tspan><tspan id="tspan2642" sodipodi:role="line" x="591.61145" y="989.62195"/></text>
<text sodipodi:linespacing="125%" id="text2644" y="1064.1959" x="591.31848" style="font-size:20px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Arial;-inkscape-font-specification:Arial" xml:space="preserve"><tspan y="1064.1959" x="591.31848" id="tspan2646" sodipodi:role="line">0</tspan></text>
<g transform="translate(769.3005,38.058349)" id="g2650">
<path style="fill:none;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.5;stroke-linecap:round;stroke-linejoin:round;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;visibility:visible;display:inline;overflow:visible;enable-background:accumulate" d="M 19,1006.5929 L 154,1006.5929 L 154,1031.2596 L 19,1031.2596 L 19,1006.5929 z" id="path2652"/>
<path id="path2654" d="M 19,981.92618 L 154,981.92618 L 154,1006.5929 L 19,1006.5929 L 19,981.92618 z" style="fill:none;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.5;stroke-linecap:round;stroke-linejoin:round;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;visibility:visible;display:inline;overflow:visible;enable-background:accumulate"/>
<path style="fill:none;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.5;stroke-linecap:round;stroke-linejoin:round;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;visibility:visible;display:inline;overflow:visible;enable-background:accumulate" d="M 19,956.92618 L 154,956.92618 L 154,981.5929 L 19,981.5929 L 19,956.92618 z" id="path2656"/>
<text xml:space="preserve" style="font-size:20px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Arial;-inkscape-font-specification:Arial" x="4.5126953" y="1001.5929" id="text2658" sodipodi:linespacing="125%"><tspan sodipodi:role="line" id="tspan2660" x="4.5126953" y="1001.5929">1</tspan></text>
<text xml:space="preserve" style="font-size:20px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Arial;-inkscape-font-specification:Arial" x="4" y="976.5929" id="text2662" sodipodi:linespacing="125%"><tspan sodipodi:role="line" id="tspan2664" x="4" y="976.5929">2</tspan></text>
<text xml:space="preserve" style="font-size:20px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Arial;-inkscape-font-specification:Arial" x="3.7998047" y="951.46594" id="text2666" sodipodi:linespacing="125%"><tspan sodipodi:role="line" id="tspan2668" x="3.7998047" y="951.46594">3</tspan></text>
<path id="path2670" d="M 19,931.92618 L 154,931.92618 L 154,956.5929 L 19,956.5929 L 19,931.92618 z" style="fill:none;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.5;stroke-linecap:round;stroke-linejoin:round;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;visibility:visible;display:inline;overflow:visible;enable-background:accumulate"/>
<path style="fill:none;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.5;stroke-linecap:round;stroke-linejoin:round;marker:none;marker-start:none;marker-mid:none;marker-end:none;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;visibility:visible;display:inline;overflow:visible;enable-background:accumulate" d="M 19,906.92618 L 154,906.92618 L 154,931.5929 L 19,931.5929 L 19,906.92618 z" id="path2672"/>
<text sodipodi:linespacing="125%" id="text2674" y="926.5636" x="4.1220703" style="font-size:20px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Arial;-inkscape-font-specification:Arial" xml:space="preserve"><tspan y="926.5636" x="4.1220703" id="tspan2676" sodipodi:role="line">4</tspan><tspan y="951.5636" x="4.1220703" sodipodi:role="line" id="tspan2678"/></text>
<text xml:space="preserve" style="font-size:20px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Arial;-inkscape-font-specification:Arial" x="3.8291016" y="1026.1376" id="text2680" sodipodi:linespacing="125%"><tspan sodipodi:role="line" id="tspan2682" x="3.8291016" y="1026.1376">0</tspan></text>
</g>
<text sodipodi:linespacing="125%" id="text2684" y="1064.1427" x="303.69717" style="font-size:20px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Arial;-inkscape-font-specification:Arial" xml:space="preserve"><tspan y="1064.1427" x="303.69717" id="tspan2686" sodipodi:role="line">A</tspan></text>
<text sodipodi:linespacing="125%" id="text2688" y="1039.4761" x="485.30811" style="font-size:20px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Arial;-inkscape-font-specification:Arial" xml:space="preserve"><tspan y="1039.4761" x="485.30811" id="tspan2690" sodipodi:role="line">B</tspan></text>
<text xml:space="preserve" style="font-size:20px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Arial;-inkscape-font-specification:Arial" x="485.5083" y="1064.1427" id="text2763" sodipodi:linespacing="125%"><tspan sodipodi:role="line" id="tspan2765" x="485.5083" y="1064.1427">A</tspan></text>
<text xml:space="preserve" style="font-size:20px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Arial;-inkscape-font-specification:Arial" x="121.88602" y="846.32251" id="text2816" sodipodi:linespacing="125%"><tspan sodipodi:role="line" id="tspan2818" x="121.88602" y="846.32251">A</tspan></text>
<g transform="translate(-110.82003,-12.8571)" id="g5458">
<g id="g5454">
<path style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;marker-start:none;stroke-opacity:1" d="M 239.37598,930.5929 L 239.37598,885.5929" id="path4887" sodipodi:nodetypes="cs"/>
<path sodipodi:nodetypes="ccc" transform="translate(4.3759766,771.5929)" id="path5452" d="M 230,149 L 235,159 L 240,149" style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"/>
</g>
</g>
<text xml:space="preserve" style="font-size:20px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Arial;-inkscape-font-specification:Arial" x="303.49698" y="846.32251" id="text5496" sodipodi:linespacing="125%"><tspan sodipodi:role="line" id="tspan5498" x="303.49698" y="846.32251">B</tspan></text>
<g id="g5500" transform="translate(70.991133,-12.8571)">
<g id="g5502">
<path sodipodi:nodetypes="cs" id="path5504" d="M 239.37598,930.5929 L 239.37598,885.5929" style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;marker-start:none;stroke-opacity:1"/>
<path style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" d="M 230,149 L 235,159 L 240,149" id="path5506" transform="translate(4.3759766,771.5929)" sodipodi:nodetypes="ccc"/>
</g>
</g>
<text sodipodi:linespacing="125%" id="text5508" y="846.32251" x="485.30811" style="font-size:20px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Arial;-inkscape-font-specification:Arial" xml:space="preserve"><tspan y="846.32251" x="485.30811" id="tspan5510" sodipodi:role="line">B</tspan></text>
<g transform="matrix(1,0,0,-1,252.80224,1803.3287)" id="g5512">
<g id="g5514">
<path style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;marker-start:none;stroke-opacity:1" d="M 239.37598,930.5929 L 239.37598,885.5929" id="path5516" sodipodi:nodetypes="cs"/>
<path sodipodi:nodetypes="ccc" transform="translate(4.3759766,771.5929)" id="path5518" d="M 230,149 L 235,159 L 240,149" style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"/>
</g>
</g>
<text sodipodi:linespacing="125%" id="text5520" y="1064.1427" x="485.5083" style="font-size:20px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Arial;-inkscape-font-specification:Arial" xml:space="preserve"><tspan y="1064.1427" x="485.5083" id="tspan5522" sodipodi:role="line">A</tspan></text>
<text xml:space="preserve" style="font-size:20px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Arial;-inkscape-font-specification:Arial" x="667.31946" y="1064.1427" id="text5558" sodipodi:linespacing="125%"><tspan sodipodi:role="line" id="tspan5560" x="667.31946" y="1064.1427">A</tspan></text>
<g id="g5566" transform="matrix(1,0,0,-1,434.61339,1803.3287)">
<g id="g5568">
<path sodipodi:nodetypes="cs" id="path5570" d="M 239.37598,930.5929 L 239.37598,885.5929" style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;marker-start:none;stroke-opacity:1"/>
<path style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" d="M 230,149 L 235,159 L 240,149" id="path5572" transform="translate(4.3759766,771.5929)" sodipodi:nodetypes="ccc"/>
</g>
</g>
<text xml:space="preserve" style="font-size:20px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Arial;-inkscape-font-specification:Arial" x="667.31946" y="846.32251" id="text5574" sodipodi:linespacing="125%"><tspan sodipodi:role="line" id="tspan5576" x="667.31946" y="846.32251">A</tspan></text>
</g>
</g>
<script xmlns="" public-path="moz-extension://ff8cca0e-5336-417a-b78e-a0d94c485783/"/></svg>
\ No newline at end of file
slides/figs/tri_insertion.svg
View file @ febfc3f8
......@@ -6,7 +6,7 @@
version="1.2"
id="svg451"
sodipodi:docname="tri_insertion.svg"
inkscape:version="1.1.1 (3bf5ae0d25, 2021-09-20)"
inkscape:version="1.2.1 (9c6d41e410, 2022-07-14, custom)"
xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
xmlns:xlink="http://www.w3.org/1999/xlink"
......@@ -27,14 +27,16 @@
fit-margin-right="0"
fit-margin-bottom="0"
inkscape:zoom="1.3787842"
inkscape:cx="244.41824"
inkscape:cy="70.714476"
inkscape:cx="127.64869"
inkscape:cy="70.351836"
inkscape:window-width="1920"
inkscape:window-height="1080"
inkscape:window-height="1007"
inkscape:window-x="0"
inkscape:window-y="0"
inkscape:window-maximized="1"
inkscape:current-layer="svg451" />
inkscape:current-layer="svg451"
inkscape:showpageshadow="2"
inkscape:deskcolor="#d1d1d1" />
<defs
id="defs118">
<g
......@@ -310,14 +312,9 @@
height="100%"
style="fill:#000000;fill-opacity:1"
transform="translate(-0.05000001,0.07642544)" />
<g
id="g4296"
transform="translate(-0.05000001,0.07642544)">
<g
id="g4183">
<path
style="fill:#85cfff;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0.9;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:10;stroke-opacity:1"
d="m 36.5,49.10156 h 36 v -36 h -36 z m 0,0"
d="m 36.45,49.177985 h 36 v -36 h -36 z m 0,0"
id="path132" />
<use
xlink:href="#glyph0-1"
......@@ -326,7 +323,8 @@
id="use136"
width="100%"
height="100%"
style="fill:#000000;fill-opacity:1" />
style="fill:#000000;fill-opacity:1"
transform="translate(-0.05000001,0.07642544)" />
<use
xlink:href="#glyph0-2"
x="18.5"
......@@ -334,7 +332,8 @@
id="use138"
width="100%"
height="100%"
style="fill:#000000;fill-opacity:1" />
style="fill:#000000;fill-opacity:1"
transform="translate(-0.05000001,0.07642544)" />
<use
xlink:href="#glyph0-2"
x="153.5"
......@@ -342,7 +341,8 @@
id="use214"
width="100%"
height="100%"
style="fill:#000000;fill-opacity:1" />
style="fill:#000000;fill-opacity:1"
transform="translate(-0.05000001,0.07642544)" />
<use
xlink:href="#glyph0-7"
x="162.5"
......@@ -350,7 +350,8 @@
id="use216"
width="100%"
height="100%"
style="fill:#000000;fill-opacity:1" />
style="fill:#000000;fill-opacity:1"
transform="translate(-0.05000001,0.07642544)" />
<use
xlink:href="#glyph0-5"
x="45.5"
......@@ -358,7 +359,8 @@
id="use220"
width="100%"
height="100%"
style="fill:#000000;fill-opacity:1" />
style="fill:#000000;fill-opacity:1"
transform="translate(-0.05000001,0.07642544)" />
<use
xlink:href="#glyph0-6"
x="189.5"
......@@ -366,7 +368,8 @@
id="use288"
width="100%"
height="100%"
style="fill:#000000;fill-opacity:1" />
style="fill:#000000;fill-opacity:1"
transform="translate(-0.05000001,0.07642544)" />
<use
xlink:href="#glyph0-4"
x="117.5"
......@@ -374,7 +377,8 @@
id="use296"
width="100%"
height="100%"
style="fill:#000000;fill-opacity:1" />
style="fill:#000000;fill-opacity:1"
transform="translate(-31.26875,0.07642544)" />
<use
xlink:href="#glyph0-3"
x="81.5"
......@@ -382,38 +386,39 @@
id="use300"
width="100%"
height="100%"
style="fill:#000000;fill-opacity:1" />
style="fill:#000000;fill-opacity:1"
transform="translate(40.715625,0.07642544)" />
<path
style="clip-rule:evenodd;fill:none;stroke:#000000;stroke-width:0.9;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:10;stroke-opacity:1"
d="m 54.5,4.10156 h -36"
d="m 54.45,4.1779854 h -36"
id="path304" />
<path
style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0.9;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:10;stroke-opacity:1"
d="M 34.820312,0.5 20.417969,4.10156 34.820312,7.69922 Z m 0,0"
d="m 34.770312,0.57642544 -14.402343,3.60155996 14.402343,3.59766 z m 0,0"
id="path310" />
<path
style="clip-rule:nonzero;fill:none;stroke:#000000;stroke-width:0.9;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:10;stroke-opacity:1"
d="m 180.5,49.10156 h 36 v -36 h -36 z m 0,0"
d="m 180.45,49.177985 h 36 v -36 h -36 z m 0,0"
id="path312" />
<path
style="fill:none;stroke:#000000;stroke-width:0.9;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:10;stroke-opacity:1"
d="m 144.5,49.10156 h 36 v -36 h -36 z m 0,0"
d="m 144.45,49.177985 h 36 v -36 h -36 z m 0,0"
id="path316" />
<path
style="fill:none;stroke:#000000;stroke-width:0.9;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:10;stroke-opacity:1"
d="m 108.5,49.10156 h 36 v -36 h -36 z m 0,0"
d="m 108.45,49.177985 h 36 v -36 h -36 z m 0,0"
id="path318" />
<path
style="fill:none;stroke:#000000;stroke-width:0.9;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:10;stroke-opacity:1"
d="m 72.5,49.10156 h 36 v -36 h -36 z m 0,0"
d="m 72.45,49.177985 h 36 v -36 h -36 z m 0,0"
id="path320" />
<path
style="fill:none;stroke:#000000;stroke-width:0.9;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:10;stroke-opacity:1"
d="m 0.5,49.10156 h 36 v -36 h -36 z m 0,0"
d="M 0.44999999,49.177985 H 36.45 v -36 H 0.44999999 Z m 0,0"
id="path322" />
</g>
<g
id="g4165">
id="g4165"
transform="translate(-0.05000001,0.07642544)">
<path
style="fill:#85cfff;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0.9;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:10;stroke-opacity:1"
d="m 108.5,168.75781 h 36 v -36 h -36 z m 0,0"
......@@ -521,7 +526,7 @@
</g>
<g
id="g1537"
transform="translate(0,-12.171875)">
transform="translate(-0.05000001,-12.09545)">
<path
style="fill:#85cfff;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0.9;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:10;stroke-opacity:1"
d="m 72.5,121.10156 h 36 v -36 h -36 z m 0,0"
......@@ -621,7 +626,7 @@
</g>
<g
id="g4147"
transform="translate(-20.072045,-17.85576)">
transform="translate(-20.122045,-17.779335)">
<use
xlink:href="#glyph0-1"
x="189.5"
......@@ -811,7 +816,7 @@
</g>
<g
id="g4103"
transform="translate(-20.072045,-0.680515)">
transform="translate(-20.122045,-0.60408956)">
<path
style="clip-rule:nonzero;fill:#85cfff;fill-opacity:1;fill-rule:evenodd;stroke:none"
d="m 439.79137,109.6102 h 36 V 73.610197 h -36 z m 0,0"
......@@ -923,7 +928,7 @@
</g>
<g
id="g4121"
transform="translate(-20.072045,0.487993)">
transform="translate(-20.122045,0.56441844)">
<path
style="fill:#85cfff;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:0.9;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:10;stroke-opacity:1"
d="m 403.79137,48.613567 h 36 v -36 h -36 z m 0,0"
......@@ -1029,5 +1034,4 @@
d="m 259.79137,48.613567 h 36 v -36 h -36 z m 0,0"
id="path448" />
</g>
</g>
</svg>
slides/gen_index.sh
View file @ febfc3f8
......@@ -38,7 +38,7 @@ for i in *.md; do
fail "Error title field not found"
fi
i="${i%.*}"
class="[${date} ${comp}](${PREFIX}${i}.pdf)"
class="[${date}: ${comp}](${PREFIX}${i}.pdf)"
classes+=("$class")
done
IFS=$'\n'
......
slides/intro.md
View file @ febfc3f8
---
title: "Introduction générale"
date: "2020-09-16"
date: "2024-09-16"
---
# La hotline
......@@ -11,59 +11,42 @@ Paul Albuquerque paul.albuquerque@hesge.ch B410
Orestis Malaspinas orestis.malaspinas@hesge.ch A401
-------------------- ------------------------------ --------------------
Utilisez le libre service (l'horaire sera fixé prochainement).
- Utilisez le libre service (l'horaire sera fixé prochainement).
- On va intensivement utiliser *Element*, installez le et utilisez le!
- Espace de discussion Matrix: <https://rb.gy/ku5es>, installez [element.io](https://element.io).
Salon de discussion [Matrix](https://matrix.to/#/!tuZtXjUSPbnRfBsFXv:matrix.org?via=matrix.org), installez [element.io](https://element.io).
![](figs/matrix.png){width=20%}
![](figs/matrix_qr.png){width=20%}
# Cyberlearn
Tout le contenu de ce qu'on raconte se trouve sur cyberlearn:
- Algorithmes et structures de données
- <https://cyberlearn.hes-so.ch/course/view.php?id=13941>
- Clé d'inscription: algo_2020_21
- <https://cyberlearn.hes-so.ch/course/view.php?id=7276>
- Clé d'inscription: algo_2024_25
- Programmation Sequentielle en C
- <https://cyberlearn.hes-so.ch/course/view.php?id=12399>
- Clé d'inscription: PS_2018
- <https://cyberlearn.hes-so.ch/course/view.php?id=7282>
- Clé d'inscription: prog_seq_2024_25
# Organisation du module
* Deux cours, 50% chacun.
1. Algorithmes et structures de données:
## Cinq cours, 20% chacun.
1. Algorithmes et structures de données (2 semestres):
* 1er semestre:
* bases de programmation en C jusqu'à Noël.
* algorithmique jusqu'à fin janvier.
* 2e semestre:
* algorithmique.
* Deux évaluations écrites par semestre.
2. Programmation séquentielle en C
* Deux évaluations écrites par semestre (1er sem.: novembre et janvier).
2. Programmation séquentielle en C (2 semestres)
* Familiarisation avec l'environnement Linux.
* Travaux pratiques en C.
* Apprentissage du gestionnaire de versions: git.
* Plusieurs "petits" exercices illustrant les concepts d'algorithmique
(1-2 séances).
* Évaluations:
* Un projet de programmation.
* Une évaluation machine.
# Sondage: expérience de programmation
## [Sondage: expérience de linux](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=1291283)
## [Sondage: expérience de programmation](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=1035242)
**Installez un lecteur de QR code s'il-vous-plaît.**
# Questions?
- N'hésitez pas à poser des *questions*, nous sommes là pour ça! [^1]
- Ne restez pas coincés pendant des jours sur un problème.
- Utilisez le *libre-service*!
- N'hésitez pas à faire des *retours*: *négatifs* ou *positifs*.
[^1]: Chaque étudiant·e·s a un quota de 5 questions par semestre.
* Plusieurs exercices illustrant les concepts d'algorithmique.
* Évaluations (4 tests machine).
3. Programmation système
slides/metadata.yaml
View file @ febfc3f8
---
subtitle: "Algorithmique et structures de données, 2021-2022"
author: "Paul Albuquerque (B410), Pierre Künzli et Orestis Malaspinas (A401), ISC, HEPIA"
subtitle: "Algorithmique et structures de données, 2024-2025"
author: "P. Albuquerque (B410) et O. Malaspinas (A401), ISC, HEPIA"
institute: En partie inspirés des supports de cours de P. Albuquerque
lang: fr-CH
revealjs-url: /reveal.js
......
slides_2021/.gitignore 0 → 100644
View file @ febfc3f8
*.pdf
*.err
*.markdown
*.html
index.md
.puppeteer.json
slides_2021/Makefile 0 → 100644
View file @ febfc3f8
PDFOPTIONS = -t beamer
# PDFOPTIONS += -F pantable
PDFOPTIONS += -F mermaid-filter
PDFOPTIONS += --highlight-style my_highlight.theme
PDFOPTIONS += --pdf-engine xelatex
PDFOPTIONS += -V theme:metropolis
PDFOPTIONS += -V themeoptions:numbering=none -V themeoptions:progressbar=foot
PDFOPTIONS += -V fontsize=smaller
PDFOPTIONS += -V urlcolor=blue
REVEALOPTIONS = -t revealjs
REVEALOPTIONS += -F mermaid-filter
REVEALOPTIONS += --self-contained
REVEALOPTIONS += -V revealjs-url=reveal.js
REVEALOPTIONS += -V theme=white
REVEALOPTIONS += -V width=1920
REVEALOPTIONS += -V margin=0
REVEALOPTIONS += --slide-level=1
MD=$(wildcard *.md) # Tous les fichiers .md
PDF=$(MD:%.md=%.pdf) # Pour les fichier pdf on transforme .md -> .pdf
HTML=$(MD:%.md=%.html) # Pour les fichier html on transforme .md -> .html
MARKDOWN=$(MD:%.md=%.markdown) # Pour les fichier markdown on transforme .md -> .markdown
CHROMIUM:=$(shell which chromium || which chromium-browser)
all: puppeteer $(PDF)
# all: puppeteer $(PDF) $(HTML) # La cible par défaut (all) exécute les cibles %.pdf
docker: docker-compose.yml
docker-compose run slides make puppeteer -k || true
docker-compose run slides make all -k || true
docker_clean: docker-compose.yml
docker-compose run slides make clean -k || true
puppeteer:
@echo "Setting chromium to $(CHROMIUM) for puppeteer"
@echo -e "{\n\"executablePath\":" \"$(CHROMIUM)\" ",\n\"args\": [\"--no-sandbox\"]\n}" > .puppeteer.json
index:
rm -f index.md
./gen_index.sh
markdown: $(MARKDOWN) # La markdown les cibles %.markdown
%.pdf: %.md metadata.yaml # %.pdf (chaque fichier %.md génère un fichier avec le même nom mais l'extension .pdf et la dépendance metadata.yaml)
pandoc -s $(OPTIONS) $(PDFOPTIONS) -o $@ $^
%.html: %.md metadata.yaml
pandoc -s $(OPTIONS) $(REVEALOPTIONS) -o $@ $^
%.markdown: %.md metadata.yaml yq
sed '1 { /^---/ { :a N; /\n---/! ba; d} }' $< > no_header
grep -v -F -x -f no_header $< > header.yaml
echo "---" > tmp.yaml
./yq_linux_amd64 merge metadata.yaml header.yaml >> tmp.yaml
cat tmp.yaml no_header > $@
rm no_header header.yaml tmp.yaml
yq: # On peut même télécharger un petit programme avec notre makefile
wget -nc https://github.com/mikefarah/yq/releases/download/3.4.1/yq_linux_amd64
chmod "u+x" yq_linux_amd64
deploy: all
mkdir -p algo_cours
cp *.pdf algo_cours
clean:
rm -f *.html *.pdf *.markdown yq_linux_amd64* index.md .puppeteer.json
.PHONY: clean index puppeteer yq
slides_2021/cours_1.md 0 → 100644
View file @ febfc3f8
---
title: "Introduction aux algorithmes"
date: "2021-09-22"
---
# Qu'est-ce qu'un algorithme?
## Définition informelle (recette)
* des entrées (les ingrédients, le matériel utilisé) ;
* des instructions élémentaires simples (frire, flamber, etc.), dont les
exécutions dans un ordre précis amènent au résultat voulu ;
* un résultat : le plat préparé.
. . .
## Histoire et étymologie
- Existent depuis 4500 ans au moins (algorithme de division, crible
d'Eratosthène).
- Le mot algorithme est dérivé du nom du mathématicien perse
*Muḥammad ibn Musā al-Khwārizmī*, qui a été "latinisé" comme
*Algoritmi*.
. . .
## Définition formelle
En partant d'un état initial et d'entrées (peut-être vides), une séquence finie
d'instruction bien définies (ordonnées) implémentables sur un ordinateur, afin
de résoudre typiquement une classe de problèmes ou effectuer un calcul.
# Notions de base d'algorithmique
## Variable
. . .
* Paire: identifiant - valeur (assignation);
## Séquence d'instructions / expressions
. . .
* Opérateurs (arthimétiques / booléens)
* Boucles;
* Structures de contrôle;
* Fonctions;
# Algorithme de vérification qu'un nombre est premier (1/3)
Nombre premier: nombre possédant deux diviseurs entiers distincts.
. . .
## Algorithme naïf (problème)
```C
est_premier(nombre) {
si {
pour tout i, t.q. 1 < i < nombre {
i ne divise pas nombre
}
} alors vrai
sinon faux
}
```
. . .
## Pas vraiment un algorithme: pas une séquence ordonnée et bien définie
. . .
## Problème: Comment écrire ça sous une forme algorithmique?
# Algorithme de vérification qu'un nombre est premier (2/3)
## Algorithme naïf (une solution)
```C
est_premier(nombre) { // fonction
soit i := 2; // variable, type, assignation
tant que i < nombre { // boucle
si nombre modulo i = 0 { // expression typée
retourne faux // expression typée
}
i := i + 1
}
retourne vrai // expression typée
```
# Algorithme de vérification qu'un nombre est premier (3/3)
## Algorithme naïf (une solution en C)
```C
bool est_premier(int nombre) {
int i; // i est un entier
i = 2; // assignation i à 2
while (i < nombre) { // boucle avec condition
if (0 == nombre % i) { // is i divise nombre
return false; // i n'est pas premier
}
i += 1; // sinon on incrémente i
}
return true;
}
```
. . .
## Exercice: Comment faire plus rapide?
# Génération d'un exécutable
- Pour pouvoir être exécuté un code C doit être d'abord compilé (avec `gcc` ou `clang`).
- Pour un code `prog.c` la compilation "minimale" est
```bash
$ gcc prog.c
$ ./a.out # exécutable par défaut
```
- Il existe une multitude d'options de compilation:
```bash
$ gcc -O1 -std=c11 -Wall -Wextra -g porg.c -o prog -fsanitize=address
-fsanitize=leak -fsanitize=undefined
```
1. `-std=c11` utilisation de C11.
2. `-Wall et -Wextra` activation des warnings.
3. `-fsanitize=…` contrôles d’erreurs à l’exécution (coût en performance).
4. `-g` symboles de débogages sont gardés.
5. `-o` défini le fichier exécutable à produire en sortie.
6. `-O1`, `-O2`, `-O3`: activation de divers degrés d'optimisation
# La simplicité de C?
## 32 mots-clé et c'est tout
---------------- -------------- ---------------- ---------------
`auto`{.C} `double`{.C} `int`{.C} `struct`{.C}
`break`{.C} `else`{.C} `long`{.C} `switch`{.C}
`case`{.C} `enum`{.C} `register`{.C} `typedef`{.C}
`char`{.C} `extern`{.C} `return`{.C} `union`{.C}
`const`{.C} `float`{.C} `short`{.C} `unsigned`{.C}
`continue`{.C} `for`{.C} `signed`{.C} `void`{.C}
`default`{.C} `goto`{.C} `sizeof`{.C} `volatile`{.C}
`do`{.C} `if`{.C} `static`{.C} `while`{.C}
---------------- -------------- ---------------- ---------------
# Déclaration et typage
En C lorsqu'on veut utiliser une variable (ou une constante), on doit déclarer son type
```C
const double two = 2.0; // déclaration et init.
int x; // déclaration (instruction)
char c; // déclaration (instruction)
x = 1; // affectation (expression)
c = 'a'; // affectation (expression)
int y = x; // déclaration et initialisation en même temps
int a, b, c; // déclarations multiples
a = b = c = 1; // init. multiples
```
# Les variables (1/2)
## Variables et portée
- Une variable est un identifiant, qui peut être liée à une valeur (un expression).
- Une variable a une **portée** qui définit où elle est *visible* (où elle peut être accédée).
- La portée est **globale** ou **locale**.
- Une variable est **globale** est accessible à tout endroit d'un programme et doit être déclarée en dehors de toute fonction.
- Une variable est **locale** lorsqu'elle est déclarée dans un **bloc**, `{...}`{.C}.
- Une variable est dans la portée **après** avoir été déclarée.
# Les variables (2/2)
## Exemple
```C
float max; // variable globale accessible partout
int foo() {
// max est visible ici
float a = max; // valide
// par contre les varibles du main() ne sont pas visibles
}
int main() {
// max est visible ici
int x = 1; // x est locale à main
{
// x est visible ici, y pas encore
// on peut par exemple pas faire x = y;
int y = 2;
} // y est détruite à la sortie du bloc
} // x est à la sortie de main
```
<!-- TODO: quiz, compile, compile pas -->
<!-- ```C
int main() {
global = 1;
} // COMPILE PAS
```
```C
int main() {
int global = 1;
{
printf("global = %d", global);
}
} // COMPILE
```
```C
int local;
int main() {
local = 1;
{
printf("local = %d", local);
}
} // COMPILE
```
```C
#include <stdio.h>
int local = 0;
int main() {
int local = -1;
{
int local = 1;
printf("local = %d\n", local);
}
} // COMPILE
``` -->
# Quiz: compile ou compile pas?
## [Quiz: compile ou compile pas](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=1033948)
# Types de base (1/4)
## Numériques
Type Signification (**gcc pour x86-64**)
---------------------------------- ---------------------------------------------
`char`{.C}, `unsigned char`{.C} Entier signé/non-signé 8-bit
`short`{.C}, `unsigned short`{.C} Entier signé/non-signé 16-bit
`int`{.C}, `unsigned int`{.C} Entier signé/non-signé 32-bit
`long`{.C}, `unsigned long`{.C} Entier signé/non-signé 64-bit
`float`{.C} Nombre à virgule flottante, simple précision
`double`{.C} Nombre à virgule flottante, double précision
---------------------------------- ---------------------------------------------
**La signification de `short`{.C}, `int`{.C}, ... dépend du compilateur et de l'architecture.**
# Types de base (2/4)
Voir `<stdint.h>` pour des représentations **portables**
Type Signification
---------------------------------- ---------------------------------------------
`int8_t`{.C}, `uint8_t`{.C} Entier signé/non-signé 8-bit
`int16_t`{.C}, `uint16_t`{.C} Entier signé/non-signé 16-bit
`int32_t`{.C}, `uint32_t`{.C} Entier signé/non-signé 32-bit
`int64_t`{.C}, `uint64_t`{.C} Entier signé/non-signé 64-bit
---------------------------------- ---------------------------------------------
. . .
## Prenez l'habitude d'utiliser ces types-là!
# Types de base (3/4)
## Booléens
- Le ANSI C n'offre pas de booléens.
- L'entier `0`{.C} signifie *faux*, tout le reste *vrai*.
- Depuis C99, la librairie `stdbool` met à disposition un type `bool`{.C}.
- En réalité c'est un entier:
- $1 \Rightarrow$ `true`{.C}
- $0 \Rightarrow$ `false`{.C}
- On peut les manipuler comme des entier (les sommer, les multiplier, ...).
# Quiz: booléens
## [Quiz: booléens](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=1032492)
<!-- TODO Quiz en ligne -->
<!-- ```C
if (42) { /* vrai */ }
int x = 100;
if (x == 4) { /* faux */ }
if (x) { /* vrai */ }
int x = 100;
while (x−−) { /* répète tant que x est différent de 0 */ }
if (0) { /* faux */ }
if (i = 4) { /* vrai */ }
if (i = 0) { /* faux */ }
#include <stdbool.h>
bool x = true;
if (x) { /* vrai */ }
``` -->
# Types de base (4/4)
## Conversions
- Les conversions se font de manière:
- Explicite:
```C
int a = (int)2.8;
double b = (double)a;
int c = (int)(2.8+0.5);
```
- Implicite:
```C
int a = 2.8; // warning, si activés, avec clang
double b = a + 0.5;
char c = b; // pas de warning...
int d = 'c';
```
# Quiz: conversions
## [Quiz: conversions](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=1033446)
<!-- TODO Quiz en ligne -->
<!-- ```C
int a = (int)2.8; // 2
double b = 2.85;
int c = b + 0.5; // 3
int d = a + 0.5; // 2
bool d = 2.78; // 1
bool e = 1.0; // 1
``` -->
# Expressions et opérateurs (1/6)
Une expression est tout bout de code qui est **évalué**.
## Expressions simples
- Pas d'opérateurs impliqués.
- Les littéraux, les variables, et les constantes.
```C
const int L = -1; // 'L' est une constante, -1 un littéral
int x = 0; // '0' est un litéral
int y = x; // 'x' est une variable
int z = L; // 'L' est une constante
```
## Expressions complexes
- Obtenues en combinant des *opérandes* avec des *opérateurs*
```C
int x; // pas une expression (une instruction)
x = 4 + 5; // 4 + 5 est une expression
// dont le résultat est affecté à 'x'
```
# Expressions et opérateurs (2/6)
## Opérateurs relationnels
Opérateurs testant la relation entre deux *expressions*:
- `(a opérateur b)` retourne `1`{.C} si l'expression s'évalue à `true`{.C}, `0`{.C} si l'expression s'évalue à `false`{.C}.
| Opérateur | Syntaxe | Résultat |
|-----------|--------------|----------------------|
| `<`{.C} | `a < b`{.C} | 1 si a < b; 0 sinon |
| `>`{.C} | `a > b`{.C} | 1 si a > b; 0 sinon |
| `<=`{.C} | `a <= b`{.C} | 1 si a <= b; 0 sinon |
| `>=`{.C} | `a >= b`{.C} | 1 si a >= b; 0 sinon |
| `==`{.C} | `a == b`{.C} | 1 si a == b; 0 sinon |
| `!=`{.C} | `a != b`{.C} | 1 si a != b; 0 sinon |
# Expressions et opérateurs (3/6)
## Opérateurs logiques
| Opérateur | Syntaxe | Signification |
|-----------|--------------|----------------------|
| `&&`{.C} | `a && b`{.C} | ET logique |
| `||`{.C} | `a || b`{.C} | OU logique |
| `!`{.C} | `!a`{.C} | NON logique |
# Quiz: opérateurs logiques
## [Quiz: opérateurs logiques](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=1033629)
<!-- TODO: Quiz -->
<!-- ```C
1 && 0 == 0
7 && 3 == 1
4 || 3 == 1
!34 == 0
!0 == 1
Soit n un unsigned char initialisé à 127:
!n == 0
``` -->
# Expressions et opérateurs (4/6)
## Opérateurs arithmétiques
| Opérateur | Syntaxe | Signification |
|-----------|--------------|----------------------|
| `+`{.C} | `a + b`{.C} | Addition |
| `-`{.C} | `a - b`{.C} | Soustraction |
| `*`{.C} | `a * b`{.C} | Multiplication |
| `/`{.C} | `a / b`{.C} | Division |
| `%`{.C} | `a % b`{.C} | Modulo |
# Expressions et opérateurs (5/6)
## Opérateurs d'assignation
| Opérateur | Syntaxe | Signification |
|-----------|--------------|---------------------------------------------|
| `=`{.C} | `a = b`{.C} | Affecte la valeur `b` à la variable `a` |
| | | et retourne la valeur de `b` |
| `+=`{.C} | `a += b`{.C} | Additionne la valeur de `b` à `a` et |
| | | assigne le résultat à `a`. |
| `-=`{.C} | `a -= b`{.C} | Soustrait la valeur de `b` à `a` et |
| | | assigne le résultat à `a`. |
| `*=`{.C} | `a *= b`{.C} | Multiplie la valeur de `b` à `a` et |
| | | assigne le résultat à `a`. |
| `/=`{.C} | `a /= b`{.C} | Divise la valeur de `b` à `a` et |
| | | assigne le résultat à `a`. |
| `%=`{.C} | `a %= b`{.C} | Calcule le modulo la valeur de `b` à `a` et |
| | | assigne le résultat à `a`. |
# Expressions et opérateurs (6/6)
## Opérateurs d'assignation (suite)
| Opérateur | Syntaxe | Signification |
|-----------|--------------|---------------------------------------------|
| `++`{.C} | `++a`{.C} | Incrémente la valeur de `a` de 1 et |
| | | retourne le résultat (`a += 1`). |
| `--`{.C} | `--a`{.C} | Décrémente la valeur de `a` de 1 et |
| | | retourne le résultat (`a -= 1`). |
| `++`{.C} | `a++`{.C} | Retourne `a`{.C} et incrémente `a` de 1. |
| `--`{.C} | `a--`{.C} | Retourne `a`{.C} et décrémente `a` de 1. |
# Structures de contrôle: `if`{.C} .. `else if`{.C} .. `else`{.C} (1/2)
## Syntaxe
```C
if (expression) {
instructions;
} else if (expression) { // optionnel
// il peut y en avoir plusieurs
instructions;
} else {
instructions; // optionnel
}
```
```C
if (x) { // si x s'évalue à `vrai`
printf("x s'évalue à vrai.\n");
} else if (y == 8) { // si y vaut 8
printf("y vaut 8.\n");
} else {
printf("Ni l'un ni l'autre.\n");
}
```
# Structures de contrôle: `if`{.C} .. `else if`{.C} .. `else`{.C} (2/2)
## Pièges
```C
int x, y;
x = y = 3;
if (x = 2)
printf("x = 2 est vrai.\n");
else if (y < 8)
printf("y < 8.\n");
else if (y == 3)
printf("y vaut 3 mais cela ne sera jamais affiché.\n");
else
printf("Ni l'un ni l'autre.\n");
x = -1; // toujours évalué
```
# Quiz: `if ... else`{.C}
## [Quiz: `if ... else`{.C}](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=1033916)
# Structures de contrôle: `while`{.C}
## La boucle `while`{.C}
```C
while (condition) {
instructions;
}
do {
instructions;
} while (condition);
```
## La boucle `while`{.C}, un exemple
```C
int sum = 0; // syntaxe C99
while (sum < 10) {
sum += 1;
}
do {
sum += 10;
} while (sum < 100)
```
# Structures de contrôle: `for`{.C}
## La boucle `for`{.C}
```C
for (expression1; expression2; expression3) {
instructions;
}
```
## La boucle `for`{.C}
```C
int sum = 0; // syntaxe C99
for (int i = 0; i < 10; i++) {
sum += i;
}
for (int i = 0; i != 1; i = rand() % 4) { // ésotérique
printf("C'est plus ésotérique.\n");
}
```
# Exercice: la factorielle
Écrire un programme qui calcule la factorielle d'un nombre
$$
N! = 1\cdot 2\cdot ... \cdot (N-1)\cdot N.
$$
## Par groupe de 3: écrire un pseudo-code
. . .
```C
int factorielle(int n) {
i = 1;
fact = 1;
pour i <= n {
fact *= i;
i += 1;
}
}
```
# Exercice: la factorielle
\footnotesize
Écrire un programme qui calcule la factorielle d'un nombre
$$
N! = 1\cdot 2\cdot ... \cdot (N-1)\cdot N.
$$
## Par groupe de 3: écrire un code en C
Quand vous avez fini postez le code sur le salon matrix.
. . .
```C
#include <stdio.h>
int main() {
int nb = 10;
int fact = 1;
int iter = 2;
while (iter <= nb) {
fact *= iter;
iter++;
}
}
```
. . .
## Comment améliorer ce code? (notez ça sur une feuille)
# Entrées/sorties: `printf()`{.C} (1/2)
## Généralités
- La fonction `printf()`{.C} permet d'afficher du texte sur le terminal:
```C
int printf(const char *format, ...);
```
- Nombre d'arguments variables.
- `format`{.C} est le texte, ainsi que le format (type) des variables à afficher.
- Les arguments suivants sont les expressions à afficher.
# Entrées/sorties: `printf()`{.C} (2/2)
## Exemple
```C
#include <stdio.h>
#include <stdlib.h>
int main() {
printf("Hello world.\n");
int val = 1;
printf("Hello world %d time.\n", val);
printf("%f squared is equal to %f.\n", 2.5, 2.5*2.5);
return EXIT_SUCCESS;
}
```
# Entrées/sorties: `scanf()`{.C} (1/2)
## Généralités
- La fonction `scanf()`{.C} permet de lire du texte formaté entré au clavier:
```C
int scanf(const char *format, ...);
```
- `format`{.C} est le format des variables à lire (comme `printf()`{.C}).
- Les arguments suivants sont les variables où sont stockées les valeurs lues.
# Entrées/sorties: `scanf()`{.C} (2/2)
## Exemple
```C
#include <stdio.h>
#include <stdlib.h>
int main() {
printf("Enter 3 numbers: \n");
int i, j, k;
scanf("%d %d %d", &i, &j, &k);
printf("You entered: %d %d %d\n", i, j, k);
return EXIT_SUCCESS;
}
```
# Exercice: la factorielle en mieux
## Individuellement
1. Ajoutez des fonctionnalités à votre code.
2. Écrivez l'algorithme de calcul de deux façon différentes.
3. Pour celles et ceux qui ont fini pendant que les autres essaient: faites-le
en récursif (sans aide).
. . .
## Postez vos solutions sur matrix!
slides_2021/cours_10.md 0 → 100644
View file @ febfc3f8
---
title: "Piles et files d'attente"
date: "2021-12-08"
patat:
eval:
tai:
command: fish
fragment: false
replace: true
ccc:
command: fish
fragment: false
replace: true
images:
backend: auto
---
# La liste chaînée et pile (1/N)
## Structure de données
* Chaque élément de la liste contient:
1. une valeur,
2. un pointeur vers le prochain élément.
* La pile est un pointeur vers le premier élément.
![Un exemple de liste chaînée.](figs/Singly-linked-list.svg){width=80%}
# La liste chaînée et pile (2/N)
## Une pile-liste-chaînée
```C
typedef struct _element {
int data;
struct _element *next;
} element;
typedef element* stack;
```
## Fonctionnalités?
. . .
```C
void stack_create(stack *s); // *s = NULL;
void stack_destroy(stack *s);
void stack_push(stack *s, int val);
void stack_pop(stack *s, int *val);
void stack_peek(stack s, int *val);
bool stack_is_empty(stack s); // reutrn NULL == stack;
```
# La liste chaînée et pile (3/N)
## Empiler? (faire un dessin)
. . .
```C
```
## Empiler? (le code ensemble)
. . .
```C
void stack_push(stack *s, int val) {
element *elem = malloc(sizeof(*elem));
elem->data = val;
elem->next = *s;
s = elem;
}
```
# La liste chaînée et pile (4/N)
## Jeter un oeil? (faire un dessin)
. . .
```C
```
## Jeter un oeil? (le code ensemble)
. . .
```C
void stack_peek(stack s, int *val) {
*val = s->data;
}
```
# La liste chaînée et pile (5/N)
## Dépiler? (faire un dessin)
. . .
```C
```
## Dépiler? (le code ensemble)
. . .
```C
void stack_pop(stack *s, int *val) {
stack_peek(*s, val);
element *tmp = *s;
*s = (*s)->next;
free(tmp);
return val;
}
```
# La liste chaînée et pile (6/N)
## Détruire? (faire un dessin)
. . .
```C
```
## Détruire? (le code ensemble)
. . .
```C
void stack_destroy(stack *s) {
while (!stack_is_empty(*s)) {
int val = stack_pop(s);
}
}
```
# La file d'attente (1/N)
* Structure de données abstraite permettant le stockage d'éléments.
* *FIFO*: First In First Out, ou première entrée première sortie.
* Analogue de la vie "réelle"":
* File à un guichet,
* Serveur d'impressions,
* Mémoire tampon, ...
## Fonctionnalités
. . .
* Enfiler, ajouter un élément à la fin de la file.
* Défiler, extraire un élément au devant de la file.
* Tester si la file est vide.
. . .
* Lire l'élément de la fin de la file.
* Lire l'élément du devant de la file.
* Créer une liste vide.
* Détruire une liste vide.
# La file d'attente (2/N)
## Implémentation possible
* La structure file, contient un pointeur vers la tête et un vers la queue.
* Entre les deux, les éléments sont stockés dans une liste chaînée (comme une
pile).
![Illustration d'une file
d'attente.](figs/fig_queue_representation.png)
## Structure de données en C?
. . .
```C
txpedef struct _element { // Elément de liste
int data;
struct _element* next;
} element;
typedef struct _queue { // File d'attente:
element* head; // tête de file d'attente
element* tail; // queue de file d'attente
} queue;
```
# Fonctionnalités d'une file d'attente (gitlab)
## Creation et consultations
. . .
```C
void queue_init(queue *fa); // head = tail = NULL
bool queue_is_empty(queue fa); // fa.head == fa.tail == NULL
int queue_tail(queue fa); // return fa.head->data
int queue_head(queue fa); // return fa.tail->data
```
## Manipulations et destruction
. . .
```C
void queue_enqueue(queue *fa, int val); // adds an element before the tail
int queue_dequeue(queue *fa); // removes the head and returns stored value
void queue_destroy(queue *fa); // dequeues everything into oblivion
```
# Enfilage
## Deux cas différents:
1. La file est vide (faire un dessin):
. . .
![Insertion dans une file d'attente
vide.](./figs/fig_empty_queue_insert.png){width=40%}
2. La file n'est pas vide (faire un dessin):
. . .
![Insertion dans une file d'attente
non-vide.](./figs/fig_non_empty_queue_insert.png){width=70%}
# Enfilage
## Live (implémentation)
. . .
```C
void queue_enqueue(queue *fa, int val) {
element elmt = malloc(sizeof(*elmt));
elmt->data = val;
elmt->next = NULL;
if (queue_is_empty(*fa)) {
fa->head = elmt;
fa->tail = elmt;
} else {
fa->tail->next = elmt;
fa->tail = elmt;
}
}
```
# Défilage
## Trois cas différents
1. La file a plus d'un élément (faire un dessin):
. . .
![Extraction d'une file d'attente](./figs/fig_queue_extract.png){width=80%}
2. La file un seul élément (faire un dessin):
. . .
![Extraction d'une file d'attente de longueur 1.](./figs/fig_queue_extract_one.svg){width=25%}
3. La file est vide (problème)
# Défilage
## Live (implémentation)
. . .
```C
int queue_dequeue(queue *fa) {
elmt = fa->head;
int val = elmt->data;
fa->head = fa->head->next;
free(elmt);
if (NULL == fa->head) {
fa->tail = NULL;
}
return val;
}
```
. . .
## Problème avec cette implémentation?
slides_2021/cours_11.md 0 → 100644
View file @ febfc3f8
---
title: "Files d'attente et listes triées"
date: "2021-12-15"
patat:
eval:
tai:
command: fish
fragment: false
replace: true
ccc:
command: fish
fragment: false
replace: true
images:
backend: auto
---
# La file d'attente (1/N)
* Structure de données abstraite permettant le stockage d'éléments.
* *FIFO*: First In First Out, ou première entrée première sortie.
* Analogue de la vie "réelle"":
* File à un guichet,
* Serveur d'impressions,
* Mémoire tampon, ...
## Fonctionnalités
. . .
* Enfiler: ajouter un élément à la fin de la file.
* Défiler: extraire un élément au devant de la file.
* Tester si la file est vide.
. . .
* Lire l'élément de la fin de la file.
* Lire l'élément du devant de la file.
* Créer une liste vide.
* Détruire une liste vide.
# La file d'attente (2/N)
## Implémentation possible
* La structure file, contient un pointeur vers la tête et un vers la queue.
* Entre les deux, les éléments sont stockés dans une liste chaînée (comme une
pile).
![Illustration d'une file d'attente.](figs/fig_queue_representation.png)
## Structure de données en C?
. . .
```C
txpedef struct _element { // Elément de liste
int data;
struct _element* next;
} element;
typedef struct _queue { // File d'attente:
element* head; // tête de file d'attente
element* tail; // queue de file d'attente
} queue;
```
# Fonctionnalités d'une file d'attente (gitlab)
## Creation et consultations
. . .
```C
void queue_init(queue *fa); // head = tail = NULL
bool queue_is_empty(queue fa); // fa.head == fa.tail == NULL
int queue_tail(queue fa); // return fa.head->data
int queue_head(queue fa); // return fa.tail->data
```
## Manipulations et destruction
. . .
```C
void queue_enqueue(queue *fa, int val); // adds an element before the tail
int queue_dequeue(queue *fa); // removes the head and returns stored value
void queue_destroy(queue *fa); // dequeues everything into oblivion
```
# Enfilage
## Deux cas différents:
1. La file est vide (faire un dessin):
. . .
![Insertion dans une file d'attente
vide.](./figs/fig_empty_queue_insert.png){width=40%}
2. La file n'est pas vide (faire un dessin):
. . .
![Insertion dans une file d'attente
non-vide.](./figs/fig_non_empty_queue_insert.png){width=70%}
# Enfilage
## Live (implémentation)
. . .
```C
void queue_enqueue(queue *fa, int val) {
element elmt = malloc(sizeof(*elmt));
elmt->data = val;
elmt->next = NULL;
if (queue_is_empty(*fa)) {
fa->head = elmt;
fa->tail = elmt;
} else {
fa->tail->next = elmt;
fa->tail = elmt;
}
}
```
# Défilage
## Trois cas différents
1. La file a plus d'un élément (faire un dessin):
. . .
![Extraction d'une file d'attente](./figs/fig_queue_extract.png){width=80%}
2. La file un seul élément (faire un dessin):
. . .
![Extraction d'une file d'attente de longueur 1.](./figs/fig_queue_extract_one.svg){width=25%}
3. La file est vide (problème)
# Défilage
## Live (implémentation)
. . .
```C
int queue_dequeue(queue *fa) {
elmt = fa->head;
int val = elmt->data;
fa->head = fa->head->next;
free(elmt);
if (NULL == fa->head) {
fa->tail = NULL;
}
return val;
}
```
. . .
## Problème avec cette implémentation?
# Destruction
## Comment on faire la désallocation?
. . .
On défile jusqu'à ce que la file soit vide!
# Complexité
## Quelle sont les complexité de:
* Enfiler?
. . .
* Défiler?
. . .
* Détruire?
. . .
* Est vide?
# Implémentation alternative
## Comment implémenter la file autrement?
. . .
* Données stockées dans un tableau;
* Tableau de taille connue à la compilation ou pas (réallouable);
* `tail` seraient les indices du tableau;
* `capacity` seraient la capacité maximale;
* On *enfile* "au bout" du tableau, au défile au début (indice `0`).
. . .
## Structure de données
```C
typedef struct _queue {
int *data;
int tail, capacity;
} queue;
```
# File basée sur un tableau
* Initialisation?
. . .
```C
```
* Est vide?
. . .
```C
```
* Enfiler?
. . .
```C
```
* Défiler?
. . .
```C
```
# Complexité
## Quelle sont les complexités de:
* Initialisation?
. . .
```C
```
* Est vide?
. . .
```C
```
* Enfiler?
. . .
```C
```
* Défiler?
. . .
```C
```
# File basée sur un tableau (git)
* Créons le squelette et `Makefile` ensemble.
. . .
* Créons quelques issues et assignons les!
# Une file plus efficace
## Comment faire une file plus efficace?
* Où est-ce que ça coince?
. . .
* Défiler est particulièrement lent $\mathcal{O}(N)$.
## Solution?
. . .
* Utiliser un indice séparé pour `head`.
```C
typedef struct _queue {
int *data;
int head, tail, capacity;
} queue;
```
# Une file plus efficace (implémentation)
## Enfilage
\footnotesize
```C
void queue_enqueue(queue *fa, int val) {
if ((fa->head == 0 && fa->tail == fa->capacity-1) ||
(fa->tail == (fa->head-1) % (fa->capacity-1))) {
return; // queue is full
}
if (fa->head == -1) { // queue was empty
fa->head = fa->tail = 0;
fa->data[fa->tail] = val;
} else if (fa->tail == fa->capacity-1 && fa->head != 0) {
// the tail reached the end of the array
fa->tail = 0;
fa->data[fa->tail] = val;
} else {
// nothing particular
fa->tail += 1;
fa->data[fa->tail] = val;
}
}
```
# Une file plus efficace (implémentation)
## Défilage
```C
void queue_dequeue(queue *fa, int *val) {
if (queue_is_empty(*fa)) {
return; // queue is empty
}
*val = fa->data[fa->head];
if (fa->head == fa->tail) { // that was the last element
fa->head = fa->tail = -1;
} else if (fa->head == fa->capacity-1) {
fa->head = 0;
} else {
fa->head += 1;
}
}
```
# Les listes triées
Une liste chaînée triée est:
* une liste chaînée
* dont les éléments sont insérés dans l'ordre.
![Exemple de liste triée.](./figs/sorted_list_example.svg)
. . .
* L'insertion est faite telle que l'ordre est maintenu.
## Quelle structure de données?
```C
```
# Les listes triées
## Quel but?
* Permet de retrouver rapidement un élément.
* Utile pour la recherche de plus court chemin dans des graphes.
* Ordonnancement de processus par degré de priorité.
## Comment?
* Les implémentations les plus efficaces se basent sur les tableaux.
* Possibles aussi avec des listes chaînées.
# Les listes triées
## Quelle structure de données dans notre cas?
Une liste chaînée bien sûr (oui c'est pour vous entraîner)!
```C
typedef struct _element { // chaque élément
int data;
struct _element *next;
} element;
typedef element* sorted_list; // la liste
```
## Fonctionnalités
```C
// insertion de val
sorted_list sorted_list_push(sorted_list list, int val);
// la liste est-elle vide?
bool is_empty(sorted_list list); // list == NULL
// extraction de val (il disparaît)
sorted_list sorted_list_extract(sorted_list list, int val);
// rechercher un élément et le retourner
element* sorted_list_search(sorted_list list, int val);
```
# L'insertion
## Trois cas
1. La liste est vide.
. . .
![Insertion dans une liste vide, `list == NULL`.](figs/sorted_list_insert_one.svg){width=30%}
. . .
```C
sorted_list sorted_list_push(sorted_list list, int val) {
if (sorted_list_is_empty(list)) {
list = malloc(sizeof(*list));
list->data = val;
list->next = NULL;
return list;
}
}
```
# L'insertion
2. L'insertion se fait en première position.
. . .
![Insertion en tête de liste, `list->data >=
val`.](figs/sorted_list_insert_first.svg){width=80%}
. . .
```C
sorted_list sorted_list_push(sorted_list list, int val) {
if (list->data >= val) {
element *tmp = malloc(sizeof(*tmp));
tmp->data = val;
tmp->next = list;
list = tmp;
return list;
}
}
```
# L'insertion
3. L'insertion se fait sur une autre position que la première.
. . .
![Insertion sur une autre position, list->data <
val.](figs/sorted_list_insert_any.svg){width=70%}
. . .
\footnotesize
```C
sorted_list sorted_list_push(sorted_list list, int val) {
element *tmp = malloc(sizeof(*tmp));
tmp->data = val;
element *crt = list;
while (NULL != crt->next && val > crt->next->data) {
crt = crt->next;
}
tmp->next = crt->next;
crt->next = tmp;
return list;
}
```
# L'extraction
## Trois cas
1. L'élément à extraire n'est **pas** le premier élément de la liste
. . .
![Extraction d'un élément qui n'est pas le premier.](figs/sorted_list_extract_any.svg){width=70%}
. . .
\footnotesize
```C
sorted_list sorted_list_extract(sorted_list list, int val) {
element *prec = *crt = list; // needed to glue elements together
while (NULL != crt && val > crt->data) {
prec = crt;
crt = crt->next;
}
if (NULL != crt && prec != crt && crt->data == val) { // glue things together
prec->next = crt->next;
free(crt);
}
return list;
}
```
# L'extraction
2. L'élément à extraire est le premier élément de la liste
. . .
![Extraction d'un élément qui est le
premier.](figs/sorted_list_extract_first.svg){width=70%}
. . .
\footnotesize
```C
sorted_list sorted_list_extract(sorted_list list, int val) {
element *prec = *crt = list; // needed to glue elements together
while (NULL != crt && val > crt->data) {
prec = crt;
crt = crt->next;
}
if (NULL != crt && crt->data == val && prec == crt) { // glue things together
list = list->next;
free(crt);
}
return list;
}
```
# L'extraction
3. L'élément à extraire n'est **pas** dans la liste.
* La liste est vide.
* La valeur est plus grande que le dernier élément de la liste.
* La valeur est plus petite que la valeur de `crt`.
. . .
On retourne la liste inchangée.
. . .
\footnotesize
```C
sorted_list sorted_list_extract(sorted_list list, int val) {
element *prec = *crt = list; // needed to glue elements together
while (NULL != crt && val > crt->data) {
prec = crt;
crt = crt->next;
}
if (NULL == crt || crt->data != val) { // val not present
return list;
}
}
```
# La recherche
```C
element* sorted_list_search(sorted_list list, int val);
```
* Retourne `NULL` si la valeur n'est pas présente (ou la liste vide).
* Retourne un pointeur vers l'élément si la valeur est présente.
. . .
```C
element* sorted_list_search(sorted_list list, int val) {
// search for element smaller than val
element* pos = sorted_list_position(list, val);
if (NULL == pos && val == list->data) {
return list; // first element contains val
} else if (NULL != pos->next && val == pos->next->data) {
return pos->next; // non-first element contains val
} else {
return NULL; // well... val's not here
}
}
```
# La recherche
## La fonction `sorted_list_position`
```C
element* sorted_list_position(sorted_list list, int val);
```
![Trois exemples de retour de la fonction `sorted_list_position()`.](figs/sorted_list_position.svg)
# La recherche
## Exercice: implémenter
```C
element* sorted_list_position(sorted_list list, int val);
```
. . .
```C
element* sorted_list_position(sorted_list list, int val) {
element* pos = list;
if (sorted_list_is_empty(list) || val <= list->data) {
pos = NULL;
} else {
while (NULL != pos->next && val > pos->next>data) {
pos = pos->next;
}
}
return pos;
}
```
# Complexité de la liste chaînée triée
## L'insertion?
. . .
$$
\mathcal{O}(N).
$$
## L'extraction?
. . .
$$
\mathcal{O}(N).
$$
## La recherche?
. . .
$$
\mathcal{O}(N).
$$
slides_2021/cours_12.md 0 → 100644
View file @ febfc3f8
---
title: "Listes triées et listes doublement chaînées"
date: "2021-12-22"
patat:
eval:
tai:
command: fish
fragment: false
replace: true
ccc:
command: fish
fragment: false
replace: true
images:
backend: auto
---
# Les listes triées
Une liste chaînée triée est:
* une liste chaînée
* dont les éléments sont insérés dans l'ordre.
![Exemple de liste triée.](./figs/sorted_list_example.svg)
. . .
* L'insertion est faite telle que l'ordre est maintenu.
## Quelle structure de données?
```C
```
# Les listes triées
## Quel but?
* Permet de retrouver rapidement un élément.
* Utile pour la recherche de plus court chemin dans des graphes.
* Ordonnancement de processus par degré de priorité.
## Comment?
* Les implémentations les plus efficaces se basent sur les tableaux.
* Possibles aussi avec des listes chaînées.
# Les listes triées
## Quelle structure de données dans notre cas?
Une liste chaînée bien sûr (oui c'est pour vous entraîner)!
```C
typedef struct _element { // chaque élément
int data;
struct _element *next;
} element;
typedef element* sorted_list; // la liste
```
## Fonctionnalités
```C
// insertion de val
sorted_list sorted_list_push(sorted_list list, int val);
// la liste est-elle vide?
bool is_empty(sorted_list list); // list == NULL
// extraction de val (il disparaît)
sorted_list sorted_list_extract(sorted_list list, int val);
// rechercher un élément et le retourner
element* sorted_list_search(sorted_list list, int val);
```
# L'insertion
## Trois cas
1. La liste est vide.
. . .
![Insertion dans une liste vide, `list == NULL`.](figs/sorted_list_insert_one.svg){width=30%}
. . .
```C
sorted_list sorted_list_push(sorted_list list, int val) {
if (sorted_list_is_empty(list)) {
list = malloc(sizeof(*list));
list->data = val;
list->next = NULL;
return list;
}
}
```
# L'insertion
2. L'insertion se fait en première position.
. . .
![Insertion en tête de liste, `list->data >=
val`.](figs/sorted_list_insert_first.svg){width=80%}
. . .
```C
sorted_list sorted_list_push(sorted_list list, int val) {
if (list->data >= val) {
element *tmp = malloc(sizeof(*tmp));
tmp->data = val;
tmp->next = list;
list = tmp;
return list;
}
}
```
# L'insertion
3. L'insertion se fait sur une autre position que la première.
. . .
![Insertion sur une autre position, list->data <
val.](figs/sorted_list_insert_any.svg){width=70%}
. . .
\footnotesize
```C
sorted_list sorted_list_push(sorted_list list, int val) {
element *tmp = malloc(sizeof(*tmp));
tmp->data = val;
element *crt = list;
while (NULL != crt->next && val > crt->next->data) {
crt = crt->next;
}
tmp->next = crt->next;
crt->next = tmp;
return list;
}
```
# L'extraction
## Trois cas
1. L'élément à extraire n'est **pas** le premier élément de la liste
. . .
![Extraction d'un élément qui n'est pas le premier.](figs/sorted_list_extract_any.svg){width=70%}
. . .
\footnotesize
```C
sorted_list sorted_list_extract(sorted_list list, int val) {
element *prec = *crt = list; // needed to glue elements together
while (NULL != crt && val > crt->data) {
prec = crt;
crt = crt->next;
}
if (NULL != crt && prec != crt && crt->data == val) { // glue things together
prec->next = crt->next;
free(crt);
}
return list;
}
```
# L'extraction
2. L'élément à extraire est le premier élément de la liste
. . .
![Extraction d'un élément qui est le
premier.](figs/sorted_list_extract_first.svg){width=70%}
. . .
\footnotesize
```C
sorted_list sorted_list_extract(sorted_list list, int val) {
element *prec = *crt = list; // needed to glue elements together
while (NULL != crt && val > crt->data) {
prec = crt;
crt = crt->next;
}
if (NULL != crt && crt->data == val && prec == crt) { // glue things together
list = list->next;
free(crt);
}
return list;
}
```
# L'extraction
3. L'élément à extraire n'est **pas** dans la liste.
* La liste est vide.
* La valeur est plus grande que le dernier élément de la liste.
* La valeur est plus petite que la valeur de `crt`.
. . .
On retourne la liste inchangée.
. . .
\footnotesize
```C
sorted_list sorted_list_extract(sorted_list list, int val) {
element *prec = *crt = list; // needed to glue elements together
while (NULL != crt && val > crt->data) {
prec = crt;
crt = crt->next;
}
if (NULL == crt || crt->data != val) { // val not present
return list;
}
}
```
# La recherche
```C
element* sorted_list_search(sorted_list list, int val);
```
* Retourne `NULL` si la valeur n'est pas présente (ou la liste vide).
* Retourne un pointeur vers l'élément si la valeur est présente.
. . .
```C
element* sorted_list_search(sorted_list list, int val) {
// search for element smaller than val
element* pos = sorted_list_position(list, val);
if (NULL == pos && val == list->data) {
return list; // first element contains val
} else if (NULL != pos->next && val == pos->next->data) {
return pos->next; // non-first element contains val
} else {
return NULL; // well... val's not here
}
}
```
# La recherche
## La fonction `sorted_list_position`
```C
element* sorted_list_position(sorted_list list, int val);
```
![Trois exemples de retour de la fonction `sorted_list_position()`.](figs/sorted_list_position.svg)
# La recherche
## Exercice: implémenter
```C
element* sorted_list_position(sorted_list list, int val);
```
. . .
```C
element* sorted_list_position(sorted_list list, int val) {
element* pos = list;
if (sorted_list_is_empty(list) || val <= list->data) {
pos = NULL;
} else {
while (NULL != pos->next && val > pos->next>data) {
pos = pos->next;
}
}
return pos;
}
```
# Complexité de la liste chaînée triée
## L'insertion?
. . .
$$
\mathcal{O}(N).
$$
## L'extraction?
. . .
$$
\mathcal{O}(N).
$$
## La recherche?
. . .
$$
\mathcal{O}(N).
$$
# Liste doublement chaînée
## Application navigateur ou éditeur de texte
* Avec une liste chaînée:
* Comment implémenter les fonctions `back` et `forward` d'un navigateur??
* Comment implémenter les fonctions `undo` et `redo` d'un éditeur de text?
. . .
Pas possible.
## Solution?
. . .
* Garder un pointeur supplémentaire sur l'élément précédent et pas seulement le
suivant.
. . .
* Cette structure de donnée est la **liste doublement chaînée** ou **doubly
linked list**.
# Liste doublement chaînée
## Exercices
* Partir du dessin suivant et par **groupe de 5**
![Un schéma de liste doublement chaînée d'entiers.](figs/doubly_linked_list.svg)
1. Écrire les structures de données pour représenter la liste doublement
chaînée dont le type sera `dll` (pour
`doubly_linked_list`)
# Liste doublement chaînée
2. Écrire les fonctionnalités de création et consultation
```C
// crée la liste doublement chaînée
dll dll_create();
// retourne la valeur à la position actuelle dans la liste
int dll_value(dll list);
// la liste est-elle vide?
bool dll_is_empty(dll list);
// Est-ce que pos est le 1er élément?
bool dll_is_head(dll list);
// Est-ce que pos est le dernier élément?
bool dll_is_tail(dll list);
// data est-elle dans la liste?
bool dll_is_present(dll list, int data);
// affiche la liste
void dll_print(dll list);
```
# Liste doublement chaînée
3. Écrire les fonctionnalités de manipulation
```C
// déplace pos au début de la liste
dll dll_move_to_head(dll list);
// déplace pos à la position suivante dans la liste
dll dll_next(dll list);
// déplace pos à la position précédente dans la liste
dll dll_prev(dll list);
```
# Liste doublement chaînée
4. Écrire les fonctionnalités d'insertion
```C
// insertion de data dans l'élément *après* pos
dll dll_insert_after(dll list, int data);
// insertion de data en tête de liste
dll dll_push(dll list, int data);
```
5. Écrire les fonctionnalités d'extraction
```C
// extraction de la valeur se trouvant dans l'élément *pos*
// l'élément *pos* est libéré
int dll_extract(dll *list);
// extrait la donnée en tête de liste
int dll_pop(dll *list);
// vide la liste
void dll_destroy(dll *list)
```
slides_2021/cours_13.md 0 → 100644
View file @ febfc3f8
---
title: "Tables de hachage"
date: "2022-01-12"
patat:
eval:
tai:
command: fish
fragment: false
replace: true
ccc:
command: fish
fragment: false
replace: true
images:
backend: auto
---
# Tableau vs Table
## Tableau
* Chaque élément (ou valeur) est lié à un indice (la case du tableau).
```C
annuaire tab[2] = {
"+41 22 123 45 67", "+41 22 234 56 78", ...
};
tab[1] == "+41 22 123 45 67";
```
## Table
* Chaque élément (ou valeur) est lié à une clé.
```C
annuaire tab = {
// Clé , Valeur
"Paul", "+41 22 123 45 67",
"Orestis", "+41 22 234 56 78",
};
tab["Paul"] == "+41 22 123 45 67";
tab["Orestis"] == "+41 22 234 56 78";
```
# Table
## Définition
Structure de données abstraite où chaque *valeur* (ou élément) est associée à une *clé* (ou
argument).
On parle de paires *clé-valeur* (*key-value pairs*).
## Donnez des exemples de telles paires
. . .
* Annuaire (nom-téléphone),
* Catalogue (objet-prix),
* Table de valeur fonctions (nombre-nombre),
* Index (nombre-page)
* ...
# Table
## Opérations principales sur les tables
* Insertion d'élément (`insert(clé, valeur)`{.C}), insère la paire `clé-valeur`
* Consultation (`get(clé)`{.C}), retourne la `valeur` correspondant à `clé`
* Suppression (`remove(clé)`{.C}), supprime la paire `clé-valeur`
## Structure de données / implémentation
Efficacité dépend de différents paramètres:
* taille (nombre de clé-valeurs maximal),
* fréquence d'utilisation (insertion, consultation, suppression),
* données triées/non-triées,
* ...
# Consultation séquentielle (`sequential_get`)
## Séquentielle
* table représentée par un (petit) tableau ou liste chaînée,
* types: `key_t` et `value_t` quelconques, et `key_value_t`
```C
typedef struct {
key_t key;
value_t value;
} key_value_t;
```
* on recherche l'existence de la clé séquentiellement dans le tableau, on
retourne la valeur.
# Consultation séquentielle (`sequential_get`)
## Implémentation? Une idée?
. . .
```C
bool sequential_get(int n, key_value_t table[n], key_t key,
value_t *value)
{
int pos = n - 1;
while (pos >= 0) {
if (key == table[pos].key) {
*value = table[pos].value;
return true;
}
pos--;
}
return false;
}
```
. . .
## Inconvénient?
# Consultation séquentielle (`sequential_get`)
## Exercice: implémenter la même fonction avec une liste chaînée
Poster le résultat sur matrix.
# Consultation dichotomique (`binary_get`)
## Dichotomique
* table représentée par un (petit) tableau trié par les clés,
* types: `key_t` et `value_t` quelconques, et `key_value_t`
* on recherche l'existence de la clé par dichotomie dans le tableau, on
retourne la valeur,
* les clés possèdent la notion d'ordre (`<, >, =` sont définis).
# Consultation dichotomique (`binary_get`)
\footnotesize
## Implémentation? Une idée?
. . .
```C
bool binary_get1(int n, value_key_t table[n], key_t key, value_t *value) {
int top = n - 1, bottom = 0;
while (top > bottom) {
int middle = (top + bottom) / 2;
if (x > table[middle]) {
bottom = middle+1;
} else {
top = middle;
}
}
if (key == table[top].key) {
*value = table[top].value;
return true;
} else {
return false;
}
}
```
# Consultation dichotomique (`binary_get`)
\footnotesize
## Autre implémentation
```C
bool binary_get2(int n, key_value_t table[n], key_t key, value_t *value) {
int top = n - 1, bottom = 0;
while (true) {
int middle = (top + bottom) / 2;
if (key > table[middle].key) {
bottom = middle + 1;
} else if (key < table[middle].key) {
top = middle;
} else {
*value = table[middle].value;
return true;
}
if (top < bottom) {
break;
}
}
return false;
}
```
## Quelle est la différence avec le code précédent?
# Transformation de clé (hashing)
## Problématique: Numéro AVS (13 chiffres)
* Format: 106.3123.8492.13
```
Numéro AVS | Nom
0000000000000 | -------
... | ...
1063123849213 | Paul
... | ...
3066713878328 | Orestis
... | ...
9999999999999 | -------
```
## Quelle est la clé? Quelle est la valeur?
. . .
* Clé: Numéro AVS, Valeur: Nom.
## Nombre de clés? Nombre de citoyens? Rapport?
. . .
* $10^{13}$ clés, $10^7$ citoyens, $10^{-5}$ ($10^{-3}\%$ de la table est
occupée) $\Rightarrow$ *inefficace*.
* Pire: $10^{13}$ entrées ne rentre pas dans la mémoire d'un
ordinateur.
# Transformation de clé (hashing)
## Problématique 2: Identificateurs d'un programme
* Format: 8 caractères (simplification)
```
Identificateur | Adresse
aaaaaaaa | -------
... | ...
resultat | 3aeff
compteur | 4fedc
... | ...
zzzzzzzz | -------
```
## Quelle est la clé? Quelle est la valeur?
. . .
* Clé: Identificateur, Valeur: Adresse.
## Nombre de clés? Nombre d'identificateur d'un programme? Rapport?
. . .
* $26^{8}\sim 2\cdot 10^{11}$ clés, $2000$ identificateurs, $10^{-8}$ ($10^{-6}\%$ de la table est
occupée) $\Rightarrow$ *un peu inefficace*.
# Fonctions de transformation de clé (hash functions)
* La table est représentée avec un tableau.
* La taille du tableau est beaucoup plus petit que le nombre de clés.
* On produit un indice du tableau à partir d'une clé:
$$
h(key) = n,\quad n\in\mathbb{N}.
$$
En français: on transforme `key` en nombre entier qui sera l'indice dans le
tableau correspondant à `key`.
## La fonction de hash
* La taille du domaine des clés est beaucoup plus grand que le domaine des
indices.
* Plusieurs indices peuvent correspondre à la **même clé**:
* Il faut traiter les **collisions**.
* L'ensemble des indices doit être plus petit ou égal à la taille de la table.
## Une bonne fonction de hash
* Distribue uniformément les clés sur l'ensemble des indices.
# Fonctions de transformation de clés: exemples
## Méthode par troncature
\begin{align*}
&h: [0,9999]\rightarrow [0,9]\\
&h(key)=\mbox{troisième chiffre du nombre.}
\end{align*}
```
Key | Index
0003 | 0
1123 | 2 \
1234 | 3 |-> collision.
1224 | 2 /
1264 | 6
```
## Quelle est la taille de la table?
. . .
C'est bien dix oui.
# Fonctions de transformation de clés: exemples
## Méthode par découpage
Taille de l'index: 3 chiffres.
```
key = 321 991 24 -> 321
991
+ 24
----
1336 -> index = 336
```
## Devinez l'algorithme?
. . .
On part de la gauche:
1. On découpe la clé en tranche de longueur égale à celle de l'index.
2. On somme les nombres obtenus.
3. On tronque à la longueur de l'index.
# Fonctions de transformation de clés: exemples
## Méthode multiplicative
Taille de l'index: 2 chiffres.
```
key = 5486 -> key^2 = 30096196 -> index = 96
```
On prend le carré de la clé et on garde les chiffres du milieu du résultat.
# Fonctions de transformation de clés: exemples
## Méthode par division modulo
Taille de l'index: `N` chiffres.
```
h(key) = key % N.
```
## Quelle doit être la taille de la table?
. . .
Oui comme vous le pensiez au moins `N`.
# Traitement des collisions
## La collision
```
key1 != key2, h(key1) == h(key2)
```
## Traitement (une idée?)
. . .
* La première clé occupe la place prévue dans le tableau.
* La deuxième (troisième, etc.) est placée ailleurs de façon **déterministe**.
Dans ce qui suit la taille de la table est `table_size`.
# La méthode séquentielle
\footnotesize
## Comment ça marche?
* Quand l'index est déjà occupé on regarde sur la position suivante, jusqu'à en
trouver une libre.
```C
index = h(key);
while (table[index].state == OCCUPIED && table[index].key != key) {
index = (index + 1) % table_size; // attention à pas dépasser
}
table[index].key = key;
table[index].state = OCCUPIED;
```
## Problème?
. . .
* Regroupement d'éléments (clustering).
# Méthode linéaire
\footnotesize
## Comment ça marche?
* Comme la méthode séquentielle mais on "saute" de `k`.
```C
index = h(key);
while (table[index].state == OCCUPIED && table[index].key != key) {
index = (index + k) % table_size; // attention à pas dépasser
}
table[index].key = key;
table[index].state = OCCUPIED;
```
## Quelle valeur de `k` éviter?
. . .
* Une valeur où `table_size` est multiple de `k`.
Cette méthode répartit mieux les regroupements au travers de la table.
# Méthode du double hashing
\footnotesize
## Comment ça marche?
* Comme la méthode linéaire, mais `k = h2(key)` (variable).
```C
index = h(key);
while (table[index].state == OCCUPIED && table[index].key != key) {
index = (index + h2(k)) % table_size; // attention à pas dépasser
}
table[index].key = key;
table[index].state = OCCUPIED;
```
## Quelle propriété doit avoir `h2`?
## Exemple
```C
h2(key) = (table_size - 2) - key % (table_size -2)
```
# Méthode pseudo-aléatoire
\footnotesize
## Comment ça marche?
* Comme la méthode linéaire mais on génère `k` pseudo-aléatoirement.
```C
index = h(key);
while (table[index].state == OCCUPIED && table[index].key != key) {
index = (index + random_number) % table_size;
}
table[index].key = key;
table[index].state = OCCUPIED;
```
## Comment s'assurer qu'on va bien retrouver la bonne clé?
. . .
* Le germe (seed) de la séquence pseudo-aléatoire doit être le même.
* Le germe à choisir est l'index retourné par `h(key)`.
```C
srand(h(key));
while {
random_number = rand();
}
```
# Méthode quadratique
* La fonction des indices de collision est de degré 2.
* Soit $J_0=h(key)$, les indices de collision se construisent comme:
```C
J_i = J_0 + i^2 % table_size, i > 0,
J_0 = 100, J_1 = 101, J_2 = 104, J_3 = 109, ...
```
## Problème possible?
. . .
* Calculer le carré peut-être "lent".
* En fait on peut ruser un peu.
# Méthode quadratique
\footnotesize
```C
J_i = J_0 + i^2 % table_size, i > 0,
J_0 = 100
\
d_0 = 1
/ \
J_1 = 101 Delta = 2
\ /
d_1 = 3
/ \
J_2 = 104 Delta = 2
\ /
d_2 = 5
/ \
J_3 = 109 Delta = 2
\ /
d_3 = 7
/
J_4 = 116
--------------------------------------
J_{i+1} = J_i + d_i,
d_{i+1} = d_i + Delta, d_0 = 1, i > 0.
```
# Méthode de chaînage
## Comment ça marche?
* Chaque index de la table contient un pointeur vers une liste chaînée
contenant les paires clés-valeurs.
## Un petit dessin
```
```
# Méthode de chaînage
## Exemple
On hash avec la fonction `h(key) = key % 11` (`key` est le numéro de la lettre
de l'alphabet)
```
U | N | E | X | E | M | P | L | E | D | E | T | A | B | L | E
10 | 3 | 5 | 2 | 5 | 2 | 5 | 1 | 5 | 4 | 5 | 9 | 1 | 2 | 1 | 5
```
## Comment on représente ça? (à vous)
. . .
![La méthode de chaînage](figs/fig_hash.png){width=80%}
# Méthode de chaînage
Avantages:
* Si les clés sont grandes l'économie de place est importante (les places vides
sont `NULL`).
* La gestion des collisions est conceptuellement simple.
* Pas de problème de regroupement (clustering).
# Exercice 1
* Construire une table à partir de la liste de clés suivante:
```
R, E, C, O, U, P, A, N, T
```
* On suppose que la table est initialement vide, de taille $n = 13$.
* Utiliser la fonction $h1(k)= k \mod 13$ où k est la $k$-ème lettre de l'alphabet et un traitement séquentiel des collisions.
# Exercice 2
* Reprendre l'exercice 1 et utiliser la technique de double hachage pour traiter
les collisions avec
\begin{align*}
h_1(k)&=k\mod 13,\\
h_2(k)&=1+(k\mod 11).
\end{align*}
* La fonction de hachage est donc $h(k)=(h(k)+h_2(k)) \% 13$ en cas de
collision.
# Exercice 3
* Stocker les numéros de téléphones internes d'une entreprise suivants dans un
tableau de 10 positions.
* Les numéros sont compris entre 100 et 299.
* Soit $N$ le numéro de téléphone, la fonction de hachage est
$$
h(N)=N\mod 10.
$$
* La fonction de gestion des collisions est
$$
C_1(N,i)=(h(N)+3\cdot i)\mod 10.
$$
* Placer 145, 167, 110, 175, 210, 215 (mettre son état à occupé).
* Supprimer 175 (rechercher 175, et mettre son état à supprimé).
* Rechercher 35.
* Les cases ni supprimées, ni occupées sont vides.
* Expliquer se qui se passe si on utilise?
$$
C_1(N,i)=(h(N)+5\cdot i)\mod 10.
$$
slides_2021/cours_14.md 0 → 100644
View file @ febfc3f8
---
title: "Tables de hachage"
date: "2022-01-19"
patat:
eval:
tai:
command: fish
fragment: false
replace: true
ccc:
command: fish
fragment: false
replace: true
images:
backend: auto
---
# Exercice 3
* Stocker les numéros de téléphones internes d'une entreprise suivants dans un
tableau de 10 positions.
* Les numéros sont compris entre 100 et 299.
* Soit $N$ le numéro de téléphone, la fonction de hachage est
$$
h(N)=N\mod 10.
$$
* La fonction de gestion des collisions est
$$
C_1(N,i)=(h(N)+3\cdot i)\mod 10.
$$
* Placer 145, 167, 110, 175, 210, 215 (mettre son état à occupé).
* Supprimer 175 (rechercher 175, et mettre son état à supprimé).
* Rechercher 35.
* Les cases ni supprimées, ni occupées sont vides.
* Expliquer se qui se passe si on utilise?
$$
C_1(N,i)=(h(N)+5\cdot i)\mod 10.
$$
# Préambule
\small
* On considère pas le cas du chaînage en cas de collisions.
* L'insertion est construite avec une forme du type
```C
index = h(key);
while (table[index].state == OCCUPIED
&& table[index].key != key) {
index = (index + k) % table_size; // attention à pas dépasser
}
table[index].key = key;
table[index].state = OCCUPIED;
```
\normalsize
* Gestion de l'état d'une case *explicite*
```C
typedef enum {EMPTY, OCCUPIED, DELETED} state;
```
# L'insertion
## Pseudocode?
. . .
```C
insert(table, key, value) {
index = hash de la clé;
index =
si "index" est déjà "occupé"
et la clé correspondante n'est pas "key"
alors gérer la collision;
changer l'état de la case "index" à "occupé";
changer la valeur de la case "index" à "value";
}
```
# La suppression
## Pseudocode?
. . .
```C
value_t remove(table, key) {
index = hash de la clé;
tant que l'état de la case n'est pas "vide"
si "index" est "occupé" et la clé est "key"
changer l'état de la case à "supprimé"
sinon
index = rehash
}
```
# La recherche
## Pseudocode?
. . .
```C
bool search(table, key, value) {
index = hash de la clé;
tant que l'état de la case n'est pas "vide"
si "index" est "occupé" et la clé est "key"
retourner vrai
sinon
index = rehash
}
```
# Écrivons le code!
* Mais avant:
* Quelles sont les structures de données dont nous avons besoin?
* Y a-t-il des fonctions auxiliaires à écrire?
* Écrire les signatures des fonctions.
. . .
## Structures de données
\footnotesize
. . .
```C
typedef enum {empty, deleted, occupied};
typedef ... key_t;
typedef ... value_t;
typedef struct _cell_t {
key_t key;
value_t value;
state_t state;
} cell_t;
typedef struct _hm {
cell_t *table;
int capacity;
int size;
} hm;
```
# Écrivons le code!
## Fonctions auxiliaires
. . .
```C
static int hash(key_t key);
static int rehash(int index, key_t key);
static int find_index(hm h, key_t key);
```
## Signature de l'API
```C
void hm_init(hm *h, int capacity);
void hm_destroy(hm *h);
bool hm_set(hm *h, key_t key, value_t *value);
bool hm_get(hm h, key_t key, value_t *value);
bool hm_remove(hm *h, key_t key, value_t *value);
bool hm_search(hm h, key_t key);
void hm_print(hm h);
```
# Live code session!
0. Offered to you by ProtonVPN[^1]!
. . .
1. Like the video.
2. Subscribe to the channel.
3. Use our one time voucher for ProtonVPN: `PAULISAWESOME`.
4. Consider donating on our patreon.
[^1]: The fastest way to connect to BBB!
slides_2021/cours_15.md 0 → 100644
View file @ febfc3f8
---
title: "Arbres"
date: "2022-02-23"
patat:
eval:
tai:
command: fish
fragment: false
replace: true
ccc:
command: fish
fragment: false
replace: true
images:
backend: auto
---
# Les arbres: définition
"Un arbre est un graphe acyclique orienté possédant une unique racine, et tel que tous les nœuds sauf la racine ont un unique parent."
. . .
**Santé!**
## Plus sérieusement
* Ensemble de **noeuds** et d'**arêtes** (graphe),
* Les arêtes relient les noeuds entre eux, mais pas n'importe comment: chaque
noeud a au plus un **parent**,
* Le seul noeud sans parent est la **racine**,
* Chaque noeud a un nombre fini de **fils**,
* La hiérarchie des noeuds rend les arêtes **orientées** (parent -> fils), et empêche les
**cycles** (acyclique, orienté).
* La **feuille** ou **noeud terminal** est un noeud sans enfants,
* Le **niveau** est 1 à la racine et **niveau+1** pour les fils,
* Le **degré** d'un noeud est le nombre de fils du noeud.
. . .
* Chaque noeud est un arbre en lui même.
* La **récursivité** sera très utile!
# Arbre ou pas arbre?
::: columns
:::: column
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
1-->2;
1-->3;
3-->2;
3-->4;
3-->5;
```
::::
. . .
:::: column
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
1-->2;
1-->3;
3-->4;
3-->5;
3-->6;
```
::::
:::
# Arbre ou pas arbre?
::: columns
:::: column
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
1-->2;
1-->3;
3-->4;
3-->5;
3-->6;
6-->7;
7-->3;
```
::::
. . .
:::: column
```{.mermaid format=pdf width=300 loc=figs/}
graph TD;
1;
```
::::
:::
# Arbre ou pas arbre?
::: columns
:::: column
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
1---2;
1---3;
3---4;
3---5;
```
::::
. . .
:::: column
```{.mermaid format=pdf width=300 loc=figs/}
graph BT;
1-->2;
1-->3;
3-->4;
3-->5;
3-->6;
```
::::
:::
# Degré et niveau
* Illustration du degré (nombre de fils) et du niveau (profondeur)
::: columns
:::: column
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
1[degré 2]-->2[degré 0];
1-->3[degré 3];
3-->4[degré 0];
3-->5[degré 0];
3-->6[degré 0];
```
::::
. . .
:::: column
```{.mermaid format=pdf width=300 loc=figs/}
graph TD;
1[niveau 1]-->2[niveau 2];
1-->3[niveau 2];
3-->4[niveau 3];
3-->5[niveau 3];
3-->6[niveau 3];
```
::::
:::
* Les noeuds de degré 0, sont des feuilles.
# Application: recherche rapide
## Pouvez vous construire un arbre pour résoudre le nombre secret?
. . .
* Le nombre secret ou la recherche dychotomique (nombre entre 0 et 10).
::: columns
:::: column
```{.mermaid format=pdf width=400 loc=figs/}
graph LR;
5-->|<|2;
5-->|>|7;
7-->|>|8;
7-->|<|6;
8-->|>|9;
9-->|>|10;
2-->|<|1;
2-->|>|3;
3-->|>|4;
1-->|<|0;
```
::::
:::: column
**Question:** Quelle est la complexité pour trouver un nombre?
::::
:::
# Autres représentation
* Botanique
* **Exercice:** Ajouter les degrés/niveaux et feuilles
```{.mermaid width=250 format=pdf loc=figs/}
graph TD;
A-->B;
A-->C;
B-->D;
B-->E;
B-->F;
F-->I;
F-->J;
C-->G;
C-->H;
H-->K;
```
# Autres représentation
* Ensembliste
::: columns
:::: column
```{.mermaid width=300 format=pdf loc=figs/}
graph TD;
A-->B;
A-->C;
B-->D;
B-->E;
B-->F;
F-->I;
F-->J;
C-->G;
C-->H;
H-->K;
```
::::
. . .
:::: column
![](figs/ensemble.svg)
::::
:::
# Autres représentation
* Liste
::: columns
:::: column
```{.mermaid width=400 format=pdf loc=figs/}
graph TD;
A-->B;
A-->C;
B-->D;
B-->E;
B-->F;
F-->I;
F-->J;
C-->G;
C-->H;
H-->K;
```
::::
. . .
:::: column
```
(A
(B
(D)
(E)
(F
(I)
(J)
)
)
(C
(G)
(H
(K)
)
)
)
```
::::
:::
# Autres représentation
* Par niveau
::: columns
:::: column
```{.mermaid width=400 format=pdf loc=figs/}
graph TD;
A-->B;
A-->C;
B-->D;
B-->E;
B-->F;
F-->I;
F-->J;
C-->G;
C-->H;
H-->K;
```
::::
. . .
:::: column
```
1 2 3 4
-------------------------
A
B
D
E
F
I
J
C
G
H
K
```
::::
:::
# L'arbre binaire
* Structure de données abstraite,
* Chaque noeud a au plus deux fils: gauche et droite,
* Chaque fils est un arbre.
## Comment représenteriez vous une telle structure?
. . .
```C
<R, G, D>
R: racine
G: sous-arbre gauche
D: sous-arbre droite
```
## Comment cela s'écrirait en C?
. . .
```C
typedef struct _node {
contenu info;
struct _node *left, *right;
} node;
typedef node *tree;
```
# L'arbre binaire
## Que se passerait-il avec
```C
typedef struct _node {
int info;
struct _node left, right;
} node;
```
* On ne sait pas quelle est la taille de node, on ne peut pas l'allouer!
## Interface minimale
* Qu'y mettriez vous?
. . .
```C
NULL -> arbre (vide)
<n, arbre, arbre> -> arbre
visiter(arbre) -> noeud (la racine de l'arbre)
gauche(arbre) -> arbre (sous-arbre de gauche)
droite(arbre) -> arbre (sous-arbre de droite)
```
* Les autres opérations (insertion, parcours, etc) dépendent de ce qu'on stocke
dans l'arbre.
# Exemple d'arbre binaire
* Représentez `(c - a * b) * (d + e / f)` à l'aide d'un arbre binaire (matrix)
. . .
::: columns
:::: column
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
A[*]-->B[-];
B-->C[c];
B-->D[*];
D-->E[a];
D-->F[b];
A-->G[+];
G-->H[d];
G-->I["/"];
I-->J[e];
I-->K[f];
```
::::
:::: column
## Remarques
* L'arbre est **hétérogène**: le genre d'info est pas le même sur chaque noeud
(opérateur, opérande).
* Les feuilles contiennent les opérandes.
* Les noeuds internes contiennent les opérateurs.
::::
:::
# Parcours d'arbres binaires
* Appliquer une opération à tous les noeuds de l'arbre,
* Nécessité de **parcourir** l'arbre,
* Utiliser uniquement l'interface: visiter, gauche,
droite.
## Une idée de comment parcourir cet arbre?
* 3 parcours (R: Racine, G: sous-arbre gauche, D: sous-arbre droit):
::: columns
:::: column
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
A[*]-->B[-];
B-->C[c];
B-->D[*];
D-->E[a];
D-->F[b];
A-->G[+];
G-->H[d];
G-->I["/"];
I-->J[e];
I-->K[f];
```
::::
:::: column
1. Pacrours **préfixe** (R, G D),
2. Parcours **infixe** (G, R, D),
3. Parcours **postfixe** (G, D, R).
::::
:::
# Le parcours infixe (G, R, D)
* Gauche, Racine, Droite:
1. On descend dans l'arbre de gauche tant qu'il est pas vide,
2. On visite la racine du sous arbre,
3. On descend dans le sous-arbre de droite (s'il est pas vide),
4. On recommence.
. . .
## Incompréhensible?
* La récursivité c'est la vie.
```
parcours_infixe(arbre a)
si est_pas_vide(gauche(a))
parcours_infixe(gauche(a))
visiter(A)
si est_pas_vide(droite(A))
parcours_infixe(droite(A))
```
# Graphiquement (dessinons)
::: columns
:::: column
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
A[*]-->B[-];
B-->C[c];
B-->D[*];
D-->E[a];
D-->F[b];
A-->G[+];
G-->H[d];
G-->I["/"];
I-->J[e];
I-->K[f];
```
::::
:::: column
```
parcours_infixe(arbre a)
si est_pas_vide(gauche(a))
parcours_infixe(gauche(a))
visiter(A)
si est_pas_vide(droite(A))
parcours_infixe(droite(A))
```
::::
:::
# Graphiquement (`mermaid` c'est super)
::: columns
:::: column
```{.mermaid format=pdf width=400 loc=figs/}
graph TD;
A[*]-->B[-];
A[*]-.->|1|B[-];
B-->C[c];
B-.->|2|C[c];
C-.->|3|B;
B-->D[*];
B-.->|4|D;
D-->E[a];
D-.->|5|E;
E-.->|6|D;
D-->F[b];
D-.->|7|F;
F-.->|8|A;
A-->G[+];
A-.->|9|G;
G-->H[d];
G-.->|10|H;
H-.->|11|G;
G-->I["/"];
G-.->|12|I;
I-->J[e];
I-.->|13|J;
J-.->|14|I;
I-->K[f];
I-.->|15|K;
```
::::
:::: column
```
parcours_infixe(arbre a)
si est_pas_vide(gauche(a))
parcours_infixe(gauche(a))
visiter(A)
si est_pas_vide(droite(A))
parcours_infixe(droite(A))
```
## Remarque
Le noeud est visité à la **remontée**.
## Résultat
```
c - a * b * d + e / f
```
::::
:::
# Et en C?
## Live code
\footnotesize
. . .
```C
typedef int data;
typedef struct _node {
data info;
struct _node* left;
struct _node* right;
} node;
typedef node* tree_t;
void tree_print(tree_t tree, int n) {
if (NULL != tree) {
tree_print(tree->left, n+1);
for (int i = 0; i < n; i++) {
printf(" ");
}
printf("%d\n", tree->info);
tree_print(tree->right, n+1);
}
}
```
# Question
## Avez-vous compris le fonctionnement?
. . .
## Vous en êtes sûr·e·s?
. . .
## OK, alors deux exercices:
1. Écrire le pseudo-code pour le parcours R, G, D (matrix).
2. Écrire le pseudo-code pour la parcours G, D, R (matrix),
## Rappel
```
parcours_infixe(arbre a)
si est_pas_vide(gauche(a))
parcours_infixe(gauche(a))
visiter(A)
si est_pas_vide(droite(A))
parcours_infixe(droite(A))
```
# Correction
\footnotesize
* Les deux parcours sont des modifications **triviales**[^1] de l'algorithme
infixe.
## Le parcours postfixe
```python
parcours_postfoxe(arbre a)
si est_pas_vide(gauche(a))
parcours_postfixe(gauche(a))
si est_pas_vide(droite(a))
parcours_postfixe(droite(a))
visiter(a)
```
## Le parcours préfixe
```python
parcourx_préfixe(arbre a)
visiter(a)
si est_pas_vide(gauche(a))
parcours_préfixe(gauche(a))
si est_pas_vide(droite(a))
parcours_préfixe(droite(a))
```
. . .
**Attention:** L'implémentation de ces fonctions en C sont **à faire** en
exercice (inspirez vous de ce qu'on a fait avant)!
# Exercice: parcours
## Comment imprimer l'arbre ci-dessous?
```
f
/
e
+
d
*
c
-
b
*
a
```
. . .
## Bravo vous avez trouvé!
* Il s'agissait du parcours D, R, G.
# Implémentation
## Vous avez 5 min pour implémenter cette fonction et la poster sur matrix!
. . .
```C
void pretty_print(tree_t tree, int n) {
if (NULL != tree) {
pretty_print(tree->right, n+1);
for (int i = 0; i < n; ++i) {
printf(" ");
}
printf("%d\n", tree->info);
pretty_print(tree->left);
}
}
```
# Exercice supplémentaire (sans corrigé)
Écrire le code de la fonction
```C
int depth(tree_t t);
```
qui retourne la profondeur maximale d'un arbre.
Indice: la profondeur à chaque niveau peut-être calculée à partir du niveau des
sous-arbres de gauche et de droite.
# La recherche dans un arbre binaire
* Les arbres binaires peuvent retrouver une information très rapidement.
* À quelle complexité? À quelle condition?
. . .
## Condition
* Le contenu de l'arbre est **ordonné** (il y a une relation d'ordre (`<`, `>`
entre les éléemts).
## Complexité
* La profondeur de l'arbre (ou le $\mathcal{O}(\log_2(N))$)
. . .
## Exemple: les arbres lexicographiques
* Chaque noeud contient une information de type ordonné, la **clé**,
* Par construction, pour chaque noeud $N$:
* Toutes clé du sous-arbre à gauche de $N$ sont inférieurs à la clé de $N$.
* Toutes clé du sous-arbre à droite de $N$ sont inférieurs à la clé de $N$.
# Algorithme de recherche
* Retourner le noeud si la clé est trouvée dans l'arbre.
```python
arbre recherche(clé, arbre)
tante_que est_non_vide(arbre)
si clé < clé(arbre)
arbre = gauche(arbre)
sinon si clé > clé(arbre)
arbre = droite(arbre)
sinon
retourne arbre
retourne NULL
```
# Algorithme de recherche, implémentation (live)
\footnotesize
. . .
```C
typedef int key_t;
typedef struct _node {
key_t key;
struct _node* left;
struct _node* right;
} node;
typedef node* tree_t;
tree_t search(key_t key, tree_t tree) {
tree_t current = tree;
while (NULL != current) {
if (current->key > X) {
current = current->gauche;
} else if (current->key < X){
current = current->droite;
} else {
return current;
}
}
return NULL;
}
```
# Exercice (5-10min)
Écrire le code de la fonction
```C
int tree_size(tree_t tree);
```
qui retourne le nombre total de noeuds d'un arbre et poster le résutat sur
matrix.
Indication: la taille, est 1 + le nombre de noeuds du sous-arbre de gauche
additionné au nombre de noeuds dans le sous-arbre de droite.
. . .
```C
int arbre_size(tree_t tree) {
if (NULL == tree) {
return 0;
} else {
return 1 + tree_size(tree->left)
+ tree_size(tree->right);
}
}
```
# L'insertion dans un arbre binaire
* C'est bien joli de pouvoir faire des parcours, recherches, mais si on peut
pas construire l'arbre....
## Pour un arbre lexicographique
* Rechercher la position dans l'arbre où insérer.
* Créer un noeud avec la clé et le rattacher à l'arbre.
# Exemple d'insertions
* Clés uniques pour simplifier.
* Insertion de 5, 15, 10, 25, 2, -5, 12, 14, 11.
* Rappel:
* Plus petit que la clé courante => gauche,
* Plus grand que la clé courante => droite.
* Faisons le dessins ensemble
```
```
## Exercice (3min, puis matrix)
* Dessiner l'arbre en insérant 20, 30, 60, 40, 10, 15, 25, -5
# Pseudocode d'insertion (1/2)
* Deux parties:
* Recherche le parent où se passe l'insertion.
* Ajout du fils dans l'arbre.
## Recherche du parent
```
arbre position(arbre, clé)
si est_non_vide(arbre)
si clé < clé(arbre)
suivant = gauche(arbre)
sinon
suivant = droite(arbre)
tant que clé(arbre) != clé && est_non_vide(suivant)
arbre = suivant
si clé < clé(arbre)
suivant = gauche(arbre)
sinon
suivant = droite(arbre)
retourne arbre
```
# Pseudocode d'insertion (2/2)
* Deux parties:
* Recherche de la position.
* Ajout dans l'arbre.
## Ajout du fils
```
ajout(arbre, clé)
si est_vide(arbre)
arbre = noeud(clé)
sinon
si clé < clé(arbre)
gauche(arbre) = noeud(clé)
sinon si clé > clé(arbre)
droite(arbre) = noeud(clé)
sinon
retourne
```
# Code d'insertion en C (1/2)
## Recherche du parent (ensemble)
. . .
```C
tree_t position(tree_t tree, key_t key) {
tree_t current = tree;
if (NULL != current) {
tree_t subtree = key > current->key ? current->right :
current->left;
while (key != current->key && NULL != subtree) {
current = subtree;
subtree = key > current->key ? current->right :
current->left;
}
}
return current;
}
```
[^1]: Copyright cours de mathématiques pendant trop d'années.