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
Loading items

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
Loading items
Show changes
Commits on Source (552)
452 additional commits have been omitted to prevent performance issues.
Expand all Show whitespace changes
Inline Side-by-side
Showing
with 8401 additions and 2278 deletions
.gitignore
View file @ febfc3f8
*.o
*.xopp*
slides/package-lock.json
slides/package.json
slides/.vscode/settings.json
.vscode/settings.json
slides/node_modules/.package-lock.json
README.md 0 → 100644
View file @ febfc3f8
# Remerciements et contributions
Merci aux contributeurs suivants pour leurs efforts (dans un ordre alphabétique):
* P. Albuquerque
* J. Bach
* A. Boyer
* M. Corboz
* M. Divià
* Y. El Hakouni
* A. Escribano
* P. Kunzli
* G. Legouic
* G. Marino Jarrin
* H. Radhwan
* I. Saroukhanian
* C. Volta
css/tufte-css/tufte.css 0 → 100644
View file @ febfc3f8
@charset "UTF-8";
/* Import ET Book styles
adapted from https://github.com/edwardtufte/et-book/blob/gh-pages/et-book.css */
@font-face {
font-family: "et-book";
src: url("et-book/et-book-roman-line-figures/et-book-roman-line-figures.eot");
src: url("et-book/et-book-roman-line-figures/et-book-roman-line-figures.eot?#iefix") format("embedded-opentype"), url("et-book/et-book-roman-line-figures/et-book-roman-line-figures.woff") format("woff"), url("et-book/et-book-roman-line-figures/et-book-roman-line-figures.ttf") format("truetype"), url("et-book/et-book-roman-line-figures/et-book-roman-line-figures.svg#etbookromanosf") format("svg");
font-weight: normal;
font-style: normal;
font-display: swap;
}
@font-face {
font-family: "et-book";
src: url("et-book/et-book-display-italic-old-style-figures/et-book-display-italic-old-style-figures.eot");
src: url("et-book/et-book-display-italic-old-style-figures/et-book-display-italic-old-style-figures.eot?#iefix") format("embedded-opentype"), url("et-book/et-book-display-italic-old-style-figures/et-book-display-italic-old-style-figures.woff") format("woff"), url("et-book/et-book-display-italic-old-style-figures/et-book-display-italic-old-style-figures.ttf") format("truetype"), url("et-book/et-book-display-italic-old-style-figures/et-book-display-italic-old-style-figures.svg#etbookromanosf") format("svg");
font-weight: normal;
font-style: italic;
font-display: swap;
}
@font-face {
font-family: "et-book";
src: url("et-book/et-book-bold-line-figures/et-book-bold-line-figures.eot");
src: url("et-book/et-book-bold-line-figures/et-book-bold-line-figures.eot?#iefix") format("embedded-opentype"), url("et-book/et-book-bold-line-figures/et-book-bold-line-figures.woff") format("woff"), url("et-book/et-book-bold-line-figures/et-book-bold-line-figures.ttf") format("truetype"), url("et-book/et-book-bold-line-figures/et-book-bold-line-figures.svg#etbookromanosf") format("svg");
font-weight: bold;
font-style: normal;
font-display: swap;
}
@font-face {
font-family: "et-book-roman-old-style";
src: url("et-book/et-book-roman-old-style-figures/et-book-roman-old-style-figures.eot");
src: url("et-book/et-book-roman-old-style-figures/et-book-roman-old-style-figures.eot?#iefix") format("embedded-opentype"), url("et-book/et-book-roman-old-style-figures/et-book-roman-old-style-figures.woff") format("woff"), url("et-book/et-book-roman-old-style-figures/et-book-roman-old-style-figures.ttf") format("truetype"), url("et-book/et-book-roman-old-style-figures/et-book-roman-old-style-figures.svg#etbookromanosf") format("svg");
font-weight: normal;
font-style: normal;
font-display: swap;
}
/* Tufte CSS styles */
html {
font-size: 15px;
}
body {
width: 87.5%;
margin-left: auto;
margin-right: auto;
padding-left: 12.5%;
font-family: et-book, Palatino, "Palatino Linotype", "Palatino LT STD", "Book Antiqua", Georgia, serif;
background-color: #fffff8;
color: #111;
max-width: 1400px;
counter-reset: sidenote-counter;
}
h1 {
font-weight: 400;
margin-top: 4rem;
margin-bottom: 1.5rem;
font-size: 3.2rem;
line-height: 1;
}
h2 {
font-style: italic;
font-weight: 400;
margin-top: 2.1rem;
margin-bottom: 1.4rem;
font-size: 2.2rem;
line-height: 1;
}
h3 {
font-style: italic;
font-weight: 400;
font-size: 1.7rem;
margin-top: 2rem;
margin-bottom: 1.4rem;
line-height: 1;
}
hr {
display: block;
height: 1px;
width: 55%;
border: 0;
border-top: 1px solid #ccc;
margin: 1em 0;
padding: 0;
}
p.subtitle {
font-style: italic;
margin-top: 1rem;
margin-bottom: 1rem;
font-size: 1.8rem;
display: block;
line-height: 1;
}
.numeral {
font-family: et-book-roman-old-style;
}
.danger {
color: red;
}
article {
padding: 5rem 0rem;
}
section {
padding-top: 1rem;
padding-bottom: 1rem;
}
p,
dl,
ol,
ul {
font-size: 1.4rem;
line-height: 2rem;
}
p {
margin-top: 1.4rem;
margin-bottom: 1.4rem;
padding-right: 0;
vertical-align: baseline;
}
/* Chapter Epigraphs */
div.epigraph {
margin: 5em 0;
}
div.epigraph > blockquote {
margin-top: 3em;
margin-bottom: 3em;
}
div.epigraph > blockquote,
div.epigraph > blockquote > p {
font-style: italic;
}
div.epigraph > blockquote > footer {
font-style: normal;
}
div.epigraph > blockquote > footer > cite {
font-style: italic;
}
/* end chapter epigraphs styles */
blockquote {
font-size: 1.4rem;
}
blockquote p {
width: 55%;
margin-right: 40px;
}
blockquote footer {
width: 55%;
font-size: 1.1rem;
text-align: right;
}
section > p,
section > footer,
section > table {
width: 55%;
}
/* 50 + 5 == 55, to be the same width as paragraph */
section > dl,
section > ol,
section > ul {
width: 50%;
-webkit-padding-start: 5%;
}
dt:not(:first-child),
li:not(:first-child) {
margin-top: 0.25rem;
}
figure {
padding: 0;
border: 0;
font-size: 100%;
font: inherit;
vertical-align: baseline;
max-width: 55%;
-webkit-margin-start: 0;
-webkit-margin-end: 0;
margin: 0 0 3em 0;
}
figcaption {
float: right;
clear: right;
margin-top: 0;
margin-bottom: 0;
font-size: 1.1rem;
line-height: 1.6;
vertical-align: baseline;
position: relative;
max-width: 40%;
}
figure.fullwidth figcaption {
margin-right: 24%;
}
/* Links: replicate underline that clears descenders */
a:link,
a:visited {
color: inherit;
}
.no-tufte-underline:link {
background: unset;
text-shadow: unset;
}
a:link, .tufte-underline, .hover-tufte-underline:hover {
text-decoration: none;
background: -webkit-linear-gradient(#fffff8, #fffff8), -webkit-linear-gradient(#fffff8, #fffff8), -webkit-linear-gradient(currentColor, currentColor);
background: linear-gradient(#fffff8, #fffff8), linear-gradient(#fffff8, #fffff8), linear-gradient(currentColor, currentColor);
-webkit-background-size: 0.05em 1px, 0.05em 1px, 1px 1px;
-moz-background-size: 0.05em 1px, 0.05em 1px, 1px 1px;
background-size: 0.05em 1px, 0.05em 1px, 1px 1px;
background-repeat: no-repeat, no-repeat, repeat-x;
text-shadow: 0.03em 0 #fffff8, -0.03em 0 #fffff8, 0 0.03em #fffff8, 0 -0.03em #fffff8, 0.06em 0 #fffff8, -0.06em 0 #fffff8, 0.09em 0 #fffff8, -0.09em 0 #fffff8, 0.12em 0 #fffff8, -0.12em 0 #fffff8, 0.15em 0 #fffff8, -0.15em 0 #fffff8;
background-position: 0% 93%, 100% 93%, 0% 93%;
}
@media screen and (-webkit-min-device-pixel-ratio: 0) {
a:link, .tufte-underline, .hover-tufte-underline:hover {
background-position-y: 87%, 87%, 87%;
}
}
a:link::selection,
a:link::-moz-selection {
text-shadow: 0.03em 0 #b4d5fe, -0.03em 0 #b4d5fe, 0 0.03em #b4d5fe, 0 -0.03em #b4d5fe, 0.06em 0 #b4d5fe, -0.06em 0 #b4d5fe, 0.09em 0 #b4d5fe, -0.09em 0 #b4d5fe, 0.12em 0 #b4d5fe, -0.12em 0 #b4d5fe, 0.15em 0 #b4d5fe, -0.15em 0 #b4d5fe;
background: #b4d5fe;
}
/* Sidenotes, margin notes, figures, captions */
img {
max-width: 100%;
}
.sidenote,
.marginnote {
float: right;
clear: right;
margin-right: -60%;
width: 50%;
margin-top: 0.3rem;
margin-bottom: 0;
font-size: 1.1rem;
line-height: 1.3;
vertical-align: baseline;
position: relative;
}
.sidenote-number {
counter-increment: sidenote-counter;
}
.sidenote-number:after,
.sidenote:before {
font-family: et-book-roman-old-style;
position: relative;
vertical-align: baseline;
}
.sidenote-number:after {
content: counter(sidenote-counter);
font-size: 1rem;
top: -0.5rem;
left: 0.1rem;
}
.sidenote:before {
content: counter(sidenote-counter) " ";
font-size: 1rem;
top: -0.5rem;
}
blockquote .sidenote,
blockquote .marginnote {
margin-right: -82%;
min-width: 59%;
text-align: left;
}
div.fullwidth,
table.fullwidth {
width: 100%;
}
div.table-wrapper {
overflow-x: auto;
font-family: "Trebuchet MS", "Gill Sans", "Gill Sans MT", sans-serif;
}
.sans {
font-family: "Gill Sans", "Gill Sans MT", Calibri, sans-serif;
letter-spacing: .03em;
}
code, pre > code {
font-family: Consolas, "Liberation Mono", Menlo, Courier, monospace;
font-size: 1.0rem;
line-height: 1.42;
-webkit-text-size-adjust: 100%; /* Prevent adjustments of font size after orientation changes in iOS. See https://github.com/edwardtufte/tufte-css/issues/81#issuecomment-261953409 */
}
.sans > code {
font-size: 1.2rem;
}
h1 > code,
h2 > code,
h3 > code {
font-size: 0.80em;
}
.marginnote > code,
.sidenote > code {
font-size: 1rem;
}
pre > code {
font-size: 0.9rem;
width: 52.5%;
margin-left: 2.5%;
overflow-x: auto;
display: block;
}
pre.fullwidth > code {
width: 90%;
}
.fullwidth {
max-width: 90%;
clear:both;
}
span.newthought {
font-variant: small-caps;
font-size: 1.2em;
}
input.margin-toggle {
display: none;
}
label.sidenote-number {
display: inline;
}
label.margin-toggle:not(.sidenote-number) {
display: none;
}
.iframe-wrapper {
position: relative;
padding-bottom: 56.25%; /* 16:9 */
padding-top: 25px;
height: 0;
}
.iframe-wrapper iframe {
position: absolute;
top: 0;
left: 0;
width: 100%;
height: 100%;
}
@media (max-width: 760px) {
body {
width: 84%;
padding-left: 8%;
padding-right: 8%;
}
hr,
section > p,
section > footer,
section > table {
width: 100%;
}
pre > code {
width: 97%;
}
section > dl,
section > ol,
section > ul {
width: 90%;
}
figure {
max-width: 90%;
}
figcaption,
figure.fullwidth figcaption {
margin-right: 0%;
max-width: none;
}
blockquote {
margin-left: 1.5em;
margin-right: 0em;
}
blockquote p,
blockquote footer {
width: 100%;
}
label.margin-toggle:not(.sidenote-number) {
display: inline;
}
.sidenote,
.marginnote {
display: none;
}
.margin-toggle:checked + .sidenote,
.margin-toggle:checked + .marginnote {
display: block;
float: left;
left: 1rem;
clear: both;
width: 95%;
margin: 1rem 2.5%;
vertical-align: baseline;
position: relative;
}
label {
cursor: pointer;
}
div.table-wrapper,
table {
width: 85%;
}
img {
width: 100%;
}
}
slides/.clang-format 0 → 100644
View file @ febfc3f8
---
Language: Cpp
# BasedOnStyle: Google
AccessModifierOffset: -4
AlignAfterOpenBracket: AlwaysBreak
AlignConsecutiveAssignments: None
AlignConsecutiveBitFields: None
AlignConsecutiveDeclarations: None
AlignConsecutiveMacros: true
AlignEscapedNewlines: Left
AlignOperands: Align
AlignTrailingComments: true
AllowAllArgumentsOnNextLine: true
AllowAllConstructorInitializersOnNextLine: true
AllowAllParametersOfDeclarationOnNextLine: true
AllowShortEnumsOnASingleLine: true
AllowShortBlocksOnASingleLine: Never
AllowShortCaseLabelsOnASingleLine: false
AllowShortFunctionsOnASingleLine: Empty
AllowShortLambdasOnASingleLine: Empty
AllowShortIfStatementsOnASingleLine: Never
AllowShortLoopsOnASingleLine: false
AlwaysBreakAfterDefinitionReturnType: None
AlwaysBreakAfterReturnType: None
AlwaysBreakBeforeMultilineStrings: true
AlwaysBreakTemplateDeclarations: Yes
BinPackArguments: true
BinPackParameters: true
BitFieldColonSpacing: Both
BraceWrapping:
AfterCaseLabel: false
AfterClass: false
AfterControlStatement: MultiLine
AfterEnum: false
AfterFunction: false
AfterNamespace: false
AfterObjCDeclaration: false
AfterStruct: false
AfterUnion: false
AfterExternBlock: false
BeforeCatch: false
BeforeElse: false
BeforeLambdaBody: false
BeforeWhile: false
IndentBraces: false
SplitEmptyFunction: false
SplitEmptyRecord: true
SplitEmptyNamespace: true
BreakBeforeBinaryOperators: NonAssignment
BreakBeforeBraces: Custom
BreakBeforeInheritanceComma: false
BreakInheritanceList: AfterColon
BreakBeforeTernaryOperators: true
BreakConstructorInitializersBeforeComma: false
BreakConstructorInitializers: AfterColon
BreakAfterJavaFieldAnnotations: false
BreakStringLiterals: true
ColumnLimit: 100
CommentPragmas: '^ IWYU pragma:'
CompactNamespaces: false
ConstructorInitializerAllOnOneLineOrOnePerLine: true
ConstructorInitializerIndentWidth: 4
ContinuationIndentWidth: 4
Cpp11BracedListStyle: true
DeriveLineEnding: false
DerivePointerAlignment: false
DisableFormat: false
ExperimentalAutoDetectBinPacking: false
FixNamespaceComments: true
ForEachMacros:
- foreach
- Q_FOREACH
- BOOST_FOREACH
IncludeBlocks: Regroup
IncludeCategories:
- Regex: '^<ext/.*\.h>'
Priority: 2
SortPriority: 0
- Regex: '^<.*\.h>'
Priority: 1
SortPriority: 0
- Regex: '^<.*'
Priority: 2
SortPriority: 0
- Regex: '.*'
Priority: 3
SortPriority: 0
IncludeIsMainRegex: '([-_](test|unittest))?$'
IncludeIsMainSourceRegex: ''
IndentCaseLabels: false
IndentCaseBlocks: false
IndentGotoLabels: false
IndentPPDirectives: None
IndentExternBlock: AfterExternBlock
IndentWidth: 4
IndentWrappedFunctionNames: true
InsertTrailingCommas: None
JavaScriptQuotes: Leave
JavaScriptWrapImports: true
KeepEmptyLinesAtTheStartOfBlocks: false
MacroBlockBegin: ''
MacroBlockEnd: ''
MaxEmptyLinesToKeep: 1
NamespaceIndentation: None
ObjCBinPackProtocolList: Never
ObjCBlockIndentWidth: 2
ObjCBreakBeforeNestedBlockParam: true
ObjCSpaceAfterProperty: false
ObjCSpaceBeforeProtocolList: true
PenaltyBreakAssignment: 2
PenaltyBreakBeforeFirstCallParameter: 1
PenaltyBreakComment: 300
PenaltyBreakFirstLessLess: 120
PenaltyBreakString: 1000
PenaltyBreakTemplateDeclaration: 10
PenaltyExcessCharacter: 1000000
PenaltyReturnTypeOnItsOwnLine: 200
PointerAlignment: Right
RawStringFormats:
- Language: Cpp
Delimiters:
- cc
- CC
- cpp
- Cpp
- CPP
- 'c++'
- 'C++'
CanonicalDelimiter: ''
BasedOnStyle: google
- Language: TextProto
Delimiters:
- pb
- PB
- proto
- PROTO
EnclosingFunctions:
- EqualsProto
- EquivToProto
- PARSE_PARTIAL_TEXT_PROTO
- PARSE_TEST_PROTO
- PARSE_TEXT_PROTO
- ParseTextOrDie
- ParseTextProtoOrDie
- ParseTestProto
- ParsePartialTestProto
CanonicalDelimiter: ''
BasedOnStyle: google
ReflowComments: true
SortIncludes: false
SortUsingDeclarations: false
SpaceAfterCStyleCast: false
SpaceAfterLogicalNot: false
SpaceAfterTemplateKeyword: true
SpaceBeforeAssignmentOperators: true
SpaceBeforeCpp11BracedList: true
SpaceBeforeCtorInitializerColon: true
SpaceBeforeInheritanceColon: true
SpaceBeforeParens: ControlStatements
SpaceBeforeRangeBasedForLoopColon: true
SpaceInEmptyBlock: true
SpaceInEmptyParentheses: false
SpacesBeforeTrailingComments: 2
SpacesInAngles: false
SpacesInConditionalStatement: false
SpacesInContainerLiterals: false
SpacesInCStyleCastParentheses: false
SpacesInParentheses: false
SpacesInSquareBrackets: false
SpaceBeforeSquareBrackets: false
Standard: Auto
StatementMacros:
- Q_UNUSED
- QT_REQUIRE_VERSION
TabWidth: 4
UseCRLF: false
UseTab: Never
WhitespaceSensitiveMacros:
- STRINGIZE
- PP_STRINGIZE
- BOOST_PP_STRINGIZE
...
slides/.gitignore
View file @ febfc3f8
*.pdf
*.err
diagram*.pdf
cours*.pdf
intro.pdf
mermaid-filter.err
.puppeteer.json
slides/.puppeteer.json deleted 100644 → 0
View file @ bab8ccf0
{
"executablePath": "/usr/bin/chromium-browser",
"args": ["--no-sandbox"]
}
slides/Makefile
View file @ febfc3f8
......@@ -10,29 +10,35 @@ PDFOPTIONS += -V urlcolor=blue
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: $(PDF) # La cible par défaut (all) exécute les cibles %.pdf
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 all -k || true
docker compose run slides
docker_clean: docker-compose.yml
docker-compose run slides make clean -k || true
docker compose run slides clean
puppeteer:
@echo "Setting chromium to $(CHROMIUM) for puppeteer"
@echo -e "{\n\"executablePath\":" \"$(CHROMIUM)\" ",\n\"args\": [\"--no-sandbox\"]\n}" > .puppeteer.json
# @echo "{\n\"executablePath\":" \"$(CHROMIUM)\" ",\n\"args\": [\"--no-sandbox\"]\n}" > .puppeteer.json
index.md: gen_index.sh
$(shell ./gen_index.sh)
index.html: index.md
pandoc -s $(OPTIONS) --css ../css/tufte-css/tufte.css -o $@ $^
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 $@ $^
# %.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)
# ifeq ($(PANDOC),pandoc)
# pandoc -s $(OPTIONS) $(PDFOPTIONS) -o $@ $^
# else
# -s $(OPTIONS) $(PDFOPTIONS) -o $@ $^
# endif
%.markdown: %.md metadata.yaml yq
sed '1 { /^---/ { :a N; /\n---/! ba; d} }' $< > no_header
grep -v -F -x -f no_header $< > header.yaml
......@@ -45,9 +51,12 @@ 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
deploy: all index.html
mkdir -p algo_cours
cp *.pdf algo_cours
cp index.html algo_cours
clean:
rm -f *.pdf *.markdown yq_linux_amd64*
rm -rf *.html *.pdf *.markdown yq_linux_amd64* index.md .puppeteer.json algo_cours *.err
.PHONY: clean index.md puppeteer yq
slides/cours_1.md
View file @ febfc3f8
---
title: "Introduction aux algorithmes"
date: "2021-09-22"
title: "Introduction aux algorithmes I"
date: "2024-09-16"
---
# Qu'est-ce qu'un algorithme?
......@@ -42,7 +42,7 @@ de résoudre typiquement une classe de problèmes ou effectuer un calcul.
. . .
* Opérateurs (arthimétiques / booléens)
* Opérateurs (arithmétiques / booléens)
* Boucles;
* Structures de contrôle;
* Fonctions;
......@@ -57,14 +57,12 @@ 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 {
booléen est_premier(nombre)
si
pour tout i, t.q. 1 < i < nombre
i ne divise pas nombre
}
} alors vrai
alors vrai
sinon faux
}
```
. . .
......@@ -80,14 +78,12 @@ est_premier(nombre) {
## 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
booléen 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
}
i = i + 1
retourne vrai // expression typée
```
......@@ -103,7 +99,7 @@ bool est_premier(int nombre) {
if (0 == nombre % i) { // is i divise nombre
return false; // i n'est pas premier
}
i += 1; // sinon on incrémente i
i = i + 1; // sinon on incrémente i
}
return true;
}
......@@ -125,9 +121,9 @@ bool est_premier(int nombre) {
- 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
```console
$ gcc -O1 -std=c11 -Wall -Wextra -g prog.c -o prog
-fsanitize=address
```
1. `-std=c11` utilisation de C11.
2. `-Wall et -Wextra` activation des warnings.
......@@ -244,7 +240,7 @@ int main() {
# Quiz: compile ou compile pas?
## [Quiz: compile ou compile pas](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=1033948)
## [Quiz: compile ou compile pas](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=501934)
# Types de base (1/4)
......@@ -292,7 +288,7 @@ Type Signification
# Quiz: booléens
## [Quiz: booléens](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=1032492)
## [Quiz: booléens](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=501922)
<!-- TODO Quiz en ligne -->
<!-- ```C
......@@ -336,7 +332,7 @@ if (x) { /* vrai */ }
# Quiz: conversions
## [Quiz: conversions](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=1033446)
## [Quiz: conversions](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=501925)
<!-- TODO Quiz en ligne -->
<!-- ```C
......@@ -351,343 +347,3 @@ 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/cours_10.md
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
...
title: "Backtracking et piles"
date: "2024-12-02"
---
# La liste chaînée et pile (1/N)
# Le problème des 8-reines
## Structure de données
\Huge Le problème des 8-reines
* 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.
# Problème des 8-reines
![Un exemple de liste chaînée.](figs/Singly-linked-list.svg){width=80%}
* Placer 8 reines sur un échiquier de $8 \times 8$.
* Sans que les reines ne puissent se menacer mutuellement (92 solutions).
# La liste chaînée et pile (2/N)
## Conséquence
## Une pile-liste-chaînée
* Deux reines ne partagent pas la même rangée, colonne, ou diagonale.
* Donc chaque solution a **une** reine **par colonne** ou **ligne**.
```C
typedef struct _element {
int data;
struct _element *next;
} element;
typedef element* stack;
```
## Généralisation
## Fonctionnalités?
* Placer $N$ reines sur un échiquier de $N \times
N$.
- Exemple de **backtracking** (retour en arrière) $\Rightarrow$ récursivité.
. . .
![Problème des 8-reines. Source:
[wikipedia](https://fr.wikipedia.org/wiki/Problème_des_huit_dames)](./figs/fig_recursivite_8_reines.png){width=35%}
```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;
```
# Problème des 2-reines
![Le problème des 2 reines n'a pas de solution.](figs/2reines.svg){width=50%}
# La liste chaînée et pile (3/N)
# Comment trouver les solutions?
## Empiler? (faire un dessin)
* On pose la première reine sur la première case disponible.
* On rend inaccessibles toutes les cases menacées.
* On pose la reine suivante sur la prochaine case non-menacée.
* Jusqu'à ce qu'on puisse plus poser de reine.
* On revient alors en arrière jusqu'au dernier coup où il y avait plus qu'une
possibilité de poser une reine.
* On recommence depuis là.
. . .
```C
* Le jeu prend fin quand on a énuméré *toutes* les possibilités de poser les
reines.
# Problème des 3-reines
![Le problème des 3 reines n'a pas de solution non plus.](figs/3reines.svg)
# Problème des 4-reines
![Le problème des 4 reines a une solution.](figs/4reines.svg)
# Problème des 4-reines, symétrie
![Le problème des 4 reines a une autre solution (symétrie
horizontale).](figs/4reines_sym.svg)
```
# Problème des 5 reines
## Empiler? (le code ensemble)
## Exercice: Trouver une solution au problème des 5 reines
. . .
* Faire une capture d'écran / une photo de votre solution et la poster sur
matrix.
```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
......@@ -96,226 +81,384 @@ void stack_push(stack *s, int val) {
```
## Jeter un oeil? (le code ensemble)
# Quelques observations sur le problème
* Une reine par colonne au plus.
* On place les reines sur des colonnes successives.
* On a pas besoin de "regarder en arrière" (on place "devant" uniquement).
* Trois étapes:
* On place une reine dans une case libre.
* On met à jour le tableau.
* Quand on a plus de cases libres on "revient dans le temps" ou c'est qu'on
a réussi.
# Le code du problème des 8 reines (1/5)
## Quelle structure de données?
. . .
Une matrice de booléens fera l'affaire:
```C
void stack_peek(stack s, int *val) {
*val = s->data;
}
bool board[n][n];
```
# La liste chaînée et pile (5/N)
## Dépiler? (faire un dessin)
## Quelles fonctionnalités?
. . .
```C
// Pour chaque ligne placer la reine sur toutes les colonnes
// et compter les solutions
void nbr_solutions(board, column, counter);
// Copier un tableau dans un autre
void copy(board_in, board_out);
// Placer la reine à li, co et rendre inaccessible devant
void placer_devant(board, li, co);
```
# Le code du problème des 8 reines (2/5)
## Le calcul du nombre de solutions
```C
// Calcule le nombre de solutions au problème des <n> reines
rien nbr_solutions(board, column, count)
pour chaque ligne
si la case libre
si column < n - 1
copier board dans un "new" board,
y poser une reine
et mettre à jour ce "new" board
nbr_solutions(new_board, column+1, count)
sinon
on a posé la n-ème et on a gagné
count += 1
```
# Le code du problème des 8 reines (3/5)
## Le calcul du nombre de solutions
```C
// Placer une reine et mettre à jour
rien placer_devant(board, ligne, colonne)
board est occupé à ligne/colonne
toutes les cases des colonnes
suivantes sont mises à jour
```
## Dépiler? (le code ensemble)
# Le code du problème des 8 reines (4/5)
## Compris? Alors écrivez le code et postez le!
. . .
## Le nombre de solutions
\footnotesize
```C
void stack_pop(stack *s, int *val) {
stack_peek(*s, val);
element *tmp = *s;
*s = (*s)->next;
free(tmp);
return val;
// Calcule le nombre de solutions au problème des <n> reines
void nb_sol(int n, bool board[n][n], int co, int *ptr_cpt) {
for (int li = 0; li < n; li++) {
if (board[li][co]) {
if (co < n-1) {
bool new_board[n][n]; // alloué à chaque nouvelle tentative
copy(n, board, new_board);
prises_devant(n, new_board, li, co);
nb_sol(n, new_board, co+1, ptr_cpt);
} else {
*ptr_cpt = (*ptr_cpt)+1;
}
}
}
}
```
# La liste chaînée et pile (6/N)
## Détruire? (faire un dessin)
# Le code du problème des 8 reines (5/5)
. . .
\footnotesize
## Placer devant
```C
// Retourne une copie du tableau <board> complété avec les positions
// prises sur la droite droite par une reine placée en <board(li,co)>
void placer_devant(int n, bool board[n][n], int li, int co) {
board[li][co] = false; // position de la reine
for (int j = 1; j < n-co; j++) {
// horizontale et diagonales à droite de la reine
if (j <= li) {
board[li-j][co+j] = false;
}
board[li][co+j] = false;
if (li+j < n) {
board[li+j][co+j] = false;
}
}
}
```
# Les piles
\Huge Les piles
# Les piles (1/5)
## Qu'est-ce donc?
* Structure de données abstraite...
. . .
```
* de type `LIFO` (*Last in first out*).
## Détruire? (le code ensemble)
![Une pile où on ajoute A, puis B avant de les retirer. Source:
[Wikipedia](https://upload.wikimedia.org/wikipedia/commons/e/e1/Stack_(data_structure)_LIFO.svg)](figs/Stack.svg){width=70%}
. . .
## Des exemples de la vraie vie
```C
void stack_destroy(stack *s) {
while (!stack_is_empty(*s)) {
int val = stack_pop(s);
}
}
```
. . .
# La file d'attente (1/N)
* Pile d'assiettes, de livres, ...
* Adresses visitées par un navigateur web.
* Les calculatrices du passé (en polonaise inverse).
* Les boutons *undo* de vos éditeurs de texte (aka *u* dans vim).
* 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, ...
# Les piles (2/5)
## 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.
1. Empiler (push): ajouter un élément sur la pile.
2. Dépiler (pop): retirer l'élément du sommet de la pile et le retourner.
3. Pile vide? (is_empty?).
. . .
4. Jeter un œil (peek): retourner l'élément du sommet de la pile (sans le dépiler).
5. Nombre d'éléments (length).
## Comment faire les 4, 5 à partir de 1 à 3?
. . .
4. Dépiler l'élément, le copier, puis l'empiler à nouveau.
5. Dépiler jusqu'à ce que la pile soit vide, puis empiler à nouveau.
. . .
* 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.
## Existe en deux goûts
* Pile avec ou sans limite de capacité (à concurrence de la taille de la
mémoire).
# La file d'attente (2/N)
# Les piles (3/5)
## Implémentation possible
## Implémentation
* 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).
* Jusqu'ici on n'a pas du tout parlé d'implémentation (d'où le nom de structure
abstraite).
* Pas de choix unique d'implémentation.
## Quelle structure de données allons nous utiliser?
. . .
![Illustration d'une file
d'attente.](figs/fig_queue_representation.png)
Et oui vous avez deviné: un tableau!
## Structure de données en C?
## La structure: de quoi avons-nous besoin (pile de taille fixe)?
. . .
```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;
#define MAX_CAPACITY 500
typedef struct _stack {
int data[MAX_CAPACITY]; // les données
int top; // indice du sommet
} stack;
```
# Fonctionnalités d'une file d'attente (gitlab)
# Les piles (4/5)
## Creation et consultations
## Initialisation
. . .
```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
void stack_init(stack *s) {
s->top = -1;
}
```
## Manipulations et destruction
## Est vide?
. . .
```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
bool stack_is_empty(stack s) {
return s.top == -1;
}
```
# Enfilage
## Empiler (ajouter un élément au sommet)
. . .
```C
void stack_push(stack *s, int val) {
s->top += 1;
s->data[s->top] = val;
}
```
## Deux cas différents:
# Les piles (5/5)
1. La file est vide (faire un dessin):
## Dépiler (enlever l'élément du sommet)
. . .
![Insertion dans une file d'attente
vide.](./figs/fig_empty_queue_insert.png){width=40%}
```C
int stack_pop(stack *s) {
s->top -= 1;
return s->data[s->top+1];
}
```
2. La file n'est pas vide (faire un dessin):
## Jeter un oeil (regarder le sommet)
. . .
![Insertion dans une file d'attente
non-vide.](./figs/fig_non_empty_queue_insert.png){width=70%}
```C
int stack_peek(stack s) {
return s.data[s.top];
}
```
## Quelle est la complexité de ces opérations?
# Enfilage
. . .
## Live (implémentation)
## Voyez-vous des problèmes potentiels avec cette implémentation?
. . .
* Empiler avec une pile pleine.
* Dépiler avec une pile vide.
* Jeter un oeil au sommet d'une pile vide.
# Gestion d'erreur, level 0
* Il y a plusieurs façon de traiter les erreur:
* Ne rien faire (laisser la responsabilité à l'utilisateur).
* Faire paniquer le programme (il plante plus ou moins violemment).
* Utiliser des codes d'erreurs.
## La panique
* En C, on a les `assert()` pour faire paniquer un programme.
# Les assertions
\Huge Les assertions
# Assertions (1/3)
```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;
#include <assert.h>
void assert(int expression);
```
## Qu'est-ce donc?
- Macro permettant de tester une condition lors de l'exécution d'un programme:
- Si `expression == 0`{.C} (condition fausse), `assert()`{.C} affiche un message d'erreur sur `stderr`{.C} et termine l'exécution du programme.
- Sinon l'exécution se poursuit normalement.
- Peuvent être désactivés à la compilation avec `-DNDEBUG` (équivalent à `#define NDEBUG`)
## À quoi ça sert?
- Permet de réaliser des tests unitaires.
- Permet de tester des conditions catastrophiques d'un programme.
- **Ne permet pas** de gérer les erreurs.
# Assertions (2/3)
<!-- \footnotesize -->
## Exemple
```C
#include <assert.h>
void stack_push(stack *s, int val) {
assert(s->top < MAX_CAPACITY-1);
s->top += 1;
s->data[s->top] = val;
}
int stack_pop(stack *s) {
assert(s->top >= 0);
s->top -= 1;
return s->data[s->top+1];
}
int stack_peek(stack *s) {
assert(s->top >= 0);
return s->data[s->top];
}
```
# Défilage
# Assertions (3/3)
## Cas typiques d'utilisation
## Trois cas différents
- Vérification de la validité des pointeurs (typiquement `!= NULL`{.C}).
- Vérification du domaine des indices (dépassement de tableau).
1. La file a plus d'un élément (faire un dessin):
## Bug vs. erreur de *runtime*
- Les assertions sont là pour détecter les bugs (erreurs d'implémentation).
- Les assertions ne sont pas là pour gérer les problèmes externes au programme (allocation mémoire qui échoue, mauvais paramètre d'entrée passé par l'utilisateur, ...).
. . .
![Extraction d'une file d'attente](./figs/fig_queue_extract.png){width=80%}
- Mais peuvent être pratiques quand même pour ça...
- Typiquement désactivées dans le code de production.
2. La file un seul élément (faire un dessin):
. . .
# La pile dynamique
## Comment modifier le code précédent pour avoir une taille dynamique?
![Extraction d'une file d'attente de longueur 1.](./figs/fig_queue_extract_one.svg){width=25%}
. . .
```C
// alloue une zone mémoire de size octets
void *malloc(size_t size);
// change la taille allouée à size octets (contiguïté garantie)
void *realloc(void *ptr, size_t size);
```
3. La file est vide (problème)
. . .
# Défilage
**Attention:** `malloc` sert à allouer un espace mémoire (**pas** de notion de tableau).
## Live (implémentation)
## Et maintenant?
. . .
```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;
}
void stack_create(stack *s); // crée une pile avec une taille par défaut
// vérifie si la pile est pleine et réalloue si besoin
void stack_push(stack *s, int val);
// vérifie si la pile est vide/trop grande
// et réalloue si besoin
void stack_pop(stack *s, int *ret);
```
. . .
## Problème avec cette implémentation?
## Faisons s'implémentation ensemble
slides/cours_11.md
View file @ febfc3f8
This diff is collapsed.
slides/cours_12.md
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
title: "File d'attente, liste triée, liste doublement chaînée"
date: "2024-12-16"
---
# La file d'attente
\Huge La file d'attente
# La file d'attente (1/2)
* 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 file vide.
* Détruire une file.
# La file d'attente (2/2)
\footnotesize
## Implémentation possible
* La structure de file, contient un pointeur vers la tête et un autre vers le début de la file.
* Entre les deux, les éléments sont stockés dans une liste chaînée.
![Illustration d'une file d'attente.](figs/fig_queue_representation.png){width=80%}
## Structure de données en C?
. . .
```C
typedef 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
## Création 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.tail->data
int queue_head(queue fa); // return fa.head->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) {
element* 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 est la 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` serait un indice du tableau;
* `capacity` serait 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 est les complexités de
* Initialisation?
. . .
```C
```
* Est vide?
. . .
```C
```
* Enfiler?
. . .
```C
```
* Défiler?
. . .
```C
```
# 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;
}
}
```
# Listes triées
\Huge Les listes triées
# Les listes triées
Une liste chaînée triée est:
......@@ -53,8 +413,9 @@ Une liste chaînée triée est:
# Les listes triées
## Quelle structure de données dans notre cas?
\footnotesize
## Quelle structure de données dans notre cas?
Une liste chaînée bien sûr (oui c'est pour vous entraîner)!
......@@ -72,14 +433,14 @@ typedef element* sorted_list; // la liste
// 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
bool sorted_list_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
# L'insertion (1/3)
## Trois cas
......@@ -102,7 +463,7 @@ sorted_list sorted_list_push(sorted_list list, int val) {
}
```
# L'insertion
# L'insertion (2/3)
2. L'insertion se fait en première position.
......@@ -125,14 +486,13 @@ sorted_list sorted_list_push(sorted_list list, int val) {
}
```
# L'insertion
# L'insertion (3/3)
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%}
![Insertion sur une autre position, list->data < val.](figs/sorted_list_insert_any.svg){width=70%}
. . .
......@@ -152,8 +512,7 @@ sorted_list sorted_list_push(sorted_list list, int val) {
}
```
# L'extraction
# L'extraction (1/3)
## Trois cas
......@@ -165,7 +524,7 @@ sorted_list sorted_list_push(sorted_list list, int val) {
. . .
\footnotesize
\scriptsize
```C
sorted_list sorted_list_extract(sorted_list list, int val) {
......@@ -182,15 +541,13 @@ sorted_list sorted_list_extract(sorted_list list, int val) {
}
```
# L'extraction
# L'extraction (2/3)
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%}
![Extraction d'un élément qui est le premier.](figs/sorted_list_extract_first.svg){width=70%}
. . .
......@@ -203,7 +560,8 @@ sorted_list sorted_list_extract(sorted_list list, int val) {
prec = crt;
crt = crt->next;
}
if (NULL != crt && crt->data == val && prec == crt) { // glue things together
// glue things together
if (NULL != crt && crt->data == val && prec == crt) {
list = list->next;
free(crt);
}
......@@ -211,7 +569,7 @@ sorted_list sorted_list_extract(sorted_list list, int val) {
}
```
# L'extraction
# L'extraction (3/3)
3. L'élément à extraire n'est **pas** dans la liste.
* La liste est vide.
......@@ -256,7 +614,9 @@ element* sorted_list_search(sorted_list list, int 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) {
} else if (NULL != pos && NULL != pos->next
&& val == pos->next->data)
{
return pos->next; // non-first element contains val
} else {
return NULL; // well... val's not here
......@@ -290,7 +650,7 @@ element* sorted_list_position(sorted_list list, int val) {
if (sorted_list_is_empty(list) || val <= list->data) {
pos = NULL;
} else {
while (NULL != pos->next && val > pos->next>data) {
while (NULL != pos->next && val > pos->next->data) {
pos = pos->next;
}
}
......@@ -324,14 +684,13 @@ $$
\mathcal{O}(N).
$$
# Liste doublement chaînée
## Application navigateur ou éditeur de texte
## 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?
* Comment implémenter les fonctions `back` et `forward` d'un navigateur?
* Comment implémenter les fonctions `undo` et `redo` d'un éditeur de texte?
. . .
......@@ -351,6 +710,10 @@ Pas possible.
# Liste doublement chaînée
\Huge Liste doublement chaînée
# Liste doublement chaînée
## Exercices
* Partir du dessin suivant et par **groupe de 5**
......@@ -400,7 +763,7 @@ dll dll_prev(dll list);
4. Écrire les fonctionnalités d'insertion
```C
// insertion de data dans l'élément *après* pos
// 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);
......@@ -409,12 +772,11 @@ 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é
// 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)
void dll_destroy(dll *list);
```
slides/cours_13.md
View file @ febfc3f8
This diff is collapsed.
slides/cours_14.md
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
...
date: "2025-02-21"
---
# Exercice 3
# Les tables de hachage
* 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.
$$
\Huge Les tables de hachage
# Préambule
# Tableau vs Table
\small
## Tableau
* On considère pas le cas du chaînage en cas de collisions.
* L'insertion est construite avec une forme du type
* Chaque élément (ou valeur) est lié à un indice (la case du tableau).
```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;
annuaire tab[2] = {
"+41 22 123 45 67", "+41 22 234 56 78", ...
};
tab[1] == "+41 22 123 45 67";
```
\normalsize
* Gestion de l'état d'une case *explicite*
## Table
* Chaque élément (ou valeur) est lié à une clé.
```C
typedef enum {EMPTY, OCCUPIED, DELETED} state;
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";
```
# L'insertion
# 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*).
## Pseudocode?
## 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
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;
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.
changer l'état de la case "index" à "occupé";
changer la valeur de la case "index" à "value";
# 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;
}
```
# La suppression
. . .
## Inconvénient?
## Pseudocode?
# 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
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
bool binary_get1(int n, key_value_t table[n], key_t key, value_t *value) {
int top = n - 1, bottom = 0;
while (top > bottom) {
int middle = (top + bottom) / 2;
if (key > table[middle].key) {
bottom = middle+1;
} else {
top = middle;
}
}
if (key == table[top].key) {
*value = table[top].value;
return true;
} else {
return false;
}
}
```
# La recherche
# Consultation dichotomique (`binary_get`)
## Pseudocode?
\footnotesize
. . .
## Autre implémentation
```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
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;
}
```
# Écrivons le code!
## Quelle est la différence avec le code précédent?
# Transformation de clé (hashing)
\footnotesize
## 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
* 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.
```
key1 != key2, h(key1) == h(key2)
```
## Traitement (une idée?)
. . .
## Structures de données
* 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
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;
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;
```
# Écrivons le code!
## 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;
```
## Fonctions auxiliaires
## 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
static int hash(key_t key);
static int rehash(int index, key_t key);
static int find_index(hm h, key_t key);
srand(h(key));
while {
random_number = rand();
}
```
## Signature de l'API
# 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
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);
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.
```
# Live code session!
# 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
```
0. Offered to you by ProtonVPN[^1]!
```
# 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)
. . .
1. Like the video.
2. Subscribe to the channel.
3. Use our one time voucher for ProtonVPN: `PAULISAWESOME`.
4. Consider donating on our patreon.
![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.
[^1]: The fastest way to connect to BBB!
# 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/cours_15.md
View file @ febfc3f8
This diff is collapsed.
slides/cours_16.md 0 → 100644
View file @ febfc3f8
This diff is collapsed.
slides/cours_17.md 0 → 100644
View file @ febfc3f8
This diff is collapsed.
slides/cours_18.md 0 → 100644
View file @ febfc3f8
This diff is collapsed.
slides/cours_19.md 0 → 100644
View file @ febfc3f8
This diff is collapsed.
slides/cours_2.md
View file @ febfc3f8
This diff is collapsed.
slides/cours_20.md 0 → 100644
View file @ febfc3f8
This diff is collapsed.