python各种排序算法_各种排序算法（Python）,python

class Solution(object):

def sortArray(self, nums):

"""

:type nums: List[int]

:rtype: List[int]

"""

"""

# 直接偷懒

return sorted(nums)

"""

"""

# 冒泡排序

def bubbleSort(nums):

for i in range(len(nums)-1,-1,-1):

for j in range(i):

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

nums[j],nums[j+1] = nums[j+1],nums[j]

return nums

return bubbleSort(nums)

"""

"""

# 插入排序

def insertSort(nums):

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

temp = nums[i]

index = i

while nums[index-1] > temp and index > 0:

nums[index] = nums[index-1]

index-=1

nums[index] = temp

return nums

return insertSort(nums)

"""

"""

# 选择排序

def selectSort(nums):

for i in range(len(nums)-1,1,-1):

max_index = 0

for j in range(i+1):

if nums[j] > nums[max_index]:

max_index = j

nums[max_index],nums[i] = nums[i],nums[max_index]

return nums

return selectSort(nums)

"""

"""

# 归并排序

def mergeSort(nums):

if len(nums)>1:

mid = len(nums)//2

left = nums[:mid]

right = nums[mid:]

mergeSort(left)

mergeSort(right)

i,j,k = 0, 0, 0

while i

if left[i] < right[j]:

nums[k] = left[i]

i+=1

else:

nums[k] = right[j]

j+=1

k+=1

while i < len(left):

nums[k] = left[i]

i+=1

k+=1

while j

nums[k] = right[j]

j+=1

k+=1

return nums

return mergeSort(nums)

"""

"""

# 快速排序

def quictSort(nums):

if len(nums) < 2:

return nums

pivot = nums[len(nums)//2]

left = []

right = []

nums.remove(pivot)

for i in nums:

if i

left.append(i)

else:

right.append(i)

return quictSort(left) + [pivot] + quictSort(right)

return quictSort(nums)

"""

"""

# 希尔排序

def shellSort(nums):

def gapInsertSort(nums,start,gap):

for i in range(start+gap,len(nums),gap):

cur = nums[i]

pos = i

while pos >= gap and nums[pos-gap] > cur:

nums[pos] = nums[pos-gap]

pos = pos - gap

nums[pos] = cur

subNumsCount = len(nums)//2

while subNumsCount > 0:

for i in range(subNumsCount):

gapInsertSort(nums,i,subNumsCount)

subNumsCount//=2

return nums

return shellSort(nums)

"""

"""

# 改善后的冒泡排序

def opt_bubbleSort(nums):

flag = True

passnum = len(nums) - 1

while passnum and flag:

flag = False

for i in range(passnum):

if nums[i] > nums[i+1]:

flag = True

nums[i],nums[i+1] = nums[i+1],nums[i]

passnum-=1

return nums

return opt_bubbleSort(nums)

"""

"""

# 不用借助额外空间的快速排序

def opt_quictSort(nums):

def partition(nums,f,l):

pivot = nums[f]

leftmark = f+1

rightmark = l

done = False

while not done:

while leftmark<=rightmark and nums[leftmark] <= pivot:

leftmark+=1

while rightmark>= pivot and leftmark<=rightmark:

rightmark+=1

if leftmark > rightmark:

done = True

else:

nums[leftmark],nums[rightmark] = nums[rightmark],numr[leftmark]

nums[f],nums[rightmark] = nums[rightmark],nums[f]

return rightmark

def quickSortHelper(nums,f,l):

if f

s = partition(nums,f,l)

quickSortHelper(nums,f,s-1)

quickSortHelper(nums,s+1,l)

return nums

return quickSortHelper(nums,0,len(nums)-1)

"""