数据结构-交换排序

1.冒泡排序

---

冒泡排序：重复遍历数据序列，依次比较两个相邻的元素，如果它们的顺序颠倒，就把他们交换过来。

具体方法：（升序）

• 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
• 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
• 针对所有的元素重复以上的步骤，除了最后一个。
• 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

---

我们看一下排序简要过程：

原序列：5 2 8 6 3 9 0

---

上述过程的代码片：
       一共7个元素，第一趟：6次比较；第二趟：5次比较；… ；第六趟：1次比较。n个元素需要比较n-1趟，每一趟都只需比较未排好序的序列，也就是说，需要两层循环。第一层控制的是比较的趟数，共n-1趟；第二层控制的是每趟需要比较的次数。每趟需要比较的次数都是不同的，所以定义tmp记录次数，外层循环更新，tmp也更新。

void BubbleSort(int* a, int n)// 冒泡排序
{
    for (int i = 0; i < n - 1; ++i)   // 控制循环趟数
    {
        int tmp = n - i - 1;          // 记录每趟需要比较的次数
        for (int j = 0; j < tmp; ++j) // 控制比较次数
        {
            if (a[j] > a[j + 1])
            {
                Swap(&a[j], &a[j + 1]);
            }
        }
    }
}

 

总结

稳定性：稳定
时间复杂度：O(N²)
最好情况：O(N)      最坏情况：O(N²)
空间复杂度：O(1)

---

2.快速排序

---

快速排序：任取待排序元素序列中的某个元素作为基准值，按照该基准值将待排序集合分割成两个子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后左右子序列重复该过程，直到所有元素都排列在相应的位置上为止，是分治法的经典体现。

---

快速排序有很多常见的方法，比如： 左右指针法、前后指针法、挖坑法、三数取中法优化、非递归实现。
代码中的函数形参left、right都是数组下标

2.1 左右指针法

从序列的两端下标开始遍历，选定一个基准值（下面的代码选择的是右边元素，先控制左下标。若右边元素为基准值，则先动左下标；若左边元素为基准值，则先动右下标），将小于基准值的元素放到左边序列，大于基准值的元素放到右边序列，最后基准值归位。这只是其中一段序列的定位，需用递归实现。

int _QuickPartSort1(int* a, int left, int right)// 快速排序（左右指针法） 
{
    int key = a[right];    //将序列最后一个元素当做基准值
    int keyindex = right;  //记录基准值的下标
    
    while (left < right)  
    {   //下标控制，左右下标从序列的左右两端向中间比较
        //左边的值小于基准值，则不动，指针向右走
        while (left < right && a[left] <= key)
        {
            ++left;
        }
        //右边的值大于基准值，则不动，指针向左走
        while (left < right && a[right] >= key)
        {
            --right;
        }
        //此时，left下标的值和right下标的值都不符合要求，则交换
        if (left < right)
        {
            Swap(&a[left], &a[right]);
        }
    }
    //其余元素都已归位，最后将基准值写入序列
    Swap(&a[left], &a[keyindex]);
    return left;
}

void QuickSort1(int* a, int left, int right)// 快速排序（左右指针法） 
{
    if (left >= right)
        return;
    int keyindex = _QuickPartSort1(a, left, right); //接收基准值下标
    
    QuickSort1(a, left, keyindex - 1); //递归实现左子序列
    QuickSort1(a, keyindex + 1, right);//递归实现右子序列
}

---

2.2 前后指针法

这块代码不太容易懂，要举个例子试一试
前后指针法：相当于定义一前一后下标prev和cur，当prev的元素大于基准值，且prev!=cur时，交换元素，循环执行，将当前序列大于基准值的元素过滤到右边。

int _QuickPartSort2(int* a, int left, int right)   // 快速排序（前后指针法）
{
    int key = a[right];   //记录基准值
    int prev = left - 1;  //记录当前位置前面的下标
    int cur = left;       //记录当前位置下标
    
    while (cur < right)   //保证下标不越界
    {
        if (a[cur] < key&&(++prev) != cur)
        {   //如果当前元素小于基准值，当prev小于cur时，交换元素
            //此时的cur元素小于基准值，prev元素大于基准值，外层循环执行，将大于基准值的元素过滤到右边
            Swap(&a[cur], &a[prev]);
        }
        ++cur;
    }
    //将prev归位
    ++prev;
    //交换，放入基准值
    Swap(&a[right], &a[prev]);
    return prev;
}

void QuickSort2(int* a, int left, int right)// 快速排序（前后指针法）
{
    if (left >= right)
        return;
    int keyindex = _QuickPartSort2(a, left, right);//接收基准值下标
    
    QuickSort2(a, left, keyindex - 1);  //递归实现左子序列
    QuickSort2(a, keyindex + 1, right); //递归实现右子序列
}

---

2.3 挖坑法

相当于左右指针，先从左边开始遍历，遇到大于基准值的元素，将其挪到右边，这时这个位置成为一个“坑”，等着被覆盖；从右边遍历，遇到小于基准值的元素，将其挪到左边，覆盖左边的“坑”，而自己这个位置成为了下一个“坑”。

int _QuickPartSort3(int* a, int left, int right)// 快速排序（挖坑法）
{
    int key = a[right];  //记录基准值
    while (left < right)
    {
        //left元素小于等于基准值，将左下标右移
        while (left < right&&a[left] <= key)
        {
            ++left;
        }
        a[right] = a[left]; //将大于基准值的元素挪到右边
        
        //right元素大于等于基准值，将右下标左移
        while (left < right&&a[right] >= key)
        {
            --right;
        }
        a[left] = a[right]; //将小于基准值的元素挪到左边
    }
    a[left] = key; //定位基准值
    return left;
}

void QuickSort3(int* a, int left, int right)// 快速排序（挖坑法）
{
    if (left >= right)
        return;
    int keyindex = _QuickPartSort3(a, left, right);//接收基准值下标
    
    QuickSort3(a, left, keyindex - 1);  //递归实现左子序列
    QuickSort3(a, keyindex + 1, right); //递归实现右子序列
}

---

2.4 三数取中法优化

快速排序的平均运行时间是O(NlogN),而最坏的情形时性能为O(N²)。序列有序就是快速排序的最坏情况，假设有N层子序列，那么每一层都是O(N²)，要克服这种最坏情况，可以用三数取中法。
三数取中就是用mid存三个元素中的中间数，返回mid，将mid作为基准值进行排序。适用于对数据量较大的数据进行排序，而对于数据量较小的数据则表现一般。

int GetMidIndex(int* a, int left, int right) // 优化方法：三数取中 
{
    int mid = left + (right - left) / 2; //mid取left和right的平均值
    if (a[left] < a[mid])       //实际上就是返回三个下标所对应的元素中的中间数
    {
        if (a[mid] < a[right])
            return mid;
        else if (a[left] < a[right])
            return right;
        else return left;
    }
    else  // a[left]>a[mid]
    {
        if (a[right] < a[mid])
            return mid;
        else if (a[left] < a[right])
            return left;
        else return right;
    }
}

用三数取中法能够优化上述方法，只需将mid返回值作为序列的基准值进行排序。

eg. 挖坑法 三数取中 优化：

int _QuickPartSort33(int* a, int left, int right)// 快速排序（挖坑法）
{
    int mid = GetMidIndex(a, left, right); //三数取中
    Swap(&a[mid], &a[right]);  //将取到的基准值交换到序列最后
    int key = a[right];
    
    while (left < right)
    {
        while (left < right&&a[left] <= key)
        {
            ++left;
        }
        if (left < right)
        {
            a[right] = a[left];
            right--;
        }
        
        while (left < right&&a[right] >= key)
        {
            --right;
        }
        if (left < right)
        {
            a[left] = a[right];
            left++;
        }
    }
    a[left] = key;
    return left;
}
void QuickSort33(int* a, int left, int right)// 快速排序（挖坑法）
{
    if (left >= right)
        return;
    int keyindex = _QuickPartSort33(a, left, right);
 
    QuickSort33(a, left, keyindex - 1);
    QuickSort33(a, keyindex + 1, right);
}

---

2.5 非递归实现

快速排序的非递归实现需要栈，文末有实现栈的代码。

void QuickSort4(int* a, int left, int right)
{
    Stack s;
    StackInit(&s);
    StackPush(&s, left);
    StackPush(&s, right);

    while (!StackEmpty(&s))
    {
        int end = StackTop(&s);   //right
        StackPop(&s);
        int begin = StackTop(&s); //left
        StackPop(&s);
        int keyindex = _QuickPartSort3(a,  begin, end); //挖坑法，接收基准值下标
        
        //[begin,keyindex-1] key [keyindex+1,end]
        //保存左子序列
        if (begin < keyindex - 1)
        {
            StackPush(&s, begin);
            StackPush(&s, keyindex - 1);
        }
        //保存右子序列
        if (keyindex + 1 < end)
        {
            StackPush(&s, keyindex + 1);
            StackPush(&s, end);
        }
    }
}

---

总结

快速排序整体的综合性能和使用场景都是比较好的。
稳定性：不稳定
时间复杂度：O(NlogN)
空间复杂度：O(logN)

---

实现栈：

#include<assert.h>
#include<stdio.h>
#include<malloc.h>
#include<stdbool.h>

typedef int STDataType;
struct Stack
{
    STDataType* _array;
    size_t _top;
    size_t _capacity;
};

typedef struct Stack Stack;

void StackInit(Stack* ps);
void StackDestory(Stack* ps);
void StackPush(Stack* ps,STDataType x);
void StackPop(Stack* ps);
STDataType StackTop(Stack* ps);
size_t StackSize(Stack* ps);
bool StackEmpty(Stack* ps);

void StackInit(Stack* ps)
{
    assert(ps);
    ps->_array = NULL;
    ps->_top = 0;
    ps->_capacity = 0;
}

void StackDestory(Stack* ps)
{
    assert(ps);
    if (ps->_array != NULL)
    {
        free(ps->_array);
        ps->_array = NULL;
        ps->_capacity = ps->_top = 0;
    }
}

void StackPush(Stack* ps, STDataType x)
{
    assert(ps);
    if (ps->_top == ps->_capacity)
    {
        size_t newcapacity = ps->_capacity == 0 ? 2 : ps->_capacity * 2;
        ps->_array = (STDataType*)realloc(ps->_array, newcapacity * sizeof(STDataType));
        ps->_capacity = newcapacity;
    }

    ps->_array[ps->_top] = x;
    ps->_top++;
}

void StackPop(Stack* ps)
{
    assert(ps && ps->_top > 0);
    --ps->_top;
}

STDataType StackTop(Stack* ps)
{
    assert(ps && ps->_top > 0);
    return ps->_array[ps->_top - 1];
}

size_t StackSize(Stack* ps)
{
    assert(ps);
    return ps->_top;
}

bool StackEmpty(Stack* ps)
{
    assert(ps);
    return ps->_top == 0;
}
// 测试
void TestStack()
{
    Stack s;
    StackInit(&s);
    StackPush(&s, 1);
    StackPush(&s, 2);
    StackPush(&s, 3);
    StackPush(&s, 4);
    while (!StackEmpty(&s))
    {
        printf("%d ", StackTop(&s));
        StackPop(&s);
    }
    printf("\n");
    StackDestory(&s);
}