各種排序演算法的比較

Ⅰ 各種排序演算法最好和最壞情況比較

最壞情況下比較次數最少的為D）堆排序：
A）冒泡排序 需要比較O(n^2)次（n(n - 1)/2次），即序列逆序的情況
B）簡單選擇排序，無論是否最壞都需要O(n^2)次（n(n - 1)/2次）
C）直接插入排序，最壞情況需要比較O(n^2)次（n(n - 1)/2次）
D）堆排序，無論是否最壞比較O(nlog2n)次
E）快速排序，最壞情況退化為冒泡排序，需要比較O(n^2)次（n(n - 1)/2次）

Ⅱ 幾種常用的排序演算法比較

排序，從小大，0坐標的在下面，即排序後小的在下面，大的在上面。

1，冒泡Bubble：從第0個開始，一直往上，與相鄰的元素比較，如果下面的大，則交換。
Analysis：
Implementation：
void BubbleSort(int *pData, int iNum)

2，插入Insertion：與打撲克牌時整理牌很想像，假定第一張牌是有序的，從第二張牌開始，拿出這張牌來，往下比較，如果有比這張牌大的，則把它撥到上一個位置，直到找到比手上的這張更小的（或到頂了），
則把手上的這張牌插入到這張更小的牌的後面。
Analysis：
Implementation：
void InsertionSort(int *list, int length)
{
int i, j, temp;
for (i = 1; i < length; i++)
{
temp = list[i];
j = i - 1;
while ((j >= 0) && (list[j] > temp))
{
list[j+1] = list[j];
j--;
}
list[j+1] = temp;
}
}

3，選擇Selection：從所有元素中找到最小的放在0號位置，從其它元素（除了0號元素）中再找到最小的，放到1號位置，......。
Analysis：
Implementation：
void SelectionSort(int data[], int count)
{
int i, j, min, temp;
for (i = 0; i < count - 1; i++)
{
/* find the minimum */
min = i;
for (j = i+1; j < count; j++)
{
if (data[j] < data[min])
{
min = j;
}
}
/* swap data[i] and data[min] */
temp = data[i];
data[i] = data[min];
data[min] = temp;
}
}

4，快速Quick：先拿出中間的元素來（值保存到temp里），設置兩個索引（index or pointer），一個從0號位置開始往最大位置尋找比temp大的元素；一個從最大號位置開始往最小位置尋找比temp小的元素，找到了或到頂了，則將兩個索引所指向的元素
互換，如此一直尋找交換下去，直到兩個索引交叉了位置，這個時候，從0號位置到第二個索引的所有元素就都比temp小，從第一個索引到最大位置的所有元素就都比temp大，這樣就把所有元素分為了兩塊，然後採用前面的辦法分別排序這兩個部分。總的來
說，就是隨機找一個元素（通常是中間的元素），然後把小的放在它的左邊，大的放右邊，對左右兩邊的數據繼續採用同樣的辦法。只是為了節省空間，上面採用了左右交換的方法來達到目的。
Analysis：
Implementation：
void QuickSort(int *pData, int left, int right)
{
int i, j;
int middle, iTemp;
i = left;
j = right;

middle = pData[(left + right) / 2]; //求中間值
do
{
while ((pData[i] < middle) && (i < right)) //從左掃描大於中值的數
i++;

while ((pData[j] > middle) && (j > left)) //從右掃描小於中值的數
j--;

if (i <= j) //找到了一對值
{
//交換
iTemp = pData[i];
pData[i] = pData[j];
pData[j] = iTemp;
i++;
j--;
}
} while (i <= j); //如果兩邊掃描的下標交錯，就停止（完成一次）

//當左邊部分有值(left<j)，遞歸左半邊
if(left < j)
QuickSort(pData, left, j);

//當右邊部分有值(right>i)，遞歸右半邊
if(right > i)
QuickSort(pData, i, right);
}

5，希爾Shell：是對Insertion Sort的一種改進，在Insertion Sort中，從第2個位置開始取出數據，每次都是與前一個（step/gap==1）進行比較。Shell Sort修改為，在開始時採用較大的步長step，
從第step位置開始取數據，每次都與它的前step個位置上的數據進行比較（如果有8個數據，初始step==4，那麼pos(4)與pos(0)比較，pos(0)與pos(-4)，pos(5)與pos(1)，pos(1)與pos(-3)，
...... pos(7)與pos(3)，pos(3)與pos(-1)），然後逐漸地減小step，直到step==1。step==1時，排序過程與Insertion Sort一樣，但因為有前面的排序，這次排序將減少比較和交換的次數。
Shell Sort的時間復雜度與步長step的選擇有很大的關系。Shell排序比冒泡排序快5倍，比插入排序大致快2倍。Shell排序比起QuickSort，MergeSort，HeapSort慢很多。但是它相對比較簡單，它適合
於數據量在5000以下並且速度並不是特別重要的場合。它對於數據量較小的數列重復排序是非常好的。
Analysis：
Implementation：
template<typename RandomIter, typename Compare>
void ShellSort(RandomIter begin, RandomIter end, Compare cmp)
{
typedef typename std::iterator_traits<RandomIter>::value_type value_type;
typedef typename std::iterator_traits<RandomIter>::difference_type diff_t;

diff_t size = std::distance(begin, end);
diff_t step = size / 2;
while (step >= 1)
{

for (diff_t i = step; i < size; ++i)
{
value_type key = *(begin+i);
diff_t ins = i; // current position

while (ins >= step && cmp(key, *(begin+ins-step)))
{
*(begin+ins) = *(begin+ins-step);
ins -= step;
}

*(begin+ins) = key;
}

if(step == 2)
step = 1;
else
step = static_cast<diff_t>(step / 2.2);
}
}

template<typename RandomIter>
void ShellSort(RandomIter begin, RandomIter end)
{
typedef typename std::iterator_traits<RandomIter>::value_type value_type;
ShellSort(begin, end, std::less<value_type>());
}

6，歸並Merge：先將所有數據分割成單個的元素，這個時候單個元素都是有序的，然後前後相鄰的兩個兩兩有序地合並，合並後的這兩個數據再與後面的兩個合並後的數據再次合並，充分前面的過程直到所有的數據都合並到一塊。
通常在合並的時候需要分配新的內存。
Analysis：
Implementation：
void Merge(int array[], int low, int mid, int high)
{
int k;
int *temp = (int *) malloc((high-low+1) * sizeof(int)); //申請空間，使其大小為兩個已經排序序列之和，該空間用來存放合並後的序列
int begin1 = low;
int end1 = mid;
int begin2 = mid + 1;
int end2 = high;

for (k = 0; begin1 <= end1 && begin2 <= end2; ++k) //比較兩個指針所指向的元素，選擇相對小的元素放入到合並空間，並移動指針到下一位置
{
if(array[begin1]<=array[begin2])
{
temp[k] = array[begin1++];
}
else
{
temp[k] = array[begin2++];
}
}
if(begin1 <= end1) //若第一個序列有剩餘，直接拷貝出來粘到合並序列尾
{
memcpy(temp+k, array+begin1, (end1-begin1+1)*sizeof(int));
}
if(begin2 <= end2) //若第二個序列有剩餘，直接拷貝出來粘到合並序列尾
{
memcpy(temp+k, array+begin2, (end2-begin2+1)*sizeof(int));
}
memcpy(array+low, temp, (high-low+1)*sizeof(int));//將排序好的序列拷貝回數組中
free(temp);
}

void MergeSort(int array[], unsigned int first, unsigned int last)
{
int mid = 0;
if (first < last)
{
mid = (first+last)/2;
MergeSort(array, first, mid);
MergeSort(array, mid+1,last);
Merge(array,first,mid,last);
}
}

Ⅲ 綜合排序演算法的比較

#include "stdio.h "
#include "stdlib.h "
#define Max 100 //假設文件長度
typedef struct{ //定義記錄類型
int key; //關鍵字項
}RecType;
typedef RecType SeqList[Max+1]; //SeqList為順序表，表中第0個元素作為哨兵
int n; //順序表實際的長度
//==========直接插入排序法======
void InsertSort(SeqList R) { //對順序表R中的記錄R[1¨n]按遞增序進行插入排序
int i,j;
for(i=2;i <=n;i++) //依次插入R[2]，……，R[n]
if(R[i].key <R[i-1].key){ //若R[i].key大於等於有序區中所有的keys，則R[i]留在原位 R[0]=R[i];j=i-1; //R[0]是R[i]的副本 do { //從右向左在有序區R[1¨i-1]中查找R[i] 的位置 R[j+1]=R[j]; //將關鍵字大於R[i].key的記錄後移 j--; }while(R[0].key <R[j].key); //當R[i].key≥R[j].key 是終止
R[j+1]=R[0]; //R[i]插入到正確的位置上
}//endif
}
//==========冒泡排序======= typedef enum{FALSE,TRUE} Boolean; //FALSE為0，TRUE為1
void BubbleSort(SeqList R) { //自下向上掃描對R做冒泡排序
int i,j;
bool exchange; //交換標志 for(i=1;i <n;i++) { //最多做n-1趟排序
exchange=false; //本趟排序開始前，交換標志應為假
for(j=n-1;j> =i;j--){ //對當前無序區R[i¨n] 自下向上掃描
if(R[j+1].key <R[j].key){ //兩兩比較，滿足條件交換記錄
R[0]=R[j+1]; //R[0]不是哨兵，僅做暫存單元
R[j+1]=R[j];
R[j]=R[0];
exchange=true; //發生了交換，故將交換標志置為真
}
if(! exchange) return; //本趟排序未發生交換，提前終止演算法
}// endfor（為循環）
}
//==========快速排序=======
//1.========一次劃分函數=====
int Partition(SeqList R,int i,int j) {
// 對R[i¨j]做一次劃分，並返回基準記錄的位置
RecType pivot=R[i]; //用第一個記錄作為基準
while(i <j) { //從區間兩端交替向中間掃描，直到i=j
while(i <j &&R[j].key> =pivot.key) //基準記錄pivot相當與在位置i上
j--; //從右向左掃描，查找第一個關鍵字小於pivot.key的記錄R[j]
if(i <j) //若找到的R[j].key < pivot.key，則
R[i++]=R[j]; //交換R[i]和R[j]，交換後i指針加1
while(i <j &&R[i].key <=pivot.key) //基準記錄pivot相當與在位置j上
i++; //從左向右掃描，查找第一個關鍵字小於pivot.key的記錄R[i]
if(i <j) //若找到的R[i].key > pivot.key，則
R[j--]=R[i]; //交換R[i]和R[j]，交換後j指針減1
}
R[i]=pivot; //此時，i=j，基準記錄已被最後定位
return i; //返回基準記錄的位置
}
//2.=====快速排序===========
void QuickSort(SeqList R,int low,int high) { //R[low..high]快速排序
int pivotpos; //劃分後基準記錄的位置
if(low <high) { //僅當區間長度大於1時才排序
pivotpos=Partition(R,low,high); //對R[low..high]做一次劃分，得到基準記錄的位置
QuickSort(R,low,pivotpos-1); //對左區間遞歸排序
QuickSort(R,pivotpos+1,high); //對右區間遞歸排序
}
}
//======直接選擇排序========
void SelectSort(SeqList R) {
int i,j,k;
for(i=1;i <n;i++){ //做第i趟排序（1≤i≤n-1）
k=i;
for(j=i+1;j <=n;j++) //在當前無序區R[i¨n]中選key最小的記錄R[k]
if(R[j].key <R[k].key)
k=j; //k記下目前找到的最小關鍵字所在的位置
if(k!=i) { //交換R[i]和R[k]
R[0]=R[i];R[i]=R[k];R[k]=R[0];
} //endif
} //endfor
}
//======堆排序========
//==========大根堆調整函數=======
void Heapify(SeqList R,int low,int high) {
// 將R[low..high]調整為大根堆，除R[low]外，其餘結點均滿足堆性質
int large; //large指向調整結點的左、右孩子結點中關鍵字較大者
RecType temp=R[low]; //暫存調整結點
for(large=2*low; large <=high;large*=2){ //R[low]是當前調整結點
//若large> high,則表示R[low]是葉子，調整結束；否則先令large指向R[low]的左孩子
if(large <high && R[large].key <R[large+1].key)
large++; //若R[low]的右孩子存在且關鍵字大於左兄弟，則令large指向它
//現在R[large]是調整結點R[low]的左右孩子結點中關鍵字較大者
if(temp.key> =R[large].key) //temp始終對應R[low]
break; //當前調整結點不小於其孩子結點的關鍵字，結束調整
R[low]=R[large]; //相當於交換了R[low]和R[large]
low=large; //令low指向新的調整結點，相當於temp已篩下到large的位置
}
R[low]=temp; //將被調整結點放入最終位置上
}
//==========構造大根堆==========
void BuildHeap(SeqList R) { //將初始文件R[1..n]構造為堆
int i;
for(i=n/2;i> 0;i--)
Heapify(R,i,n); //將R[i..n]調整為大根堆
}
//==========堆排序===========
void HeapSort(SeqList R) { //對R[1..n]進行堆排序，不妨用R[0]做暫存單元
int i;
BuildHeap(R); //將R[1..n]構造為初始大根堆
for(i=n;i> 1;i--){ //對當前無序區R[1..i]進行堆排序，共做n-1趟。
R[0]=R[1]; R[1]=R[i];R[i]=R[0]; //將堆頂和堆中最後一個記錄交換
Heapify(R,1,i-1); //將R[1..i-1]重新調整為堆，僅有R[1]可能違反堆性質。
}
}
//==========二路歸並排序===========
//===將兩個有序的子序列R[low..m]和R[m+1..high]歸並成有序的序列R[low..high]===
void Merge(SeqList R,int low,int m,int high) {
int i=low,j=m+1,p=0; //置初始值
RecType *R1; //R1為局部量
R1=(RecType *)malloc((high-low+1)*sizeof(RecType)); //申請空間
while(i <=m && j <=high) //兩個子序列非空時取其小者輸出到R1[p]上
R1[p++]=(R[i].key <=R[j].key)? R[i++]:R[j++];
while(i <=m) //若第一個子序列非空，則復制剩餘記錄到R1
R1[p++]=R[i++];
while(j <=high) //若第二個子序列非空，則復制剩餘記錄到R1中
R1[p++]=R[j++];
for(p=0,i=low;i <=high;p++,i++)
R[i]=R1[p]; //歸並完成後將結果復制回R[low..high]
}
//=========對R[1..n]做一趟歸並排序========
void MergePass(SeqList R,int length) {
int i;
for(i=1;i+2*length-1 <=n;i=i+2*length)
Merge(R,i,i+length-1,i+2*length-1); //歸並長度為length的兩個相鄰的子序列
if(i+length-1 <n) //尚有一個子序列，其中後一個長度小於length
Merge(R,i,i+length-1,n); //歸並最後兩個子序列
//注意：若i≤n且i+length-1≥n時，則剩餘一個子序列輪空，無須歸並
}
//========== 自底向上對R[1..n]做二路歸並排序===============
void MergeSort(SeqList R) {
int length;
for(length=1;length <n;length*=2) //做[lgn]趟排序
MergePass(R,length); //有序長度≥n時終止
}
//==========輸入順序表========
void input_int(SeqList R) {
int i;
printf( "Please input num(int): ");
scanf( "%d ",&n);
printf( "Plase input %d integer: ",n);
for(i=1;i <=n;i++)
scanf( "%d ",&R[i].key);
}
//==========輸出順序表========
void output_int(SeqList R) {
int i;
for(i=1;i <=n;i++)
printf( "%4d ",R[i].key);
}
//==========主函數======
void main() {
int i;
SeqList R;
input_int(R);
printf( "\t******** Select **********\n ");
printf( "\t1: Insert Sort\n ");
printf( "\t2: Bubble Sort\n ");
printf( "\t3: Quick Sort\n ");
printf( "\t4: Straight Selection Sort\n ");
printf( "\t5: Heap Sort\n ");
printf( "\t6: Merge Sort\n ");
printf( "\t7: Exit\n ");
printf( "\t***************************\n ");
scanf( "%d ",&i); //輸入整數1-7，選擇排序方式
switch (i){
case 1: InsertSort(R);
break; //值為1，直接插入排序
case 2: BubbleSort(R);
break; //值為2，冒泡法排序
case 3: QuickSort(R,1,n);
break; //值為3，快速排序
case 4: SelectSort(R);
break; //值為4，直接選擇排序
case 5: HeapSort(R);
break; //值為5，堆排序
case 6: MergeSort(R);
break; //值為6，歸並排序
case 7: exit(0); //值為7，結束程序
}
printf( "Sort reult: ");
output_int(R);
}

Ⅳ 各種排序演算法比較

插入排序 n*n、希爾排序 <=n*n、起泡排序 <=n* n、快速排序 n *log 2 n、選擇排序=n * n、堆排序n * log2 n、歸並排序 n * n

Ⅳ 數據結構中幾種常見的排序演算法之比較

實話實說，關於數據結構中幾種常見的排序演算法（例如：冒泡排序、SHELL排序、歸並排序、快速排序等）的性能好壞，還不只是學好了數據結構這門課程就能夠解決的問題，還必須要學習好、且精通掌握計算機軟體專業的另外一門非常重要的課程，才能夠解決這個問題。即：計算機演算法復雜性理論。
只有同時把這門課程學好了，那麼才能夠真正掌握數據結構中的各種排序演算法、以及各種查找演算法中所有涉及到的：比較次數、以及交換次數，最終才能夠根據具體的開發軟體規模的不同，選擇出一個適合開發該軟體的最佳演算法。

Ⅵ 6．各種排序演算法比較

什麼意圖
幾乎全是垃圾演算法。。。。。。
~~~~

Ⅶ 幾種排序演算法效率的比較

插入排序，選擇排序，交換排序（冒泡），數據結構書上有詳細的介紹
以下是直接插入排序，選擇排序，希爾排序，冒泡排序的演算法

/*直接插入排序的基本思想是：順序地把待排序序
列中的各個記錄按其關鍵字的大小，插入到已排
序的序列的適當位置。
*/

void InsertSort(elemtype x[], int n)
{
int i,j;
elemtype s;

for(i=0;i<n-1;i )
{
s = x[i 1];
j = i;
while(j>-1 && s.key<x[j].key)
{
x[j 1] = x[j];
j--;
}
x[j 1]=s;
}
}

/*選擇排序的基本思想是：不斷從待排序的序列中
選取關鍵字最小的記錄放到已排序的記錄序列的
後面，知道序列中所有記錄都已排序為止。
*/
void SelectSort(elemtype x[], int n)
{
int i,j,Small;
elemtype Temp;

for(i=0;i<n-1;i )
{
Small = i;
for(j=i 1;j<n;j )
{
if(x[j].key<x[Small].key)
Small = j;
}

if(Small!=i)
{
Temp = x[i];
x[i] = x[Small];
x[Small] = Temp;
}
}
}

/*希爾排序的基本思想是：不斷把待排序的記錄分
成若干個小組，對同一組內的記錄進行排序，在
分組時，始終保證當前組內的記錄個數超過前面
分組排序時組內的記錄個數。
*/

void ShellSort(elemtype x[], int n, int d[], int Number)
{
int i, j, k, m, Span;
elemtype s;

for(m=0;m<Number;m )
{
Span = d[m];
for(k=0;k<Span;k )
{
for(i=k;i<n-Span;i =Span)
{
s = x[i Span];
j = i;
while(j>-1 && s.key<x[j].key)
{
x[j Span] = x[j];
j-=Span;
}
x[j Span] = s;
}
}
}
}

/*冒泡排序的基本思想是：將待排序序列中第一個
記錄的關鍵字R1與第二個記錄的關鍵字R2做比較，
如果R1>R2，則交換R1和R2的位置，否則不交換；
然後繼續對當前序列中的第二個記錄和第三個記
錄同樣的處理，依此類推。
*/

void BubbleSort(elemtype x[], int n)
{
int i,j,flag=1;
elemtype temp;

for(i=1;i<n && flag==1;i )
{
flag=0;
for(j=0;j<n-i;j )
{
if(x[j].key>x[j 1].key)
{
flag=1;
temp=x[j];
x[j]=x[j 1];
x[j 1]=temp;
}
}
}
}

Ⅷ 簡述各種排序演算法的優缺點

一、冒泡排序
已知一組無序數據a[1]、a[2]、……a[n]，需將其按升序排列。首先比較a[1]與 a[2]的值，若a[1]大於a[2]則交換 兩者的值，否則不變。再比較a[2]與a[3]的值，若a[2]大於a[3]則交換兩者的值，否則不變。再比 較a[3]與a[4]，以此 類推，最後比較a[n-1]與a[n]的值。這樣處理一輪後，a[n]的值一定是這組數據中最大的。再對a[1]~a[n- 1]以相同方法 處理一輪，則a[n-1]的值一定是a[1]~a[n-1]中最大的。再對a[1]~a[n-2]以相同方法處理一輪，以此類推。共處理 n-1 輪 後a[1]、a[2]、……a[n]就以升序排列了。
優點：穩定；
缺點：慢，每次只能移動相鄰兩個數據。

二、選擇排序
每一趟從待排序的數據元素中選出最小（或最大）的一個元素，順序放在已排好序的數列的最後，直到全部待排序的數 據元素排完。
選擇排序是不穩定的排序方法。
n 個記錄的文件的直接選擇排序可經過n-1 趟直接選擇排序得到有序結果：
①初始狀態：無序區為R[1..n]，有序區為空。
②第1 趟排序 在無序區R[1..n]中選出關鍵字最小的記錄R[k]，將它與無序區的第1 個記錄R[1]交換，使R[1..1]和R[2..n]分別變 為記錄個數增加1 個的新有序區和記錄個數減少1 個的新無序區。
③第i 趟排序
第i 趟排序開始時，當前有序區和無序區分別為R[1..i-1]和R(1≤i≤n-1)。該趟 排序從當前無序區中選出關鍵字最 小的記錄 R[k]，將它與無序區的第1 個記錄R 交換，使R[1..i]和R 分別變為記錄個數增加1 個的新有序區和記錄個數減少 1 個的新無序區。
這樣，n 個記錄的文件的直接選擇排序可經過n-1 趟直接選擇排序得到有序結果。
優點：移動數據的次數已知（n-1 次）；
缺點：比較次數多。

三、插入排序
已知一組升序排列數據a[1]、a[2]、……a[n]，一組無序數據b[1]、 b[2]、……b[m]，需將二者合並成一個升序數列。 首先比較b[1]與a[1]的值，若b[1]大於a[1]，則跳過，比較b[1]與a[2]的值， 若b[1]仍然大於a[2]，則繼續跳過，直 到b[1]小於a 數組中某一數據a[x]，則將a[x]~a[n]分別向後移動一位，將b[1]插入到原來 a[x]的位置這就完成了b[1] 的插入。b[2]~b[m]用相同方法插入。（若無數組a，可將b[1]當作n=1 的數組a）
優點：穩定，快；
缺點：比較次數不一定，比較次數越少，插入點後的數據移動越多，特別是當數據總量龐大的時候，但用鏈表可以解決 這個問題。

四、縮小增量排序
由希爾在1959 年提出，又稱希爾排序(shell 排序)。
已知一組無序數據a[1]、a[2]、……a[n]，需將其按升序排列。發現當n 不大時，插入 排序的效果很好。首先取一增 量d(d<n)，將a[1]、a[1+d]、a[1+2d]……列為第一組，a[2]、a[2+d]、 a[2+2d]……列為第二組……，a[d]、a[2d]、a[3d]……="" 列為最後一組以次類推，在各組內用插入排序，然後取d'<d，重復上述操="" 作，直到d="1。"
優點：快，數據移動少；=""
缺點：不穩定，d="" 的取值是多少，應取多少個不同的值，都無法確切知道，只能憑經驗來取。=""

五、快速排序=""
快速排序是冒泡排序的改進版，是目前已知的最快的排序方法。
="" 已知一組無序數據a[1]、a[2]、……a[n]，需將其按升序排列。首先任取數據a[x]="" 作為基準。比較a[x]與其它數據並="" 排序，使a[x]排在數據的第k="" 位，並且使a[1]~a[k-1]中的每一個數="" 據a[x]，然後采 用分治的策略分別對a[1]~a[k-1]和a[k+1]~a[n] 兩組數據進行快速排序。
優點：極快，數據移動少；
缺點：不穩定。

Ⅸ 求各種排序演算法的比較

給你一個國家集訓隊的快排吧，這個應該夠用了。
這個是對a數組從小到大排序，把這個添加到任何程序中都很快。這個肯定要比堆排序快。對於插入排序快的快排肯定要較慢。但這個比較穩定，要不國家集訓隊怎麼用它呢！！！！！！
procere qsort(l,r:longint);
var
i,j,x,yy:longint;
begin
i:=l;j:=r;x:=a[(i+j) shr 1];
repeat
while a[i]<x do inc(i);
while a[j]>x do dec(j);
if i<=j then
begin
yy:=a[i];a[i]:=a[j];a[j]:=yy;
inc(i);dec(j);
end;
until i>j;
if i<r then qsort(i,r);
if l<j then qsort(l,j);
end;