1.排序问题

　　现有一个含有N个数字的数组S，如何通过程序把这个数组变成有序的数组？

　　例如：

　　排序前：S：5,3,7,5,9,4,1,100,50

　　排序后：S：1,3,4,5,5,7,9,50,100

2.快速排序（Quicksort）

　　简单介绍：　　

　　快速排序内含一道重要的工序：分区（Partition）。这里将先介绍分区，然后介绍排序方法。

分区：

　　

　　对于一个数组，将它的第一个元素设为V,令i=2，j为数组的最后一个元素的序号（index）。

　　1.先从i开始比较，如果i项元素比V小，则i++;否则停止比较，此时的i项元素大于等于V。

　　2.然后从j开始比较，如果j项元素比V大，则j--;否则停止比较，此时的i项元素小于等于V。

　　3.如果i<j,说明i项元素和j项元素之间还有元素，将i项元素和j项元素互换，然后i++,j--，然后重复1，2，3步骤，直到i和j重合（即i=j）。

　　4.将J项元素和V互换。这样就得到了一个分好区的数组：V的左端的元素都小于等于V;V的右端都大于等于V。

排序：

　　1.将整个数组进行分区。

　　2.对分区得到的两个部分数组分别进行分区，不停的分区下去，直到分区数组只有一个元素为止。

　　3.排序完成。

3.快速排序的优缺点

优点：

不需要额外空间（归并排序需要一个额外数组），速度比归并排序快。

缺点：

1.如果数组是递增的有序数组，对它用快速排序需要N2/2次操作。

2.No Stable:如果数组已经按一种排序方式排成有序了，然后再按另一种排序方式用快速排序对此数组排序，则会打乱第一种排序。（例如手机通讯录先按地区排了一次序，再按名字排一次序。）PS:归并排序是Stable的。

 

4.快速排序具体代码实现：

.h：

UCLASS()
class ALGORITHM_API AQuicksort : public AActor
{
    GENERATED_BODY()
    
public:    
    // Sets default values for this actor's properties
    AQuicksort();
    // Called every frame
    virtual void Tick(float DeltaTime) override;

    //生成数组
    void InitArray(int N);
    //把此部分数组分为两半，中间分界线为v,左半部分的数字都比v小，右半部分的数字都比v大
    int Partition(int lo, int hi);
    //更换数组里两个数字
    void ExChange(int i, int j);//开始排序
    //开始排序
    void Sort();
    void Sort( int lo, int hi);

protected:
    // Called when the game starts or when spawned
    virtual void BeginPlay() override;

public:    
    

private:

    TArray<int> MyIntArray;
};

.cpp：

// Sets default values
AQuicksort::AQuicksort()
{
     // Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
    PrimaryActorTick.bCanEverTick = true;

}

// Called when the game starts or when spawned
void AQuicksort::BeginPlay()
{
    Super::BeginPlay();
    //测试
    //生成数组
    InitArray(10000);
    UKismetSystemLibrary::PrintString(this, "Before Sort: ");
    for (int i = 0; i < MyIntArray.Num(); i++)
    {
        UKismetSystemLibrary::PrintString(this, FString::FromInt(i) + " : " + FString::FromInt(MyIntArray[i]));
    }
    //开始排序
    Sort();
    UKismetSystemLibrary::PrintString(this, "After Sort: ");
    for (int i = 0; i < MyIntArray.Num(); i++)
    {
        UKismetSystemLibrary::PrintString(this, FString::FromInt(i) + " : " + FString::FromInt(MyIntArray[i]));
    }
    
}

// Called every frame
void AQuicksort::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);

}

void AQuicksort::InitArray(int N)
{
    FRandomStream Stream;
    Stream.GenerateNewSeed();
    for (int i = 0; i < N; i++)
    {
        MyIntArray.Add(Stream.RandRange(0, 100));
    }
}

int AQuicksort::Partition(int lo, int hi)
{
    int i(lo);
    //因为后面会--j，而我们需要从hi项开始比较，所以这里j=hi+1
    int j(hi + 1);
    //只要中途不break，循环一直进行下去
    while (true)
    {
        //lo项作为比较用的元素，从lo+1开始比较,直到找到大于等于lo项的元素，才停止（除非lo项是此部分数组中最大的，此时i=hi）
        //停止时，i项元素比lo项大
        //注意：MyIntArray[++i] < MyIntArray[lo]中，先进行++i,再进行比较
        while (MyIntArray[++i] < MyIntArray[lo])
        {
            if (i == hi) break;
        }
        //从hi项开始比较,直到找到小于等于lo项的元素，才停止（除非lo项是此部分数组中最小的，此时i=lo）
        //注意：MyIntArray[lo]<MyIntArray[--j]中，先进行--j,再进行比较
        while (MyIntArray[lo]<MyIntArray[--j])
        {
            if (j == lo) break;
        }

        //如果i >= j，说明i,j重合了,不需要继续循环。此时，i项左边的元素都比lo项小；右边的元素都比lo项大
        if (i >= j) break;
        //如果i和j之间还有元素，说明还没比较完，继续比较
        ExChange(i, j);
    }
    //lo项是分界线元素，把它放到分界线处
    ExChange(lo, j);
    //返回分界线元素的Index
    return j;
}

void AQuicksort::ExChange(int i, int j)
{
    //序号i,j应该在数组范围内
    if (i > MyIntArray.Num() - 1 || j > MyIntArray.Num() - 1) return;
    //互换
    int Tempint = MyIntArray[i];
    MyIntArray[i] = MyIntArray[j];
    MyIntArray[j] = Tempint;
}

void AQuicksort::Sort()
{
    Sort(0, MyIntArray.Num() - 1);
}

void AQuicksort::Sort(int lo, int hi)
{
    if (hi <= lo) return;
    //把此部分数组分为两部分
    int j = Partition(lo, hi);
    //然后这两部分数组作为新的部分数组继续分下去，直到hi <= lo
    Sort(lo, j - 1);
    Sort(j + 1, hi);
}