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 삽입 정렬
기본적인 아이디어는 하나 이미 배열을 정렬 된 데이터에 삽입, 알고리즘의 시간 복잡도는
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, 계산 순서
기본적인 아이디어는 : (A)의 요소에, 검사는 여러 요소 미만 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