排序算法例子

冒泡排序：

#include 

using namespace std;

//冒泡排序,时间复杂度O(n^2)，稳定，比较次数最少n-1,最多n*(n-1)/2
void Bubble_Sort(int *list,int num)
{
    bool flag = true;

    for(int i=0;(i<=num)&&flag;++i)
    {
        flag = false;

        for(int j=i;jlist[j+1])
            {
                swap(list[j],list[j+1]);
                flag = true;

            }
        }
    }
}


int main()
{
    const int len=5;
    int arrayList[len]={1,3,5,2,4};

    Bubble_Sort2(arrayList,len);


    for(int i=0;i

快速排序

#include 
#include 

using namespace std;

//快速排序，最多比较n*(n-1)/2次，顺序或者逆序时比较次数最多，不稳定
//最坏情况下，时间复杂度为O(n^2)
void Quick_Sort(int *data, int low, int high)
{

    if(low>high)
    {
        //结束递归调用
        return;
    }

    int i = low;
    int j = high;

    int temp = data[low];
    while(i!=j)
    {
        //从右边开始找到小于基准值的数
        while((data[j]>=temp)&&(i

插入排序：

#include 
#include 

using namespace std;

//直接插入排序，时间复杂度O(n^2),稳定
//最少比较n-1次，最多比较n*(n-1)/2次
void Insert_Sort(int *data, int n)
{

    for (int i = 1;i < n;i++)
    {
        int temp = data[i];     //  临时变量赋值为下一个要排序的新元素
        int j = i-1;        // 令下标j为i-1，前i-1个元素已经排好序
        while ((j>=0)&&(temp < data[j]))  // 比较新元素与前i-1个元素大小
        {
            // 若新元素值小于前面排好序的数，前面的数依次后移
            data[j + 1] = data[j];
            j--;       // j前移
        }
        //将第i个值放到对应的位置
        data[j + 1] = temp;
    }
}

int main()
{
    const int len=8;
    int a[len] = {6,4,7,2,9,6,5,8};
    Insert_Sort(a,len);

    for(int i = 0; i < len; i++)
    {
        printf("%d\n",a[i]);
    }
    return 0;
}

选择排序：

#include 
#include 

using namespace std;

//选择排序，不稳定，时间复杂度O(n^2)
//比较次数固定n(n-1)/2次
void Select_Sort(int *data,int num)
{
    for(int i=0;idata[j])
            {
                minIndex=j;
            }
        }
        swap(data[i],data[minIndex]);
    }
}


int main()
{
    const int len=8;
    int a[len] = {6,4,7,2,9,6,5,8};
    Select_Sort(a,len);

    for(int i = 0; i < len; i++)
    {
        printf("%d\n",a[i]);
    }
    return 0;
}

希尔排序：

#include 
#include 

using namespace std;

//希尔排序，时间复杂度O(n^2),不稳定
//最多比较n^1.5次
void Shell_Sort(int *data, int n)
{
    int increment=n/2; //定义初始增量为size/2
    int temp;
    while(increment>0)  // 增量为0代表排序结束
    {
        for(int i=increment;i < n;i++)
        {
            temp=data[i];
            int j=i-increment;
            //增量不为1的插入排序
            while ((temp=0))
            {
                data[j+increment]=data[j];
                j-=increment;   // j按增量前移
            }
            data[j+increment]=temp;
        }
        increment/=2; // 增量变为原来的一半
    }
}


int main()
{
    const int len=8;
    int a[len] = {6,4,7,2,9,6,5,8};
    Shell_Sort(a,len);

    for(int i = 0; i < len; i++)
    {
        printf("%d\n",a[i]);
    }
    return 0;
}

归并排序

#include 
#include 
#include 
using namespace std;

//归并排序的最坏时间复杂度为O(NlogN),稳定
//归并排序辅助函数，用于对左右有序的数组进行合并
void Merge(int* data, int l,int r,int *tempList)
{

    int i=l;//i为临时数组的下标
    int j=l;//j为左部分起始下标
    int mid=(l+r)/2;//中点
    int k=mid+1;//k为右半部分起始下标

    while (j<=mid && k<=r) // 左右两部分下标分别再其范围内时
    {
        if (data[j]