Skip to content
Snippets Groups Projects
Commit 07608bcb authored by viktor.velitchk's avatar viktor.velitchk
Browse files

Upload New File

parents
No related branches found
No related tags found
No related merge requests found
Show whitespace changes
Inline Side-by-side
Showing
with 327 additions and 0 deletions
sort.ipynb 0 → 100644
+ 327
− 0
View file @ 07608bcb
%% Cell type:markdown id:4932c4cb8c3d602c tags:
# Radix sort (Tri par base)
N'utilise pas la notion de comparaison, mais celle de classements successif dans des catégories (alvéoles)
- Tri de nombre entiers dans un tableau.
- On considère que des nombres >= 0 (sans perte de généralité)
- On considère ensuite la représentation binaire de ces nombres
1. On considère le bit le moins significatif.
2. On parcourt une 1ʳᵉ fois le tableau et on place à la suite dans un 2ᵉ tableau les éléments dont le bit est 0;
puis on répète l'opération 2 pour les éléments dont le bit est 1.
3. On répète l'étape 2 en regardant le bit suivant et en permutant le rôle des deux tableaux.
On utilise donc deux tableaux pour réaliser ce tri. À noter qu'à chaque étape, l'ordre des éléments dont le bit est à 0
(réspectivement à 1) reste identique dans le 2ᵉ tableau par rapport au 1er tableau.
%% Cell type:code id:8fbaa3cc2dd052c5 tags:
``` python
import math
def offset_arr(arr: list, offset: int):
for i, _ in enumerate(arr):
arr[i] += offset
def bit_is_one_at(v: int, n: int) -> bool:
return v >> n & 1 == 1
def alveole_0(arr1: list[int], arr2: list[int], position: int):
cnt = 0
for arr_element in arr1:
if not bit_is_one_at(arr_element, position):
arr2[cnt] = arr_element
cnt += 1
def alveole_1(arr1: list[int], arr2: list[int], position: int):
cnt = len(arr1) - 1
for arr_element in reversed(arr1):
if bit_is_one_at(arr_element, position):
arr2[cnt] = arr_element
cnt -= 1
def radix_sort(tab: list[int]) -> list[int]:
min_value = min(tab)
max_bit_count = len(bin(max(a))[2:])
offset_arr(tab, -min_value)
b = [0] * len(tab)
for i in range(max_bit_count):
alveole_0(tab, b, i)
alveole_1(tab, b, i)
tab = b.copy()
offset_arr(tab, min_value)
return tab
a = [5, -5, 1, 6, 4, -6, 2, -9, 2]
print('Radix Sort')
print(a)
print(radix_sort(a))
print('Is it sorted [Y/N] : ' + ('Y' if sorted(a) == radix_sort(a) else 'N'))
```
%% Output
Radix Sort
[5, -5, 1, 6, 4, -6, 2, -9, 2]
[-9, 1, -6, 2, 2, -5, 4, 5, 6]
Is it sorted [Y/N] : Y
%% Cell type:markdown id:aad7933d9815e1c0 tags:
Merge sort (Tri par fusion)
- Tri par comparaison.
- Idée: deux listes triées, sont fusionnées pour donner une liste triée plus longue.
- Itérativement, on trie d'abord les paires de nombres, puis les groupes de 4 nombres, ensuite 8,
et ainsi jusqu'à obtenir un tableau trié.
%% Cell type:code id:c763f02616f30e9e tags:
``` python
def merge_sort(tab: list[int]) -> list[int]:
if len(tab) > 1:
center = len(tab) // 2
left = merge_sort(tab[:center])
left_size = len(left)
l_index = 0
right = merge_sort(tab[center:])
right_size = len(right)
r_index = 0
for i in range(len(tab)):
if l_index < left_size and r_index < right_size:
if left[l_index] < right[r_index]:
tab[i] = left[l_index]
l_index += 1
else:
tab[i] = right[r_index]
r_index += 1
elif l_index < left_size:
tab[i] = left[l_index]
l_index += 1
else:
tab[i] = right[r_index]
r_index += 1
return tab
else:
return tab
a = [5, -5, 1, 6, 4, -6, 2, -9, 2]
print('Merge sort')
print(a)
print(merge_sort(a))
print('Is it sorted [Y/N] : ' + ('Y' if sorted(a) == merge_sort(a) else 'N'))
```
%% Output
Merge sort
[5, -5, 1, 6, 4, -6, 2, -9, 2]
[-9, -6, -5, 1, 2, 2, 4, 5, 6]
Is it sorted [Y/N] : Y
%% Cell type:markdown id:3b774e6e3d0a248a tags:
# Quicksort (Tri rapide)
1. Choisir le pivot et l'amener à sa place.
- Les éléments à gauche sont plus petits que le pivot.
- Les éléments à droite sont plus grands que le pivot.
2. quicksort(tableau_gauche) en omettant le pivot.
3. quicksort(tableau_droite) en omettant le pivot.
4. S'il y a moins de deux éléments dans le tableau, le tableau est trié.
%% Cell type:code id:f8c901505242e16 tags:
``` python
def quicksort(tab: list[int]) -> list[int]:
pivot = tab[-1]
i = 0
j = len(tab) - 2
while i < j:
if tab[i] < pivot:
i += 1
if i == j:
i += 1
break
if tab[j] > pivot:
j -= 1
tab[i], tab[j] = tab[j], tab[i]
tab[i], tab[-1] = tab[-1], tab[i]
left = tab[:i]
right = tab[i+1:]
if len(left) > 2:
for k, v in enumerate(quicksort(left)):
tab[k] = v
if len(right) > 2:
for k, v in enumerate(quicksort(right)):
tab[k + i + 1] = v
return tab
a = [5, -5, 1, 6, 4, -6, 2, -9, 2]
print('\nQuick sort')
print(a)
print(quicksort(a))
print('Is it sorted [Y/N] : ' + ('Y' if sorted(a) == quicksort(a) else 'N'))
```
%% Output
Quick sort
[5, -5, 1, 6, 4, -6, 2, -9, 2]
[-9, -6, 1, -5, 2, 2, 4, 5, 6]
Is it sorted [Y/N] : Y
%% Cell type:markdown id:fbedcc81da34606a tags:
Bubble sort (Tri à bulle)
- Parcours du tableau et comparaison des éléments consécutifs :
- Si deux éléments consécutifs ne sont pas dans l’ordre, ils sont échangés.
- On recommence depuis le début du tableau jusqu’à avoir plus d’échanges à faire.
%% Cell type:code id:d8619d37c9c0b1c2 tags:
``` python
def bubble_sort(arr: list[int]) -> list[int]:
for i in range(len(arr) - 1, 1, -1):
already_sorted = True
for j in range(i):
if arr[j] > arr[j+1]:
arr[j], arr[j+1] = arr[j+1], arr[j]
already_sorted = False
if already_sorted:
return arr
return arr
a = [5, -5, 1, 6, 4, -6, 2, -9, 2]
print('\nBubble sort')
print(a)
print(bubble_sort(a))
print('Is it sorted [Y/N] : ' + ('Y' if sorted(a) == bubble_sort(a) else 'N'))
```
%% Output
Bubble sort
[5, -5, 1, 6, 4, -6, 2, -9, 2]
[-9, -6, -5, 1, 2, 2, 4, 5, 6]
Is it sorted [Y/N] : Y
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment