python快速排序

A. python算法有哪些

Python算法的特征

1. 有穷性：算法的有穷性指算法必须能在执行有限个步骤之后终止;

2. 确切性：算法的每一步骤必须有确切的定义;

3. 输入项：一个算法有0个或多个输入，以刻画运算对象的初始情况，所谓0个输入是指算法本身定出了初始条件;

4. 输出项：一个算法有一个或多个输出，以反映对输入数据加工后的结果，没有输出的算法是毫无意义的;

5. 可行性：算法中执行的任何计算步骤都是可以被分解为基本的可执行操作步，即每个计算步都可以在有限时间内完成;

6. 高效性：执行速度快、占用资源少;

7. 健壮性：数据响应正确。

Python算法分类：

1.
冒泡排序：是一种简单直观的排序算法。重复地走访过要排序的数列，一次比较两个元素，如果顺序错误就交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该排序已经完成。

2.
插入排序：没有冒泡排序和选择排序那么粗暴，其原理最容易理解，插入排序是一种最简单直观的排序算法啊，它的工作原理是通过构建有序序列，对于未排序数据在已排序序列中从后向前排序，找到对应位置。

3.
希尔排序：也被叫做递减增量排序方法，是插入排序的改进版本。希尔排序是基于插入排序提出改进方法的排序算法，先将整个待排序的记录排序分割成为若干个子序列分别进行直接插入排序，待整个序列中的记录基本有序时，再对全记录进行依次直接插入排序。

4. 归并排序：是建立在归并操作上的一种有效的排序算法。该算法是采用分治法Divide and的一个非常典型的应用。

5. 快速排序：由东尼·霍尔所发展的一种排序算法。又是一种分而治之思想在排序算法上的典型应用，本质上快速排序应该算是冒泡排序基础上的递归分治法。

6.
堆排序：是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质，即子结点的键值或索引总是小于它的父结点。

7.
计算排序：其核心在于将输入的数据值转化为键存储在额外开辟的数组空间中，作为一种线性时间复杂度的排序，计算排序要求输入的数据必须是具有确定范围的整数。

B. 求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)))

C. Python中既然有了sort()可以排序，那还有必要实现其他排序算法吗例如堆排序，快速排序

肯定有必要的，sort是基于快速排序，但我们编程的时候不单单要会用，而且要知道原理
此外，有些情况下冒泡、选择排序的时间复杂度也不差，而且实现简单，更适用于一些小数据量的情况，这时候这些排序反而有优势
而且有时候数据结构不一定是整型等， 是我们自定义的类型，要对其中的某个成员变量排序，知道原理就更容易理解

D. python中列表如何快速

//快速排序（分治法）
defquicksort(arr):
iflen(arr)<2:
//快速排序数组元素为0或1时，则直接输出
returnarr
else:
//取第一个值为中心数
pivot=arr[0]
//取剩余值
arr=arr[1:]
//将小于中心数的数放在less数组
less=[iforiinarrifi<=pivot]
//将大于中心数的数放在more数组
greater=[iforiinarrifi>pivot]
//递归
//分解成quicksort(less)，quicksort(greater)这两个更小的部分（分治法）
returnquicksort(less)+[pivot]+quicksort(greater)

E. 求助帮忙看一下用python实现快速排序的代码为什么一直无限循环了应该怎么修改呢

非常简单，就把第一个if left > right 改成 left >= right就可以了。。
当left = right的时候也应该是退出的条件，你没有加上所以就陷入了while != j这个循环里面了。。
在这个里面 left = right =j,而i=left+1=j+1，所以i>j,而你的判断条件只有i<j的，所以两个while和一个if都不满足就一直死循环了。。

F. 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))

G. python包含什么算法

Python基础算法有哪些?
1.
冒泡排序：是一种简单直观的排序算法。重复地走访过要排序的数列，一次比较两个元素，如果顺序错误就交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该排序已经完成。
2.
插入排序：没有冒泡排序和选择排序那么粗暴，其原理最容易理解，插入排序是一种最简单直观的排序算法啊，它的工作原理是通过构建有序序列，对于未排序数据在已排序序列中从后向前排序，找到对应位置。
3.
希尔排序：也被叫做递减增量排序方法，是插入排序的改进版本。希尔排序是基于插入排序提出改进方法的排序算法，先将整个待排序的记录排序分割成为若干个子序列分别进行直接插入排序，待整个序列中的记录基本有序时，再对全记录进行依次直接插入排序。
4. 归并排序：是建立在归并操作上的一种有效的排序算法。该算法是采用分治法Divide and的一个非常典型的应用。
5. 快速排序：由东尼·霍尔所发展的一种排序算法。又是一种分而治之思想在排序算法上的典型应用，本质上快速排序应该算是冒泡排序基础上的递归分治法。
6.
堆排序：是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质，即子结点的键值或索引总是小于它的父结点。
7.
计算排序：其核心在于将输入的数据值转化为键存储在额外开辟的数组空间中，作为一种线性时间复杂度的排序，计算排序要求输入的数据必须是具有确定范围的整数。

H. 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]

I. python 快速排序实现的具体代码，以及讲解。我是小白还请讲清楚一点，谢谢了。

快速排序：在数组L中选一个数叫支点Pivot，把数组L中所有比支点小的数放在支点的左边；比支点大的数放在支点右边..；然后分别对左、右两个新数组重新各选一个支点，重复之前的排法，直到左、右只剩下一个数不用再分。经过这样的过程后，整个数组L就被从小到大排好了.
qsort()是排序的实现。qsort(数组，起点序号，终点序号)；内容是由partition分好一轮后再分别排左、右子数组。
partition()是选支点，并分配数给左右和区分左右的过程。

J. python 算法有哪些比赛

算法是指解题方案的准确而完整的描述，是一系列解决问题的清晰指令，算法代表着用系统的方法描述解决问题的策略机制。简单来讲，能够对一定规范的输入，在有限时间内获得所要求的输出。如果一个算法有缺陷，或不适合于某个问题，执行这个算法将不会解决这个问题。不同的算法可能用不同的时间、空间或效率来完成同样的任务。一个算法的优劣可以用空间复杂度与时间复杂度来衡量。包括这几类：
1.
选择排序算法：选择排序是一种简单直观的排序算法。原理：首先在未排序序列中找到最小或最大元素，存放到排序序列的起始位置;然后，再从剩余未排序元素中继续寻找最大最小元素，然后放到已排序序列的后面，以此类推直到所有元素均排序完毕。
2.
快速排序算法：快速排序的运行速度快于选择排序。原理：设要排序的数组为N，首先任意选取一个数据作为关键数据，然后将所有比它小的数放到它前面，所有比它大的数都放到它后面，这个过程称之为快速排序。
3. 二分查找算法：二分查找的输入是一个有序的列表，如果要查找的元素包含在一个有序列表中，二分查找可以返回其位置。
4.
广度优先搜索算法：属于一种图算法，图由节点和边组成。一个节点可以与多个节点连接，这些节点称为邻居。它可以解决两类问题：第一类是从节点A出发，在没有前往节点B的路径;第二类问题是从节点A出发，前往B节点的哪条路径最短。使用广度优先搜索算法的前提是图的边没有权值，即该算法只用于非加权图中，如果图的边有权值的话就应该使用狄克斯特拉算法来查找最短路径。
5.
贪婪算法：又叫做贪心算法，对于没有快速算法的问题，就只能选择近似算法，贪婪算法寻找局部最优解，并企图以这种方式获得全局最优解，它易于实现、运行速度快，是一种不错的近似算法。