快速排序的递归方法总结

原始算法

MethodA.cpp

#include "stdafx.h"
#include "MethodA.h"

MethodA::MethodA(int* ve)
{
A = ve;
}

MethodA::~MethodA()
{
}

int* MethodA::QuickSort( int p, int r)
{
if (p < r)
{
int q = Partition( p, r);
QuickSort(p, q - 1);
QuickSort(q + 1,r);
}
return A;
}

int MethodA::Partition( int p, int r)
{
int x = A[r];
int i = p-1;
for ( int j = p; j < r; j++)
{
if (A[j] <= x)
{
i = i + 1;
exchange(i, j);
}
}
if (i + 1 < r)
{
i++;
exchange(i, r);
}
return i;
}

void MethodA::exchange(int a, int b)
{
int x = A[a];
A[a] = A;
A[b] = x;
}

[b]随机枢轴

MethodB.cpp

#include "stdafx.h"
#include "MethodB.h"
#include "stdlib.h"
#include "time.h"

MethodB::MethodB(int* ve)
{
A = ve;
}

MethodB::~MethodB()
{
}
int* MethodB::QuickSort(int p, int r)
{
if (p < r)
{
int q = Partition(p, r);
QuickSort(p, q - 1);
QuickSort(q + 1, r);
}
return A;
}

int MethodB::Partition(int p, int r)
{
//生成随机的枢轴
srand(r);
int t = rand()%(r-p)+p;
exchange(t, r);
//下同原始快速排序
int x = A[r];
int i = p - 1;
for (int j = p; j < r; j++)
{
if (A[j] <= x)
{
i = i + 1;
exchange(i, j);
}
}
exchange(i + 1, r);
return i + 1;
}

void MethodB::exchange(int a, int b)
{
int x = A[a];
A[a] = A;
A[b] = x;
}

[b]三数取中

MethodC.cpp

#include "stdafx.h"
#include "MethodC.h"

MethodC::MethodC(int* ve)
{
A = ve;
}

MethodC::~MethodC()
{
}

int* MethodC::QuickSort(int p, int r)
{
if (p < r)
{
int q = Partition(p, r);
QuickSort(p, q - 1);
QuickSort(q + 1, r);
}
return A;
}

int MethodC::Partition(int p, int r)
{
//生成随机的枢轴
int t = getMid(p, (p + r) / 2, r);
exchange(t, r);
//下同原始快速排序
int x = A[r];
int i = p - 1;
for (int j = p; j < r; j++)
{
if (A[j] <= x)
{
i = i + 1;
exchange(i, j);
}
}
exchange(i + 1, r);
return i + 1;
}

void MethodC::exchange(int a, int b)
{
int x = A[a];
A[a] = A;
A[b] = x;
}

int MethodC::getMid(int a, int b, int c)
{
if ((A[a] > A[b] && A[a] < A[c])||(A[a]>A[c]&&A[a]<A[b]))
{
return a;
}
else if ((A[b] > A[a] && A[b] < A[c]) || (A[b]<A[a] && A[b]>A[c]))
{
return b;
}
else
return c;
}

[b]三数取中+直排

MethodD.cpp

#include "stdafx.h"
#include "MethodD.h"
#include "InsertSort.h"

MethodD::MethodD(int *arr)
{
A = arr;
}

MethodD::~MethodD()
{
}
int* MethodD::QuickSort(int p, int r)
{
if (p < r)
{
int q = Partition(p, r);
if (r - p>N - 1)
{
QuickSort(p, q - 1);
QuickSort(q + 1, r);

4000
}
else
{
A=InsertSort(A).Sort(p, r);
}
}
return A;
}

int MethodD::Partition(int p, int r)
{
int x = A[r];
int i = p - 1;
for (int j = p; j < r; j++)
{
if (A[j] <= x)
{
i = i + 1;
if(i!=j)
exchange(i, j);
}
}
exchange(i + 1, r);
return i + 1;
}

void MethodD::exchange(int a, int b)
{
int x = A[a];
A[a] = A;
A[b] = x;
}

[b]插入排序

InsertSort.cpp

#include "stdafx.h"
#include "InsertSort.h"

InsertSort::InsertSort(int* ve)
{
A = ve;
}

InsertSort::~InsertSort()
{
}

int * InsertSort::Sort(int p, int q)
{
for (int i = p; i <= q; i++)
{
for (int j = p; j <i; j++)
{
if (A[i]<A[j])
{
int tmp = A[i];
for (int k = i- 1; k >= j; k--)
{
A[k + 1] = A[k];
}
A[j] = tmp;
break;
}
}
}
return A;
}

//void InsertSort::exchange(int a, int b)
//{
//  int x = A[a];
//  A[a] = A[b];
//  A[b] = x;
//}