直接插入排序，冒泡排序，快速排序，选择排序的实现

题目描述：

排序实现，要求下面代码。

基础排序功能要求能独立实现。
理解算法思想+编码实现。

根据主函数内容实现功能。

int main()
{
    //直接插入排序
    int iArray[MAX_SIZE]= {49,38,65,97,76,13,27,49};
    insertSort(iArray, MAX_SIZE);
    printArray(iArray, MAX_SIZE);

    //冒泡排序
    int jArray[MAX_SIZE]= {49,38,65,97,76,13,27,49};
    bubbleSort(jArray, MAX_SIZE);
    printArray(jArray, MAX_SIZE);

    //快速排序
    int kArray[MAX_SIZE]= {49,38,65,97,76,13,27,49};
    quickSort(kArray, 0, MAX_SIZE-1);
    printArray(kArray, MAX_SIZE);

    //选择排序
    int mArray[MAX_SIZE]= {49,38,65,97,76,13,27,49};
    bubbleSort(mArray, MAX_SIZE);
    printArray(mArray, MAX_SIZE);

    return 0;
}

代码实现：

#include <iostream>

using namespace std;

const int MAX_SIZE = 8;

//直接插入排序
void insertSort(int* arry, int n)
{
    int i, j, temp;
    for(i = 1; i < n; i++)
    {
        if(arry[i] < arry[i-1]) //反序时
        {
            temp = arry[i];
            j = i-1;
            //找到arry[i]的插入位置
            do
            {
                //将记录大于arry[i]的记录后移
                arry[j+1] = arry[j];
                j--;
            }while(j>=0 && arry[j] > temp);
            //在j+1处插入arry[i]
            arry[j+1] = temp;
        }
    }
}

//冒泡排序
void bubbleSort(int* arry, int n)
{
    int i, j;
    bool exchange;
    for(i = 0; i < n-1; i++)
    {
        exchange = false;       //一趟前exchange置为假
        for(j = n-1; j>i; j--)  //归为arry[i],循环n-i-1次
        {
            if(arry[j] < arry[j-1]) //相邻两个元素反序时
            {
                swap(arry[j], arry[j-1]);   //将arry[j]和arry[j-1]两个元素交换
                exchange = true;    //一旦有交换exchange置为真
            }
        }
        if(!exchange)   //本趟没有发生交换，中途结束算法
        {
            return ;
        }
    }

}

//快速排序
//查找数轴元素
int partition(int* arry, int s, int t)//一趟划分
{
    int i = s;
    int j = t;
    int temp = arry[i];     //以arry[i]为基准
    while( i < j)       //从两端交替向中间扫描，直至i=j为止
    {
        while(j > i && arry[j] >= temp)
        {
            j--;         //从右向左扫描，找到一个小于temp的arry[j]
        }
        arry[i] = arry[j];  //找到这样的arry[j],放入arry[i]处
        while(i < j && arry[i] <= temp)
        {
            i++;        //从左向右扫描，找到一个大于temp的arry[i]
        }
        arry[j] = arry[i];//找到这样的arry[i],放入arry[j]处

    }
    arry[i] = temp;
    return i;
}
void quickSort(int* arry, int s, int t)
{
    int i;
    if(s < t)   //区间内至少存在两个元素的情况
    {
        i = partition(arry, s, t);
        quickSort(arry, s, i-1);    //对左区间递归排序
        quickSort(arry, i+1, t);    //对右区间递归排序
    }
}

//选择排序
void selectSort(int* arry, int n)
{
    int i, j, k;
    for(i = 0; i < n-1; i++)    //做第i趟的排序
    {
        k = i;
        for(j = i+1; j < n; j++)    //在当前无序区arry[i...n-1]中选key最小的arry[k]
        {
            if(arry[j] < arry[k])
            {
                k = j;              //k记下目前找到的最小关键字所在的位置
            }
        }
        if(k != i)                   //arry[i]和arry[k]两个元素交换
        {
            swap(arry[i], arry[k]);
        }
    }

}

//输出
void printArray(int* arry, int n)
{
    for(int i = 0; i < n; i++)
    {
        cout<<arry[i]<<" ";
    }
    cout<<endl;

}

int main()
{
     //直接插入排序
    int iArray[MAX_SIZE]= {49,38,65,97,76,13,27,49};
    insertSort(iArray, MAX_SIZE);
    printArray(iArray, MAX_SIZE);

    //冒泡排序
    int jArray[MAX_SIZE]= {49,38,65,97,76,13,27,49};
    bubbleSort(jArray, MAX_SIZE);
    printArray(jArray, MAX_SIZE);

    //快速排序
    int kArray[MAX_SIZE]= {49,38,65,97,76,13,27,49};
    quickSort(kArray, 0, MAX_SIZE-1);
    printArray(kArray, MAX_SIZE);

    //选择排序
    int mArray[MAX_SIZE]= {49,38,65,97,76,13,27,49};
    selectSort(mArray, MAX_SIZE);
    printArray(mArray, MAX_SIZE);

    return 0;
}

运行结果