1. Bulle Trier
Bubble tri (Anglais: Bubble Sort) est un algorithme de tri simple. Il traverse à plusieurs reprises le nombre de colonnes à trier, une comparaison de deux éléments, s'ils les ont mis dans le mauvais ordre commutation.
"""
冒泡排序
"""
# 第一轮，依次取索引0和1、1和2，...，n-2和n-1两两比较，小的在前大的在后。一轮结束最大的在最后
# 第二轮，依次取索引0和1、1和2，...，n-3和n-2两两比较，小的在前大的在后。二轮结束次大的在倒数第二
# 第n-1轮，取索引0和1比，最小值放最前面
def bubble_sort(li):
n = len(li)
for i in range(0, n-1):
for j in range(0, n-1-i): # 每轮结束，已排序列增加，未排序列减少
if li[j] > li[j+1]:
li[j], li[j+1] = li[j+1], li[j]
li = [55, -2, 43, 91, 22, 1, 44, 90, 34]
bubble_sort(li)
print(li)
complexité du temps
- complexité temporelle optimale: O (n) (représentant le temps de parcours qu'aucun des éléments peuvent être échangés, les extrémités de tri).
- La pire complexité du temps: O (n2)
- Stabilité: Stable
2. Sélectionnez Trier
Trier de sélection (tri de sélection) est un algorithme de tri simple. Il fonctionne comme suit. Tout d'abord, trouver le plus petit élément de séquence non triés (large), la position de départ est mémorisée dans la séquence triée, puis continuer à trouver le minimum (large) élément parmi les éléments restants de non triés et triés dans l'extrémité de la séquence. Et ainsi de suite, jusqu'à ce que tous les éléments sont triés.
"""
选择排序
"""
# 第一轮，假设min_index=0，从索引1开始往后依次取值与索引0处比较，小于索引0，则最小值索引位置设置为当前索引。
# 每轮比较结束，判断min_index是否改变，改变则交换这一轮中实际的min_index和初始的min_index的值。最小值在最前面。
# 第二轮，假设min_index=1，从索引2开始依次往后取值与1处比较，找到次小值。交换次小值与本轮初始min_index=1的位置
# 重复n-1轮。
def select_sort(li):
n = len(li)
for i in range(0, n-1):
min_index = i
for j in range(i+1, n):
if li[j] < li[min_index]:
min_index = j
if min_index != i:
li[min_index], li[i] = li[i], li[min_index]
li1 = [55, -2, 43, 91, 22, 1, 44, 90, 34]
select_sort(li1)
print(li1)
complexité du temps
- La complexité du temps optimal: O (n2)
- La pire complexité du temps: O (n2)
- Stabilité: Instable (croissant considèrent chaque sélection le plus grand cas)
3. Insertion Trier
Le tri par insertion (Anglais: insertion Trier) est un simple algorithme de tri intuitive. Il fonctionne en construisant une séquence ordonnée, pour les données non triés, le balayage dans l'ordre de classement de l'arrière vers l'avant, et de trouver les positions d'insertion correspondantes. Le tri par insertion dans la réalisation, d'arrière en avant dans le processus de balayage, la nécessité d'éléments ordonnés de façon répétée la position de retour se déplacer progressivement, pour fournir un espace pour l'insertion de nouveaux éléments.
"""
插入排序
"""
# 第一轮，假设索引0有序，则取索引1与0比较，大于不交换进行下一轮，小于则交换索引0和1
# 第二轮，假设索引0和1有序，则取索引2依次与索引1和索引0比，小于交换，大于进入下一轮
# 第n-1轮，假设0,1，...，n-2有序，取索引n-1依次与n-2，n-3，...，1，0比较，小于交换，大于结束
def insert_sort(li):
n = len(li)
for i in range(0, n-1): # 循环比较n-1轮
for j in range(i+1, 0, -1):
if li[j] < li[j-1]:
li[j], li[j-1] = li[j-1], li[j]
else:
break
li1 = [55, -2, 43, 91, 22, 1, 44, 90, 34]
insert_sort(li1)
print(li1)
complexité du temps
- complexité temporelle optimale: O (n) (dans l'ordre croissant, en ordre croissant a state)
- La pire complexité du temps: O (n2)
- Stabilité: Stable
4. Tri rapide
Tri rapide (en anglais: Quicksort), également connu sous le nom d'échange division Sort (tri partition d'échange), un voyage en commandant les données à trier en deux parties distinctes, une partie de l'ensemble des données que l'autre partie de toutes les données à plus petite puis les deux parties des données de cette façon ont été rapides sorte, pour trier l'ensemble du processus peut être récursive, afin d'atteindre l'ensemble des données dans une séquence ordonnée.
étapes:
Choisir le nombre de colonnes dans un élément, appelé « référence » (pivoter), les
colonnes de réordonnancement, tous les éléments placés en face de la petite de référence à la valeur de référence, la valeur de référence est plus grand que tous les éléments placés à l'arrière de la référence (le même nombre de il peut être de chaque côté). Après la fin de la partition, la référence se trouve au milieu du nombre de colonnes. On appelle cela l'opération de séparation (partition).
Nombre de sous récursive (recursive Ce) que la valeur de référence du nombre de colonnes et le sous-élément est supérieure à la valeur de référence de la colonne de l' élément.
Le fond du boîtier de la récursivité, la taille est le nombre de colonnes est égal à zéro ou un, qui est, a toujours été triés bien. Bien qu'il ait été récursion, mais cet algorithme se termine toujours, car à chaque itération (itération), qui au moins un élément placé dans sa position finale aller.
"""
快速排序
"""
# 先假设索引0是中间值，mid = li[0],记录下来这个中间值mid
# 创建两个游标left=0，right=列表长度-1
# 取最后面的right与mid进行比较，大于mid，则right向左移，直到小于mid，这个时候，设置li[left]=li[right],
# 此时right停止移动，转而left开始比较。最后一个的元素位置空出来可以复制操作
# 即比较li[left]和mid，如果小于mid，则left向右移动，如果大于mid，则设置li[right]=li[left]
# 此时left停止移动，right开始移动，left位置又空出来允许赋值操作
# 这样一轮比较之后，left和right相遇,left=right，可以li[left]=mid，那么mid左侧都是<mid的值，右侧均>mid
# 接着left_list = li[:mid],右侧列表：right_list = li[mid:]，再对其进行递归快速排序
def quick_sort(alist, start, end):
"""快速排序"""
# 递归的退出条件
if start >= end:
return
# 设定起始元素为要寻找位置的基准元素
mid = alist[start]
# low为序列左边的由左向右移动的游标
low = start
# high为序列右边的由右向左移动的游标
high = end
while low < high:
# 如果low与high未重合，high指向的元素不比基准元素小，则high向左移动
while low < high and alist[high] >= mid:
high -= 1
# 将high指向的元素放到low的位置上
alist[low] = alist[high]
# 如果low与high未重合，low指向的元素比基准元素小，则low向右移动
while low < high and alist[low] < mid:
low += 1
# 将low指向的元素放到high的位置上
alist[high] = alist[low]
# 退出循环后，low与high重合，此时所指位置为基准元素的正确位置
# 将基准元素放到该位置
alist[low] = mid
# 对基准元素左边的子序列进行快速排序
quick_sort(alist, start, low-1)
# 对基准元素右边的子序列进行快速排序
quick_sort(alist, low+1, end)
alist = [54,26,93,17,77,31,44,55,20]
quick_sort(alist,0,len(alist)-1)
print(alist)
complexité du temps
- La complexité du temps optimal: O (nlogn)
- La pire complexité du temps: O (n2)
- Stabilité: Instable
