快排演算法

❶ 幫我寫一個快排的演算法

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]