1、バブルソート
基本的な考え方:のみ二つの要素の比較は、アルゴリズムの時間計算量は、
def bub_sort(lists):
n = len(lists)
for i in range(n):
for j in range(n):
if lists[j-1] > lists[j]:
lists[j-1],lists[j] = lists[j],lists[j-1]
return lists
2、挿入ソート
基本的な考え方は:1が既に配列をソートされたデータに挿入され、アルゴリズムの時間計算量は、
def insert_sort(lists):
size = len(lists)
for i in range(1,size):
pivot = lists[i]
j = i-1
while j >= 0:
if lists[j] > pivot:
lists[j+] = list[j]
lists[j] = pivot
j -= 1
return lists
並べ替えを選択します
基本的な考え方:あなたは現在の位置に最小の要素を選択するたび
def select_sort(lists):
n = len(lists)
for i in range(n):
for j in range(i:n):
if lists[i] < lists[j]:
lists[i],lists[j] = list[j],list[i]
return lists
4、ヒルソート
挿入ソート
def shell_sort(lists):
n = len(lists)
dist = n//2
while dist > 0:
for i in range(dist,n):
temp = lists[i]
j = i
while j >= dist and temp < lists[j - dist]:
lists[j] = lists[j - dist]
j -= dist
lists[j] = temp
dist //= 2
return lists
5、マージソート
基本的な考え方:分割ルールの概念は、最初のアレイは小規模の二つの大きなアレイに分割され、二つの小さなアレイがソートされ、次いで組み合わされ置きます。アルゴリズムの時間複雑
def merge_sort(lists):
if len(lists) <=1:
return lists
mid = len(lists)//2
left = merge_sort(lists[:mid])
right = merge_sort(lists[mid:])
return merge(left,right)
def mmerge(left,right):
res = []
i = j = 0
while i < len(left) and j < len(right):
if left[i] <= right[j]:
res.append(left[i])#append用于在列表末尾添加新内容
i +=1
else:
res.append(right[j])
j += 1
res += left[i:]
res += rught[j:]
return res
6、ヒープソート
##堆排序
def heap_sort(lists):
size = len(lists)
build_heap(lists, size)
for i in range(0, size)[::-1]:
lists[0], list[i] = list[i], lists[0]
adjust_heap(lists, 0, i)
return lists
#堆调整
def adjust_heap(lists, i, size):
lchild = 2 * i + 1
rchild = 2 * i + 2
maxi = i
if lchild < size and lists[maxi] < lists[lchild]:
maxi = lchild
if rchild < size and lists[maxi] < lists[rchild]:
maxi = rchild
if maxi !=i:
#在做了堆调整之后,做对调值操作
lists[maxi],lists[i] = lists[i],lists[maxi]
adjust_heap(lists, maxi, size)
#堆构建
def build_heap(lists,size):
for i in range(0, int(size/2))[::-1]:
adjust_heap(lists, i, size)
7、クイックソート
基本的な考え方:分割統治
def quick_sort(lists):
less = []
pivotlist = []
more = []
if len(lists) <= 1:
return lists
else:
pivot = lists[0] #把第一个元素作为key
for i in lists:
if i < pivot:
less.append(i)
elif i > pivot:
more.append(i)
else:
pivotlist.append(i)
less = quick_sort(less)
more = quick_sort(more)
return less + pivotlist + more
def QuickSort(mylist,left,right):
if left < right:
i,j = left,right
base = mylist[i] #base作为基准数
while (i < j):
while (i < j) and (mylist[j] >= base):'''若列表后边的数比基准数大或相等,
则前移一位直到有比基准数小的数出现'''
j = j - 1
mylist[i] = mylist[j]#如找到,则把第j个元素赋值给第i个元素,此时列表中i,j的元素相等
while (i < j) and (mylist[i] <= base):#同样的方式比较前半区
i = i + 1
mylist[j] = mylist[i]
mylist[i] = base
#递归前后半区
QuickSort(mylist, left, i-1)
QuickSort(mylist, j + 1, right)
return mylist
8、カウントシーケンシング
基本的な考え方は:の要素に、チェックがいくつかの要素よりも小さいが、Iと呼ばれ、位置Iに通し番号
def count_sort(a,k):#a为数组,k为max(a)
n = len(a)
b = [0 for i in range(n)] #设置输出序列,并初始化为0
c = [0 for i in range(k+1)] #设置计数序列并初始化为0
for j in a:
c[j] = c[j] + 1
for i in range(1, len(c)):
c[i] = c[i] + c[i-1]
for j in a:
b[c[j] - 1] = j
c[j] = c[j] - 1
return b
9、バケットソート
基本的な考え方:アレイは、等しい長さのいくつかのセクションに分割され、各サブアレイそれぞれソートし、最後にマージ
def bucket_sort(a):
buckets = [0] * ((max(a)-min(a))+1) #初始化桶元素为0
for i in range(len(a)):
buckets[a[i] - min(a)] +=1 #遍历数组a,在桶的相应位置累加值
b = []
for i in range(len(buckets)):
if bucket[i] != 0:
b += [i + min(a)] * buckets[i]
return b
10、基数ソート
基本的な考え方:データは異なるカット桁数に従ってソートされる、各のビット数を比較しました
def radix_sort(list, d = 3): #默认三位数,可以自定义修改
for i in range(d): #d轮排序
s = [[] for k in range(10)] #因为每一位数字都是0-9,所以建10个桶
for j in list:
s[int(j / (10 ** i)) % 10].append(j)
re = [a for b in s for a in b]
return re