快排算法
❶ 帮我写一个快排的算法
procere px(l,r:longint);
var i,j,tmp,mid:longint;
begin
i:=l;j:=r;mid:=a[(l+r) shr 1];
repeat
while a[i]<mid do inc(i);
while mid<a[j] do dec(j);
if i<=j then
begin
tmp:=a[i];
a[i]:=a[j];
a[j]:=tmp;
inc(i);dec(j);
end;
until i>j;
if l<j then px(l,j);
if i<r then px(i,r)'
end;
❷ 求问关于快速排序算法
当然变了啊 你说的i是快排的区间起始节点吧
❸ python 三路快排算法
classquick_sort(object):
def_partition(self,alist,p,r):
i=p-1
x=alist[r]
forjinrange(p,r):
ifalist[j]<=x:
i+=1
alist[i],alist[j]=alist[j],alist[i]
alist[i+1],alist[r]=alist[r],alist[i+1]
returni+1
def_quicksort(self,alist,p,r):
ifp<r:
q=self._partition(alist,p,r)
self._quicksort(alist,p,q-1)
self._quicksort(alist,q+1,r)
def__call__(self,sort_list):
self._quicksort(sort_list,0,len(sort_list)-1)
returnsort_list
❹ 算法导论中的快排算法实现出错
我未学过pascal，但看你的代码总觉得posion函数有问题，下面是我的C代码，不知你能否看懂
int Posion(int *ar,int l,int h){
int k=ar[l];
while(l<h){
while(l<h&&k<=ar[h])
h--;
ar[l]=ar[h];
while(l<h&&k>=ar[l])
l++;
ar[h]=ar[l];
}
ar[l]=k;
return l;
}
❺ 关于快速排序算法
当待排序区间中的关键码都相同，也就是快速排序的最坏情况，其运行时间是
O(n^2)，然而但在关键码不全相同时，如果总是选择中项作为主元，它的时间复杂性是O(nlogn)。
尽管在最坏情况下，快排表现出的运行时间为O（n^2），但它的平均时间复杂度仍是O(nlogn)。
❻ 快排 递归算法
procere qsort(i,j:longint);
var r,l:longint;mid,temp:longint;
begin
r:=j;
l:=i;
mid:=a[r];
repeat
while a[r]>mid do dec(r);
while a[l]<mid do inc(l);
if r>=l
then
begin
temp:=a[r];
a[r]:=a[l];
a[l]:=temp;
inc(l);dec(r);
end;
until r<l;
if i<r then qsort(i,r);
if l<j then qsort(l,j);
end;
//A是排序数组
//基本方法:把小于MIN的放在一边,
把大于MIN的放在另一边. 递归解决.时间复杂度o(n*log(n))
❼ 快速排序算法
在实际应用中，都会选择一些比较成熟有保障的算法，而不是自己写。
建议参考微软的类库。
❽ 快排算法是什么意思
快速排序，外文名Quicksort，计算机科学，适用领域Pascal，c++等语言，是对冒泡排序算法的一种改进。
原理：
设要排序的数组是A[0]……A[N-1]，首先任意选取一个数据（通常选用数组的第一个数）作为关键数据，然后将所有比它小的数都放到它左边，所有比它大的数都放到它右边，这个过程称为一趟快速排序。
性能分析：
快速排序的一次划分算法从两头交替搜索，直到low和hight重合，因此其时间复杂度是O(n)；而整个快速排序算法的时间复杂度与划分的趟数有关。
理想的情况是，每次划分所选择的中间数恰好将当前序列几乎等分，经过log2n趟划分，便可得到长度为1的子表。这样，整个算法的时间复杂度为O(nlog2n)。
以上内容参考：网络——快排算法
❾ 关于算法 快排
网络快速排序就能够明白的事 还要求别人不复制。。。真弄不明白你
❿ 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]