python几种排序_Python实现几种排序算法

Python实现几种排序算法

2018年11月12日 09:39

1.二分查找

import random

def binary_search(li,target):

start = 0

end = len(li) - 1

while end >= start:

mid = (start + end)//2

if li[mid] > target:

end = mid -1

elif li[mid] < target:

start = mid +1

else:

return mid

break

else:

return 'Not found'

li = list(range(10))

print(li)

#random.shuffle(li)

#print(li)

print(binary_search(li,11))

2.冒泡排序

import random

def bubble_sort(li):

for i in range(len(li)-1):

for j in range(len(li)-i-1):

if li[j] > li[j+1]:

li[j], li[j+1] = li[j+1], li[j]

li = list(range(100))

random.shuffle(li)

print(li)

bubble_sort(li)

print(li)

3.选择排序

import random

def choice_sort(li):

for i in range(0,len(li)-1):

min_index = i+1

for j in range(i+1,len(li)):

if li[j] < li[min_index]:

min_index = j

#print(i,min_index,li[i],li[min_index],li)

if li[i] > li[min_index]:

li[i], li[min_index] = li[min_index], li[i]

li = list(range(100))

random.shuffle(li)

print(li)

choice_sort(li)

print(li)

4.插入排序

import random

#改进后现在是插入排序，相比于冒泡排序是少进行赋值的动作

def insert_sort(li):

for i in range(1,len(li)):

temp = li[i]

while i > 0:

if temp < li[i-1]:

li[i] = li[i-1]

i -= 1

else:

break

li[i] = temp

li = list(range(100))

random.shuffle(li)

print(li)

insert_sort(li)

print(li)

5.快速排序

import random

import time

def quick_sort(array, left, right):

if left >= right:

return

low = left

high = right

key = array[low]

while left < right:

while left < right and array[right] > key:

right -= 1

array[left] = array[right]

while left < right and array[left] <= key:

left += 1

array[right] = array[left]

array[right] = key

quick_sort(array, low, left - 1)

quick_sort(array, left + 1, high)

#记住左等于右，右等于左，再把key置回

#还有一种方式就是，左小，右大换外置。

#前一种方式比后一种方式跑得快，因为少做if的判断

li = list(range(100000))

random.shuffle(li)

time_start = time.time()

random.shuffle(li)

quick_sort(li,0,len(li)-1)

time_end = time.time()

print(time_end - time_start)

6.归并排序

import random

import time

def mergeSort(alist):

#这里判断是否大于两个元素

if len(alist)>1:

mid=len(alist)//2

lefthalf=alist[:mid]

righthalf=alist[mid:]

#这里进行递归

print(lefthalf,righthalf)

mergeSort(lefthalf)

mergeSort(righthalf)

i=j=k=0

#这里处理合并

while i

if lefthalf[i]

alist[k]=lefthalf[i]

i+=1

else:

alist[k]=righthalf[j]

j+=1

k=k+1

while i

alist[k]=lefthalf[i]

i+=1

k+=1

while j

alist[k]=righthalf[j]

j+=1

k+=1

alist=[52,312,54,7,3,2,56,34,65,82,91,65]

mergeSort(alist)

print(alist)

7.计数排序

import random

import time

def count_sort(li,min_num,max_num):

temp_list = [0 for i in range(min_num,max_num + 1)]

for num in li:

temp_list[num-min_num] += 1

li.clear()

for key,val in enumerate(temp_list):

for i in range(val):

li.append(min_num+key)

#li = [5,2,4,3,7,2,1,4,6,9,7,5,2,1]

li = [random.randint(1,100) for _ in range(100)]

print(li)

count_sort(li,min(li),max(li))

print(li)

8.桶排序

import random

import time

def bucket_sort(li,min_num,max_num,bucket_num):

"""

桶排序解决了计数排序开辟空间过大的问题

将数列按插入排序的方式插入桶中

"""

bucket_list = [[] for _ in range(bucket_num)]

#计算每个桶的范围

num_range = (max_num - min_num + 2) /bucket_num

print(num_range)

for num in li:

bucket_index = int(num // num_range)

#进行插入桶中

#print(num,bucket_index)

bucket_list[bucket_index].append(num)

i = len(bucket_list[bucket_index]) -2

while i >= 0:

if num < bucket_list[bucket_index][i]:

bucket_list[bucket_index][i+1] = bucket_list[bucket_index][i]

i -= 1

else:

break

bucket_list[bucket_index][i+1] = num

#print(bucket_list)

li.clear()

for l in bucket_list:

li.extend(l)

li = [random.randint(0,100) for _ in range(10000)]

#print(li)

bucket_sort(li,min(li),max(li),100)

print(li)

9.基数排序

import random

import time

def radix_sort(li):

max_num = max(li)

pow = 0

for pow in range(len(str(max_num))+1):

radix_list = [[] for _ in range(10)]

for i in li:

#print(i,i//(10**pow) %10)

radix_list[int(i//(10**pow) %10)].append(i)

li.clear()

for l in radix_list:

li.extend(l)

#li = [11,13,16,18,12,14,19,10,15,3,53,342,2222,25,37,954,1234]

li = [random.randint(0,1000) for _ in range(10000)]

#print(li)

radix_sort(li)

print(li)

10.希尔排序

import random

import time

#k是相隔几个数

def shell_insert_sort(li,k):

for i in range(len(li)):

t = i//k

temp = li[i]

for j in range(1,t+1):

if temp < li[i-j*k]:

li[i-j*k + k] = li[i-j*k]

else:

t = j -1

break

li[i-t*k] = temp

li = list(range(20000))

random.shuffle(li)

k = len(li)//2

#shell_insert_sort(li,1)

while k > 0 :

shell_insert_sort(li,k)

k = k//2

print(li)

作者： ming.zhong

阅读： 1223

评论： 0

点赞

收藏

关注

本文版权归作者和此站共有，欢迎转载，但未经作者同意必须声明引用出处，且在文章页面明显位置给出原文连接。

评论

Nickname

Email

Comment

Submit

Cancel

暂时还没有评论，欢迎评论！