数据结构与算法分析(c语言)--排序（二）

参考《数据结构与算法分析-c语言描述》一书。

1、快速排序

快速排序的基本思想如下图所示，它选择第一个元素作为主元，它同样可以按照下面提到的算法导论中将数组分成了4个不同的部分，但是这里其实有更好的解释方法。首先，它每次都是选择第一个元素都为主元，这个回合就是要确定主元的位置；然后，有两个指针，一个leftmark指向主元的后面一个位置，另一个rightmark指向要排序的数组最后一个元素；接着，两个指针分别向中间移动，leftmark遇到比主元大的元素停止，rightmark遇到比主元小的元素停止，如果此时leftmark

快速排序

利用递归的思想，快速排序的实现如下：

#include 
#include 

int partition(int list[],int first,int last)
{
    int left = first+1;
    int right = last;
    int pivot_value = list[first];
    bool done = false;
    int tmp;
    while(!done)
    {
        while(left <= right && list[left] <= pivot_value)
            left++;
        while(left <= right && list[right] >= pivot_value)
            right--;
        if (right < left)
            done = true;
        else
        {
            tmp = list[left];
            list[left] = list[right];
            list[right] = tmp;
        }
    }
    tmp = list[right];
    list[right] = list[first];
    list[first] = tmp;
    return right;
}

void quick_sort(int list[],int first,int last)
{
    if(first < last)
    {
        int split_point = partition(list,first,last);
        quick_sort(list,first,split_point-1);
        quick_sort(list,split_point+1,last);
    }   
}

int main()
{
    int list[6] = {34,8,64,51,32,21};
    int N = 6,i;
    quick_sort(list,0,N-1);
    for (i = 0;i< N ;i++)
    {
        printf("%3d",list[i]);
    }

}

快速排序的时间复杂度是o（nlogn），由于在移动指针的时候，特别是左指针，后移的条件是小于等于，这就导致了与数组最开始的元素相等的元素将有可能在一次快速排序之后排到数组最开始元素的前面，例如3，3，5，2，4，第一次排序的结果是2，3，3，5，4，两个3的相对位置改变，所以快速排序不是稳定的排序算法。

2、冒泡排序

冒泡排序的基本思想是每个回合都从第一个元素开始和它后面的元素比较，如果比它后面的元素更大的话就交换，一直重复，直到这个元素到了它能到达的位置。每次遍历都将剩下的元素中最大的那个放到了序列的“最后”(除去了前面已经排好的那些元素)。注意检测是否已经完成了排序。

冒泡排序g

代码实现如下：

#include 
#include 


void bubble_sort(int list[],int N)
{   
    int i,j,temp;
    bool change=false;
    for(i=N;i>=1;i--)
    {
        for(j=0;j list[j+1])
            {
                temp = list[j+1];
                list[j+1] = list[j];
                list[j] = temp;
                change=true;
            }
        }
        if(!change)
        {
            break;
        }
    }
}

int main()
{
    int list[6] = {34,8,64,51,32,21};
    int N = 6,i;
    bubble_sort(list,N-1);
    for (i = 0;i< N ;i++)
    {
        printf("%3d",list[i]);
    }

}

很明显的，冒泡排序的时间复杂度是O（n^2），由于只有前一个元素大于后一个元素，两个元素的相对位置才会交换，而相等时不会交换，所以冒泡排序是稳定的排序算法。

3、选择排序

选择排序的基本思想是每个回合都选择出剩下的元素中最大的那个，选择的方法是首先默认第一元素是最大的，如果后面的元素比它大的话，那就更新剩下的最大的元素值，找到剩下元素中最大的之后将它放入到合适的位置就行了。和冒泡排序类似，只是找剩下的元素中最大的方式不同而已。

选择排序

代码实现如下：

#include 
#include 


void selection_sort(int list[],int N)
{   
    int i,j,temp,max;
    for(i=N;i>0;i--)
    {
        max = 0;
        for(j=1;j<=i;j++)
        {
            if(list[j] > list[max]){
                max = j;
            }
            if (max!=i)
            {
                temp = list[max];
                list[max] = list[i];
                list[i] = temp;
            }
        }
    }
}

int main()
{
    int list[6] = {34,8,64,51,32,21};
    int N = 6,i;
    selection_sort(list,N-1);
    for (i = 0;i< N ;i++)
    {
        printf("%3d",list[i]);
    }

}

显然，选择排序的时间复杂度也是O（n^2），选择排序也是不稳定的。

如果你喜欢我写的文章，可以帮忙给小编点个赞或者加个关注，我一定会互粉的！
如果大家对数据结构感兴趣，欢迎跟小编进行交流，小编微信为sxw2251，加我要写好备注哟！：

我的微信