❶ 怎么用python编quicksort程序
快速排序的原理：在已知的数列中选择一个数字作为基准，与剩余的数作比较，将比这个基准小的数放在左边，比其大的数放在右边；然后将基准左右两边的数列重复以上步骤，直到基准两边只有一个数字为止；
特点：不稳定，时间复杂度最理想 O(nlogn) 最差时间O(n^2)
算法原理比较简单，易于理解，其实现方法也较为多种，这里我们使用递归调用的思想采用Python实现代码；
[python]view plain
defquickSort(num,l,r):
ifl>=r:#如果只有一个数字时，结束递归
return
flag=l#是L不是1
foriinrange(l+1,r+1):#以第一个数字作为基准，从第二个数开始比较
ifnum[flag]>num[i]:
tmp=num[i]
delnum[i]
num.insert(flag,tmp)
flag+=1
quickSort(num,l,flag-1)#将基准的前后部分分别递归排序
quickSort(num,flag+1,r)
num=[1,-9,5,7,9,3,2,8]
quickSort(num,0,7)
printnum
[-9,1,2,3,5,7,8,9]
❷ python 快速排序实现的具体代码，以及讲解。我是小白还请讲清楚一点，谢谢了。
快速排序：在数组L中选一个数叫支点Pivot，把数组L中所有比支点小的数放在支点的左边；比支点大的数放在支点右边..；然后分别对左、右两个新数组重新各选一个支点，重复之前的排法，直到左、右只剩下一个数不用再分。经过这样的过程后，整个数组L就被从小到大排好了.
qsort()是排序的实现。qsort(数组，起点序号，终点序号)；内容是由partition分好一轮后再分别排左、右子数组。
partition()是选支点，并分配数给左右和区分左右的过程。
❸ python怎么快速排序与查找
算法体现的是一个思想，就像这里体现的是一个"分而治之"的思想，只要思想不山寨，一些小细节其实不要太在意。学算法嘛，就学个处理问题的思想。不过真正的快排算法不是这样的，真正最优的快排要求随机选择主元加原址排序。我这里两样都没做到。但是我还是认为他是个快排算法，因为他的思想就是快排的思想。
很多时候研究算法去争论代码量的多少真的没有这个必要。
❹ Python实现的快速排序算法详解
Python实现的快速排序算法详解
本文实例讲述了Python实现的快速排序算法。分享给大家供大家参考，具体如下：
快速排序基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
如序列[6，8，1，4，3，9]，选择6作为基准数。从右向左扫描，寻找比基准数小的数字为3，交换6和3的位置，[3，8，1，4，6，9]，接着从左向右扫描，寻找比基准数大的数字为8，交换6和8的位置，[3，6，1，4，8，9]。重复上述过程，直到基准数左边的数字都比其小，右边的数字都比其大。然后分别对基准数左边和右边的序列递归进行上述方法。
实现代码如下：
def parttion(v, left, right):
key = v[left]
low = left
high = right
while low < high:
while (low < high) and (v[high] >= key):
high -= 1
v[low] = v[high]
while (low < high) and (v[low] <= key):
low += 1
v[high] = v[low]
v[low] = key
return low
def quicksort(v, left, right):
if left < right:
p = parttion(v, left, right)
quicksort(v, left, p-1)
quicksort(v, p+1, right)
return v
s = [6, 8, 1, 4, 3, 9, 5, 4, 11, 2, 2, 15, 6]
print("before sort:",s)
s1 = quicksort(s, left = 0, right = len(s) - 1)
print("after sort:",s1)
运行结果：
before sort: [6, 8, 1, 4, 3, 9, 5, 4, 11, 2, 2, 15, 6]
after sort: [1, 2, 2, 3, 4, 4, 5, 6, 6, 8, 9, 11, 15]
❺ 求助帮忙看一下用python实现快速排序的代码为什么一直无限循环了应该怎么修改呢
非常简单，就把第一个if left > right 改成 left >= right就可以了。。
当left = right的时候也应该是退出的条件，你没有加上所以就陷入了while != j这个循环里面了。。
在这个里面 left = right =j,而i=left+1=j+1，所以i>j,而你的判断条件只有i<j的，所以两个while和一个if都不满足就一直死循环了。。
❻ 快速排序python实现
def quick_sort(nums: list, left: int, right: int) -> None:
if left < right:
i = left
j = right
# 取第一个元素为枢轴量
pivot = nums[left]
while i != j:
# 交替扫描和交换
# 从右往左找到第一个比枢轴量小的元素，交换位置
while j > i and nums[j] > pivot:
j -= 1
if j > i:
# 如果找到了，进行元素交换
nums[i] = nums[j]
i += 1
# 从左往右找到第一个比枢轴量大的元素，交换位置
while i < j and nums[i] < pivot:
i += 1
if i < j:
nums[j] = nums[i]
j -= 1
# 至此完成一趟快速排序，枢轴量的位置已经确定好了，就在i位置上（i和j)值相等
nums[i] = pivot
# 以i为枢轴进行子序列元素交换
quick_sort(nums, left, i-1)
quick_sort(nums, i+1, right)
# 测试代码
import random
data = [random.randint(-100, 100) for _ in range(10)]
quick_sort(data, 0, len(data) - 1)
print(data)
❼ Python实现的几个常用排序算法实例
#encoding=utf-8
importrandom
fromimport
defdirectInsertSort(seq):
"""直接插入排序"""
size=len(seq)
foriinrange(1,size):
tmp,j=seq[i],i
whilej>0andtmp<seq[j-1]:
seq[j],j=seq[j-1],j-1
seq[j]=tmp
returnseq
defdirectSelectSort(seq):
"""直接选择排序"""
size=len(seq)
foriinrange(0,size-1):
k=i;j=i+1
whilej<size:
ifseq[j]<seq[k]:
k=j
j+=1
seq[i],seq[k]=seq[k],seq[i]
returnseq
defbubbleSort(seq):
"""冒泡排序"""
size=len(seq)
foriinrange(1,size):
forjinrange(0,size-i):
ifseq[j+1]<seq[j]:
seq[j+1],seq[j]=seq[j],seq[j+1]
returnseq
def_divide(seq,low,high):
"""快速排序划分函数"""
tmp=seq[low]
whilelow!=high:
whilelow<highandseq[high]>=tmp:high-=1
iflow<high:
seq[low]=seq[high]
low+=1
whilelow<highandseq[low]<=tmp:low+=1
iflow<high:
seq[high]=seq[low]
high-=1
seq[low]=tmp
returnlow
def_quickSort(seq,low,high):
"""快速排序辅助函数"""
iflow>=high:return
mid=_divide(seq,low,high)
_quickSort(seq,low,mid-1)
_quickSort(seq,mid+1,high)
defquickSort(seq):
"""快速排序包裹函数"""
size=len(seq)
_quickSort(seq,0,size-1)
returnseq
defmerge(seq,left,mid,right):
tmp=[]
i,j=left,mid
whilei<midandj<=right:
ifseq[i]<seq[j]:
tmp.append(seq[i])
i+=1
else:
tmp.append(seq[j])
j+=1
ifi<mid:tmp.extend(seq[i:])
ifj<=right:tmp.extend(seq[j:])
seq[left:right+1]=tmp[0:right-left+1]
def_mergeSort(seq,left,right):
ifleft==right:
return
else:
mid=(left+right)/2
_mergeSort(seq,left,mid)
_mergeSort(seq,mid+1,right)
merge(seq,left,mid+1,right)
#二路并归排序
defmergeSort(seq):
size=len(seq)
_mergeSort(seq,0,size-1)
returnseq
if__name__=='__main__':
s=[random.randint(0,100)foriinrange(0,20)]
prints
print" "
printdirectSelectSort((s))
printdirectInsertSort((s))
printbubbleSort((s))
printquickSort((s))
printmergeSort((s))
❽ 求一个简单的Python给数字排序代码
简单排序的话，直接使用 list.sort() 就可以了，直接在原列表上进行排序。
非要写成函数的形式的话，代码如下
defABC(nums_l):
nums_l.sort()
returnnums_l
l=[1,2,5,3,4]
#其实，使用l.sort()之后，就对l进行了排序，然后输出l就可以了
printl
printABC(l)
这样，输出为
>>>================================RESTART================================
>>>
[1,2,5,3,4]
[1,2,3,4,5]
>>>
这么基础的东西，不会的话，自己看书去。
defABC(nums_l):
returnsorted(nums_l)
defmain():
nums_l=[]
whileTrue:
try:
n=int(raw_input('inputnum:>').strip())
nums_l.append(n)
except:
break
print'',ABC(nums_l)
if__name__=='__main__':
main()
❾ 用python写了一个快速排序算法，总是报错，求问哪里出错了
defquick_sort(lst,start_index,end_index):
ifstart_index>end_index:
return
tmp=lst[start_index]
i,j=start_index,end_index
whilei!=j:
while(lst[j]>=tmpandi<j):
j=j-1
while(lst[i]<=tmpandi<j):
i=i+1
ifi<j:
lst[i],lst[j]=lst[j],lst[i]
lst[start_index]=lst[i]
lst[i]=tmp
quick_sort(lst,start_index,i-1)
quick_sort(lst,i+1,end_index)
y=[33,12,45,32,6,78,109,2,1]
quick_sort(y,0,len(y)-1)
printy
❿ 求python中，自定义的复杂数据结构，快速排序的方法
应该是你sorted的使用方式不对吧，它可以对name.key这样的形式进行排序的。
classm:
def__init__(self,name,id):
self.name=name
self.id=id
@property
defkey(self):
returnself.name
deflen(self):
returnlen(self.name)
def__str__(self):
return'{{'name':'{0}','id':{1}}}'
.format(self.name,self.id)
__repr__=__str__
s=[m('zzzz',1),m('aaa',4)]
l=[('source',s),
]
#直接属性排序
l.append(('byname',sorted(s,key=lambdax:x.name)))
l.append(('byid',sorted(s,key=lambdax:x.id)))
#属性函数排序
l.append(('bykey',sorted(s,key=lambdax:x.key)))
#函数排序
l.append(('bylen()',sorted(s,key=lambdax:x.len())))
foreinl:
print(e[0])
print(e[1])
这是输出的结果：
source
[{'name':'zzzz','id':1},{'name':'aaa','id':4}]
byname
[{'name':'aaa','id':4},{'name':'zzzz','id':1}]
byid
[{'name':'zzzz','id':1},{'name':'aaa','id':4}]
bykey
[{'name':'aaa','id':4},{'name':'zzzz','id':1}]
bylen()
[{'name':'aaa','id':4},{'name':'zzzz','id':1}]
上述四种用法都是没问题的，至于name[key]的形式同样是OK的。
sorted的参数key，它是一个函数,简单的话可以直接用lambda，复杂点的可以定义成有一个参数的函数，比如：
defsorted_other(item):
ifhasattr(item,'name'):
returnitem.name
else:
returnNone
l.append(('byotherfunc',sorted(s,key=sorted_other)))