python的九大特点_python 九大排序

1，冒泡排序

defbubbleSort(arr):for i in range(1, len(arr)):for j in range(0, len(arr) -i):if arr[j] > arr[j + 1]:

arr[j], arr[j+ 1] = arr[j + 1], arr[j]returnarrif __name__ == '__main__':

arr= [34, 6, 3, 6, 56, 24, 12, 2]

set=bubbleSort(arr)print(set)

2选择排序

def selectedSort(myList):

lenth = len(myList)

for i in range(0, lenth):

smallest = i

for j in range(i + 1, lenth):

if myList[j] < myList[smallest]:

tmp = myList[smallest]

myList[smallest] = myList[j]

myList[j] = tmp

print("smallest:", myList[smallest])

print(myList)

if __name__=='__main__':

myList = [5, 3, 56, 2, 45, 9, 4, 76, 23]

print('selectedSort:')

selectedSort(myList)

3，插入排序

def insertionSort(myList):

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

key = myList[i]

j = i - 1

while j >= 0 and myList[j] > key:

myList[j + 1] = myList[j]

j -= 1

myList[j + 1] = key

return myList

if __name__ == '__main__':

myList = [48, 2, 9, 1, 5, 56, 34, 87]

set=insertionSort(myList)

print(set)

4，快速排序

defquick_sort(array, left, right):if left >=right:returnlow=left

high=right

key=array[low]while low key:

high-= 1array[low]=array[high]

array[high]=keywhile low < high and array[low] <=key:

low+= 1array[high]=array[low]

array[low]=key

quick_sort(array, left, low- 1)

quick_sort(array, low+ 1, right)if __name__ == '__main__':

array= [2, 4, 6, 3, 5, 34, 56, 23, 76, 34, 12, 26, 38]print("before sort:", array)

quick_sort(array, 0, len(array)- 1)print("---------")print(array)

5堆排序

importtime, randomdefshift_down(arr, node, end):

root=node#print (root,2*root+1,end)

while True: #从root开始对最大堆调整

child = 2 * root + 1

if child >end:break

#print("v:", root, arr[root], child, arr[child])

#print(arr)

#找出两个child中较大一个

if child + 1 <= end and arr[child] < arr[child + 1]: #如果左边小于右边

child += 1 #设置右边为大

if arr[root]

tmp =arr[root]

arr[root]=arr[child]

arr[child]=tmp#正在调整的节点设置为root

root =childelse:#无需调整的时候退出

break

#print('----------------')

def heap_sort(arr): #堆分类

#从最后一个有子节点的孩子开始调整最大堆

first =len(arr)for i in range(first, -1, -1): #(起始，结束，跳转)

shift_down(arr, i, len(arr) - 1)#print('----------end------------', arr)

#将最大的放到堆的最后一个，堆-1，继续调整

for end in range(len(arr) - 1, 0, -1):

arr[0], arr[end]=arr[end], arr[0]

shift_down(arr, 0, end- 1)defmain():

array= [23, 4, 6, 53, 15, 36, 47, 89, 23, 8, 35]#print(array)

#start_t = time.time()

heap_sort(array)#end_t = time.time()

#print("cost:", end_t - start_t)

print(array)if __name__ == '__main__':

main()

6，归并排序

defmergeSort(arr):importmathif (len(arr)<2):returnarr

middle=math.floor(len(arr)/2)

left,right=arr[0:middle],arr[middle:]returnmeger(mergeSort(left),mergeSort(right))defmeger(left,right):

result=[]while left andright:if left[0] <=right[0]:

result.append(left.pop(0))else:

result.append(right.pop(0))whileleft:

result.append(left.pop(0))whileright:

result.append(right.pop(0))returnresultif __name__=='__main__':

arr=[3,5,56,23,13,34,59,64,57,53,12]

ret=mergeSort(arr)print(ret)

7，希尔排序

importtime, randomdefshellSort(source):

step= int(len(source) / 2) #分组步长

t_start=time.time()while step >0:for index inrange(0, len(source)):if index + step

current_val= source[index] #先记下来每次大循环走到的第几个循环的值

if current_val > source[index +step]:

source[index], source[index+ step] = source[index +step], source[index]

step= int(step / 2)else: #把基本拍好的数据在进行一次插入排序

for index in range(1, len(source)):

current_val= source[index] #先记下来每次大循环走到的第几个循环的值

position =index#当前元素的左边的紧靠的元素比它大,要把左边的元素一个一个的往右移一位,给当前这个值插入到左边挪一个位置出来

while position > 0 and source[position - 1] >current_val:

source[position]= source[position - 1] #把左边元素向右移一位

position -= 1 #只一次左移只能把当前元素一个位置 ,还得继续左移只到此元素放到排序好的列表的适当位置 为止

source[position] = current_val #已经找到了左边排序好的列表里不小于current_val的元素的位置,把current_val放在这里

t_end= time.time() -t_startprint("cost:", t_end)return(source)if __name__ == '__main__':

source= [54, 56, 2, 6, 8, 34, 76, 23, 11, 45, 32]#source = [random.randrange(10000 + i) for i in range(10000)]

ret =shellSort(source)print(ret)

8，计数排序

defcountingSort(arr,maxValue):

bucketLen=maxValue+1bucket=[0]*bucketLen

sortedIndex=0

arrLen=len(arr)for i inrange(arrLen):if notbucket[arr[i]]:

bucket[arr[i]]=0

bucket[arr[i]]+= 1

for j inrange(bucketLen):while bucket[j]>0:

arr[sortedIndex]=j

sortedIndex+=1bucket[j]-= 1

returnarrif __name__=='__main__':

arr=[45,7,23,7,45,2,7,23,43,49,27,34,25,14,9,3]

ret=countingSort(arr,49)print(ret)

9，基数排序

defradixSort(arr):

i= 0 #初始为个位排序

n = 1 #最小的位数置为1(包含0)

max_num = max(arr) #待排序数组中最大数

while max_num > 10**n:

n += 1

while i

bucket= {} #用字典构建桶

for x in range(10):

bucket.setdefault(x, [])#将每个桶置空

for x in arr: #对每一位进行排序

radix =int((x / (10**i)) % 10) #得到每位的基数

bucket[radix].append(x) #将对应的数组元素加入到相应位基数的桶中

j =0for k in range(10):if len(bucket[k]) != 0: #若桶不为空

for y in bucket[k]: #将该桶中每个元素

arr[j] = y #放回到数组中

j += 1i+= 1

if __name__ == '__main__':

arr= [12,3,45,3543,214,1,4553]

radixSort(arr)print(arr)