Update algorithms

Algoritmer/README.md

@@ -20,11 +20,14 @@
 <!-- Pseudokode med forklaring -->
 
 ## Korrekthetsbevis
-<!-- TBA -->
 
 ## Styrker og svakheter sammenlignet med andre
 
 ## Kjøretid og utregning
 <!-- Under ulike omstendigheter -->
 
+Best case | Average case | Worst case | Minne
+---------|----------|---------|---------
+ TODO | TODO | TODO | TODO
+
 ## Python kodeeksempel

Algoritmer/Sortering/binary_search.md

@@ -36,7 +36,7 @@ Binary search krever en sortert input liste.
 
 ## Styrker og svakheter sammenlignet med andre
 
-Binary search er en utrolig god algoritme for store, sorterte lister, i forhold til lineært søk.
+Binary search er en utrolig god algoritme for store, sorterte lister, i forhold til lineært søk (brute force).
 
 Hvis `array` har 10 elementer, trenger vi kun å sjekke 3 elementer for å finne `target` eller konkludere med at `target` ikke eksisterer (33%).
 
@@ -48,7 +48,7 @@ Best case er `target` på midten av lista og algoritmen returnerer umiddelbart.
 
 Best case | Average case | Worst case
 ---------|----------|---------
- $O(1)$ | $O(\log n)$ | $O(\log n)$
+$O(1)$ | $O(\log n)$ | $O(\log n)$
 
 ## Python kodeeksempel
 

Algoritmer/Sortering/bucket_sort.md

@@ -9,7 +9,7 @@
 6. Kjenne kjøretidene under ulike omstendigheter, og forstå utregningen
 -->
 
-Bucket sort antar at input-listen er generert tilfeldig og er uniformt fordelt over et intervall. Bucket sort deler elementene inn i $k$ like store intervaller/bøtter, og så fordeles de $n$ input-tallene i bøttene.
+Bucket sort antar at input-listen er generert tilfeldig og er uniformt fordelt over et intervall. Bucket sort deler elementene inn i $k$ like store intervaller/bøtter, og så fordeles de $n$ input-tallene i bøttene. Deretter sorteres elementene i bøttene med en annen algoritme, som f.eks. insertion sort.
 
 ## Den formelle definisjonen av det generelle problemet
 <!-- Et problem er relasjonen mellom input og output -->
@@ -29,11 +29,16 @@ Bucket sort antar at input-listen er generert tilfeldig og er uniformt fordelt o
 <!-- TBA -->
 
 ## Styrker og svakheter sammenlignet med andre
+<!-- TODO <https://en.wikipedia.org/wiki/Bucket_sort#Comparison_with_other_sorting_algorithms> -->
 
-TBA  
-<https://en.wikipedia.org/wiki/Bucket_sort#Comparison_with_other_sorting_algorithms>
+- In-place: Nei, bucket sort oppretter mange underlister
+- Stabil: Ja dersom den underliggende algoritmen er det.
 
 ## Kjøretid og utregning
 <!-- Under ulike omstendigheter -->
 
+Best case | Average case | Worst case | Minne
+---------|----------|---------|---------
+$\Theta(n)$ | $\Theta(n)$ | $\Theta(n^2)$ | $O(n)$
+
 ## Python kodeeksempel

Algoritmer/Sortering/counting_sort.md

@@ -11,6 +11,8 @@
 
 Counting sort er en effektiv sorteringsalgoritme om det er mange elementer, men få forskjellige elementer.
 
+Anta at du kan kun ha $k$ distinkte elementer. Tell hvor mange instanser det er av hvert element, og gjør tellingen om til indekser. Flytt elementer til en ny liste basert på indeksen du fant.
+
 ## Den formelle definisjonen av det generelle problemet
 <!-- Et problem er relasjonen mellom input og output -->
 
@@ -28,11 +30,17 @@ Counting sort er en effektiv sorteringsalgoritme om det er mange elementer, men
 
 ## Styrker og svakheter sammenlignet med andre
 
+- Ikke sammenligningsbasert
 - **Counting sort** slår **radix sort** hvis antallet elementer $n \gg k$ forskjellige elementer. (_Dette er også det tilfellet hvor algoritmen er mest effektiv._)
 - Sorterer basert på at alle input-elementene $n$ er heltall med en range mellom $0$ og $k$.
+- Ikke in-place da den lager en ny liste midlertidig for å telle antall forekomster av hvert element
 - Stabil: den relative rekkefølgen til elementene i listen opprettholdes under sorteringen
 
 ## Kjøretid og utregning
 <!-- Under ulike omstendigheter -->
 
+Best case | Average case | Worst case | Minne
+---------|----------|---------|---------
+TODO | TODO | TODO | TODO
+
 ## Python kodeeksempel

Algoritmer/Sortering/merge_sort.md

@@ -51,7 +51,7 @@ I utgangspunktet vil merge sort fungere for både partalls- og oddetallslister,
 
 Best case | Average case | Worst case
 ---------|----------|---------
- $O(\log n)$ | $O(\log n)$ | $O(\log n)$
+ $O(n \log n)$ | $O(n \log n)$ | $O(n \log n)$
 
 ## Python kodeeksempel
 

Algoritmer/Sortering/quick_sort.md

@@ -38,9 +38,9 @@ Quick sort er en sammenligningsbasert splitt og hersk algoritme som velger et pi
 
 Kjøretiden avhenger i stor grad av hvilket element som blir valgt som pivot. Den absolutt verste kjøretiden $n^2$ vil være en revers sortert liste hvor det første (høyeste) elementet blir valgt som pivot. Løsningen her er å velge tilfeldig pivot-element hver gang.
 
-Best case | Average case | Worst case
----------|----------|---------
- $O(n\log n)$ | $O(n\log n)$ | $O(n^2)$
+Best case | Average case | Worst case | Minne
+---------|----------|---------|---------
+ $O(n\log n)$ | $O(n\log n)$ | $O(n^2)$ | $O(\lg n)$
 
 ## Python kodeeksempel
 

Algoritmer/Sortering/radix_sort.md

@@ -9,14 +9,16 @@
 6. Kjenne kjøretidene under ulike omstendigheter, og forstå utregningen
 -->
 
+Radix sort antar at input er $n$ elementer med $d$ siffer, der hvert siffer kan ha opp til $k$ forskjellige verdier. Algoritmen ser som regel på det minst signifikante sifferet, sorterer med hensyn på dette sifferet, og gjentar så med det nest minst signifikante sifferet, osv. Sorterer stabilt på hvert siffer. Kan bruke bl.a. counting sort eller insertion sort som underalgoritme. Utnytter at det er et begrenset antall siffer.
+
 ## Den formelle definisjonen av det generelle problemet
 <!-- Et problem er relasjonen mellom input og output -->
 
 ## Tilleggskrav for korrekthet
 <!-- Korrekhet: algoritmer virker, gir det svaret den skal -->
 <!-- Eks: Binary search må ha en sortert liste -->
 
-* Må ha en stabil sub-algoritme for å fungere. Dvs at algoritmen som sorterer underlistene er stabil.
+- Må ha en stabil sub-algoritme for å fungere. Dvs at den underliggende algoritmen som sorterer underlistene må være stabil.
 
 ## Trinn for trinn
 <!-- Pseudokode med forklaring -->
@@ -26,9 +28,17 @@
 
 ## Styrker og svakheter sammenlignet med andre
 
-* **Radix sort** slår **counting sort** hvis antallet elementer $n \ll k$ forskjellige elementer.
+- **Radix sort** slår **counting sort** hvis antallet elementer $n \ll k$ forskjellige elementer.
+- In-place: Nei
+- Stabil: Ja
 
 ## Kjøretid og utregning
 <!-- Under ulike omstendigheter -->
 
+Best case | Average case | Worst case | Minne
+---------|----------|---------|---------
+$\Theta(d(n+k))$ | $\Theta(d(n+k))$ | $\Theta(d(n+k))$ | $O(n+k)$
+
+der $d$ er antallet siffer i maksimum, $n$ er antall elementer og $k$ er antallet unike elementer.
+
 ## Python kodeeksempel