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

Replace sort.ipynb

parent 07608bcb
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
Showing
with 12 additions and 15 deletions
sort.ipynb
+ 12
− 15
View file @ d56f3b1b
%% Cell type:markdown id:4932c4cb8c3d602c tags: %% Cell type:markdown id:4932c4cb8c3d602c tags:
# Radix sort (Tri par base) # Radix sort (Tri par base)
N'utilise pas la notion de comparaison, mais celle de classements successif dans des catégories (alvéoles) 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. - Tri de nombre entiers dans un tableau.
- On considère que des nombres >= 0 (sans perte de généralité) - On considère que des nombres >= 0 (sans perte de généralité)
- On considère ensuite la représentation binaire de ces nombres - On considère ensuite la représentation binaire de ces nombres
1. On considère le bit le moins significatif. 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; 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. 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. 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 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. (réspectivement à 1) reste identique dans le 2ᵉ tableau par rapport au 1er tableau.
%% Cell type:code id:8fbaa3cc2dd052c5 tags: %% Cell type:code id:8fbaa3cc2dd052c5 tags:
``` python ``` python
import math
def offset_arr(arr: list, offset: int): def offset_arr(arr: list, offset: int):
for i, _ in enumerate(arr): for i, _ in enumerate(arr):
arr[i] += offset arr[i] += offset
def bit_is_one_at(v: int, n: int) -> bool: def bit_is_one_at(v: int, n: int) -> bool:
return v >> n & 1 == 1 return v >> n & 1 == 1
def alveole_0(arr1: list[int], arr2: list[int], position: int): def alveole_0(arr1: list[int], arr2: list[int], position: int):
cnt = 0 cnt = 0
for arr_element in arr1: for arr_element in arr1:
if not bit_is_one_at(arr_element, position): if not bit_is_one_at(arr_element, position):
arr2[cnt] = arr_element arr2[cnt] = arr_element
cnt += 1 cnt += 1
def alveole_1(arr1: list[int], arr2: list[int], position: int): def alveole_1(arr1: list[int], arr2: list[int], position: int):
cnt = len(arr1) - 1 cnt = len(arr1) - 1
for arr_element in reversed(arr1): for arr_element in reversed(arr1):
if bit_is_one_at(arr_element, position): if bit_is_one_at(arr_element, position):
arr2[cnt] = arr_element arr2[cnt] = arr_element
cnt -= 1 cnt -= 1
def radix_sort(tab: list[int]) -> list[int]: def radix_sort(tab: list[int]) -> list[int]:
min_value = min(tab) min_value = min(tab)
max_bit_count = len(bin(max(a))[2:]) max_bit_count = len(bin(max(a))[2:])
offset_arr(tab, -min_value) offset_arr(tab, -min_value)
b = [0] * len(tab) b = [0] * len(tab)
for i in range(max_bit_count): for i in range(max_bit_count):
alveole_0(tab, b, i) alveole_0(tab, b, i)
alveole_1(tab, b, i) alveole_1(tab, b, i)
tab = b.copy() tab = b.copy()
offset_arr(tab, min_value) offset_arr(tab, min_value)
return tab return tab
a = [5, -5, 1, 6, 4, -6, 2, -9, 2] a = [5, -5, 1, 6, 4, -6, 2, -9, 2]
print('Radix Sort') print('Radix Sort')
print(a) print(a)
print(radix_sort(a)) print(radix_sort(a))
print('Is it sorted [Y/N] : ' + ('Y' if sorted(a) == radix_sort(a) else 'N')) print('Is it sorted [Y/N] : ' + ('Y' if sorted(a) == radix_sort(a) else 'N'))
``` ```
%% Output %% Output
Radix Sort Radix Sort
[5, -5, 1, 6, 4, -6, 2, -9, 2] [5, -5, 1, 6, 4, -6, 2, -9, 2]
[-9, 1, -6, 2, 2, -5, 4, 5, 6] [-9, 1, -6, 2, 2, -5, 4, 5, 6]
Is it sorted [Y/N] : Y Is it sorted [Y/N] : Y
%% Cell type:markdown id:aad7933d9815e1c0 tags: %% Cell type:markdown id:aad7933d9815e1c0 tags:
Merge sort (Tri par fusion) Merge sort (Tri par fusion)
- Tri par comparaison. - Tri par comparaison.
- Idée: deux listes triées, sont fusionnées pour donner une liste triée plus longue. - 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, - 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é. et ainsi jusqu'à obtenir un tableau trié.
%% Cell type:code id:c763f02616f30e9e tags: %% Cell type:code id:c763f02616f30e9e tags:
``` python ``` python
def merge_sort(tab: list[int]) -> list[int]: def merge_sort(tab: list[int]) -> list[int]:
if len(tab) > 1: if len(tab) > 1:
center = len(tab) // 2 center = len(tab) // 2
left = merge_sort(tab[:center]) left = merge_sort(tab[:center])
left_size = len(left) left_size = len(left)
l_index = 0 l_index = 0
right = merge_sort(tab[center:]) right = merge_sort(tab[center:])
right_size = len(right) right_size = len(right)
r_index = 0 r_index = 0
for i in range(len(tab)): for i in range(len(tab)):
if l_index < left_size and r_index < right_size: if l_index < left_size and r_index < right_size:
if left[l_index] < right[r_index]: if left[l_index] < right[r_index]:
tab[i] = left[l_index] tab[i] = left[l_index]
l_index += 1 l_index += 1
else: else:
tab[i] = right[r_index] tab[i] = right[r_index]
r_index += 1 r_index += 1
elif l_index < left_size: elif l_index < left_size:
tab[i] = left[l_index] tab[i] = left[l_index]
l_index += 1 l_index += 1
else: else:
tab[i] = right[r_index] tab[i] = right[r_index]
r_index += 1 r_index += 1
return tab return tab
else: else:
return tab return tab
a = [5, -5, 1, 6, 4, -6, 2, -9, 2] a = [5, -5, 1, 6, 4, -6, 2, -9, 2]
print('Merge sort') print('Merge sort')
print(a) print(a)
print(merge_sort(a)) print(merge_sort(a))
print('Is it sorted [Y/N] : ' + ('Y' if sorted(a) == merge_sort(a) else 'N')) print('Is it sorted [Y/N] : ' + ('Y' if sorted(a) == merge_sort(a) else 'N'))
``` ```
%% Output %% Output
Merge sort Merge sort
[5, -5, 1, 6, 4, -6, 2, -9, 2] [5, -5, 1, 6, 4, -6, 2, -9, 2]
[-9, -6, -5, 1, 2, 2, 4, 5, 6] [-9, -6, -5, 1, 2, 2, 4, 5, 6]
Is it sorted [Y/N] : Y Is it sorted [Y/N] : Y
%% Cell type:markdown id:3b774e6e3d0a248a tags: %% Cell type:markdown id:3b774e6e3d0a248a tags:
# Quicksort (Tri rapide) # Quicksort (Tri rapide)
1. Choisir le pivot et l'amener à sa place. 1. Choisir le pivot et l'amener à sa place.
- Les éléments à gauche sont plus petits que le pivot. - Les éléments à gauche sont plus petits que le pivot.
- Les éléments à droite sont plus grands que le pivot. - Les éléments à droite sont plus grands que le pivot.
2. quicksort(tableau_gauche) en omettant le pivot. 2. quicksort(tableau_gauche) en omettant le pivot.
3. quicksort(tableau_droite) 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é. 4. S'il y a moins de deux éléments dans le tableau, le tableau est trié.
%% Cell type:code id:f8c901505242e16 tags: %% Cell type:code id:f8c901505242e16 tags:
``` python ``` python
def quicksort(tab: list[int]) -> list[int]: def quicksort(tab: list[int]) -> list[int]:
pivot = tab[-1] pivot = tab[-1]
i = 0 i = 0
j = len(tab) - 2 j = len(tab) - 2
while i < j: while i < j:
if tab[i] < pivot: if tab[i] < pivot:
i += 1 i += 1
if i == j: if i == j:
i += 1 i += 1
break break
if tab[j] > pivot: if tab[j] > pivot:
j -= 1 j -= 1
tab[i], tab[j] = tab[j], tab[i] tab[i], tab[j] = tab[j], tab[i]
tab[i], tab[-1] = tab[-1], tab[i] tab[i], tab[-1] = tab[-1], tab[i]
left = tab[:i] left = tab[:i]
right = tab[i+1:] right = tab[i+1:]
if len(left) > 2: if len(left) > 2:
for k, v in enumerate(quicksort(left)): for k, v in enumerate(quicksort(left)):
tab[k] = v tab[k] = v
if len(right) > 2: if len(right) > 2:
for k, v in enumerate(quicksort(right)): for k, v in enumerate(quicksort(right)):
tab[k + i + 1] = v tab[k + i + 1] = v
return tab return tab
a = [5, -5, 1, 6, 4, -6, 2, -9, 2] a = [5, -5, 1, 6, 4, -6, 2, -9, 2]
print('\nQuick sort') print('\nQuick sort')
print(a) print(a)
print(quicksort(a)) print(quicksort(a))
print('Is it sorted [Y/N] : ' + ('Y' if sorted(a) == quicksort(a) else 'N')) print('Is it sorted [Y/N] : ' + ('Y' if sorted(a) == quicksort(a) else 'N'))
``` ```
%% Output %% Output
Quick sort Quick sort
[5, -5, 1, 6, 4, -6, 2, -9, 2] [5, -5, 1, 6, 4, -6, 2, -9, 2]
[-9, -6, 1, -5, 2, 2, 4, 5, 6] [-9, -6, 1, -5, 2, 2, 4, 5, 6]
Is it sorted [Y/N] : Y Is it sorted [Y/N] : Y
%% Cell type:markdown id:fbedcc81da34606a tags: %% Cell type:markdown id:fbedcc81da34606a tags:
Bubble sort (Tri à bulle) Bubble sort (Tri à bulle)
- Parcours du tableau et comparaison des éléments consécutifs : - 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. - 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. - On recommence depuis le début du tableau jusqu’à avoir plus d’échanges à faire.
%% Cell type:code id:d8619d37c9c0b1c2 tags: %% Cell type:code id:d8619d37c9c0b1c2 tags:
``` python ``` python
def bubble_sort(arr: list[int]) -> list[int]: def bubble_sort(arr: list[int]) -> list[int]:
for i in range(len(arr) - 1, 1, -1): for i in range(len(arr) - 1, 1, -1):
already_sorted = True already_sorted = True
for j in range(i): for j in range(i):
if arr[j] > arr[j+1]: if arr[j] > arr[j+1]:
arr[j], arr[j+1] = arr[j+1], arr[j] arr[j], arr[j+1] = arr[j+1], arr[j]
already_sorted = False already_sorted = False
if already_sorted: if already_sorted:
return arr return arr
return arr return arr
a = [5, -5, 1, 6, 4, -6, 2, -9, 2] a = [5, -5, 1, 6, 4, -6, 2, -9, 2]
print('\nBubble sort') print('\nBubble sort')
print(a) print(a)
print(bubble_sort(a)) print(bubble_sort(a))
print('Is it sorted [Y/N] : ' + ('Y' if sorted(a) == bubble_sort(a) else 'N')) print('Is it sorted [Y/N] : ' + ('Y' if sorted(a) == bubble_sort(a) else 'N'))
``` ```
%% Output %% Output
Bubble sort Bubble sort
[5, -5, 1, 6, 4, -6, 2, -9, 2] [5, -5, 1, 6, 4, -6, 2, -9, 2]
[-9, -6, -5, 1, 2, 2, 4, 5, 6] [-9, -6, -5, 1, 2, 2, 4, 5, 6]
Is it sorted [Y/N] : Y 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