快速排序的递归方法总结

原始算法

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[b];
    A[b] = x;
}

随机枢轴

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[b];
    A[b] = x;
}

三数取中

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[b];
    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;
}

三数取中+直排

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);
        }
        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[b];
    A[b] = x;
}

插入排序

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;
//}