排序算法————冒泡排序、快速排序

一、冒泡排序：

1、算法思想：
冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

2、算法步骤：

1、比较相邻的元素。如果第一个比第二个大，就交换它们两个；
2、对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数，则最后的元素有序；
3、针对所有的元素重复以上的步骤，除了已有序的元素；
4、重复步骤1~3，直到排序完成。

3、代码实现：

void BubbleSoet(int* arr, int len)
{
    for (int j = 0; j < len - 1; j++)
    {
        for (int i = 0; i < len - j - 1; i++)
        {
            if (arr[i] > arr[i + 1])
            {
                swap(&arr[i],&arr[i+1]);
            }
        }
    }
}

二、快速排序：

1、算法思想：
快速排序是对冒泡排序的一种改进，通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

2、算法步骤：

1、从数列中挑出一个元素，做为 “基准”（一般去第一个元素）；
2、从最后一个元素开始找往前找到比基准小的数据，放在前面空出的位置；
3、从基准后一个元素开始往后找到比基准大的数据，放在后面空出的位置；
4、当整个序列被找完一趟后，将基准放在中间空余位置；
5、重复1-4步，使序列的左右两边全部有序。

图示：

3、代码实现：
递归：

int OneProcess(int *arr,int head, int end)//挖坑法一次排序
{
    int L = head;
    int R = end;
    int tmp = arr[L];

    while (L < R)
    {
        while (L < R && arr[R] >= tmp)
        {
            R--;
        }
        if (L < R)//防止循环R--之后小于L;
        {
            arr[L] = arr[R];
            L++;
        }
  
        while (L < R && arr[L] <= tmp)
        {
            L++;
        }
        if (L < R)//防止循环R--之后小于L;
        {
            arr[R] = arr[L];
            R--;
        }
       
    }
    arr[L] = tmp;
    return L;
}

void QuickSort1(int *arr,int head,int end)//分治法递归实现
{
    if (head < end)
    {
        int val = OneProcess(arr, head, end);
        if (val - 1 - head > 1)
        {
            QuickSort1(arr, head, val - 1);//递归实现左半边
        }

        if (end - val - 1 > 1)
        {
            QuickSort1(arr, val + 1, end);//递归实现右半边
        }
    }
}

void FastSort(int* arr, int len)
{
    int head = 0;
    int end = len - 1;
    QuickSort1(arr, head, end);
}

非递归：

void QuickSort2(int *arr, int head,int end)//非递归实现
{
    Stack st;
    int size = (int)(log10((double)(end-head+1))/log10((double)2)+1);
    //初始化栈
    st.data = (int *)malloc(sizeof(int)* 2 * size);
    assert(st.data != NULL);
    st.top = 0;

    st.data[st.top++] = head;
    st.data[st.top++] = end;

    while (st.top != 0)
    {
        end = st.data[-- st.top];
        head = st.data[--st.top];
        int val = OneProcess(arr,head,end);
        if (val - 1 - head > 1)//左边
        {
            st.data[st.top++] = head;
            st.data[st.top++] = val - 1;
        }
        if (end - val - 1 > 1)//右边
        {
            st.data[st.top++] = val + 1;
            st.data[st.top++] = end;
        }
    }

    free(st.data);
}

void FastSort(int* arr, int len)
{
    int head = 0;
    int end = len - 1;
    QuickSort2(arr, head, end);
}

4、算法分析：
通常，快速排序被认为是，在所有同数量级(O(n*long n) )的排序方法中，其平均性能最好，但是，第待排序列有序或者基本有序时，快速排序将蜕化为冒泡排序，其时间复杂度为O(n2)。