选择排序 ， 插入排序 ， 冒泡排序

选择排序 SelectionSort

代码编写：

#include <stdio.h>

void println(int array[], int len)
//打印给定长度的数组 
{
    int i = 0;   
    for(i=0; i<len; i++)
    {
        printf("%d ", array[i]);
    }   
    printf("\n");
}

void swap(int array[], int i, int j)
//交换数组中两个位置的元素 
{
    int temp = array[i];    
    array[i] = array[j];    
    array[j] = temp;
}

void SelectionSort(int array[], int len) // O(n*n)
//对数组进行选择排序，时间复杂度为O(n^2)
{
    int i = 0;
    int j = 0;
    int k = -1;

    for(i=0; i<len; i++)
    {
        k = i;

        for(j=i+1; j<len; j++)
        {
            if( array[j] < array[k] )
            {
                k = j;
            }
        }       
        swap(array, i, k);
    }
}

int main()
{
    int array[] = {21, 25, 49, 25, 16, 8};
    int len = sizeof(array) / sizeof(*array); 

    println(array, len);  
    SelectionSort(array, len);    
    println(array, len);

    return 0;
}

插入排序 InsertionSort

代码编写：

#include <stdio.h>

void println(int array[], int len)
//打印数组 
{
    int i = 0;    
    for(i=0; i<len; i++)
    {
        printf("%d ", array[i]);
    }    
    printf("\n");
}

void InsertionSort(int array[], int len) // O(n*n)
//插入排序算法，比较的次数少了一点
{
    int i = 0;
    int j = 0;
    int k = -1;
    int temp = -1;

    for(i=1; i<len; i++)
    {
        k = i;
        temp = array[k];

        for(j=i-1; (j>=0) && (array[j]>temp); j--)
        //比temp大就后移一位 
        {
            array[j+1] = array[j];
            k = j;
        }

        array[k] = temp;
    }
}

int main()
{
    int array[] = {21, 25, 49, 25, 16, 8};
    int len = sizeof(array) / sizeof(*array); 

    println(array, len);   
    InertionSort(array, len);   
    println(array, len);

    return 0;
}

冒泡排序 BubbleSort

代码编写：

#include <stdio.h>

void println(int array[], int len)
//打印数组 
{
    int i = 0;  
    for(i=0; i<len; i++)
    {
        printf("%d ", array[i]);
    }   
    printf("\n");
}

void swap(int array[], int i, int j)
//交换两个元素 
{
    int temp = array[i];   
    array[i] = array[j];   
    array[j] = temp;
}

void BubbleSort(int array[], int len) // O(n*n)
//冒泡排序算法 
{
    int i = 0;
    int j = 0;
    int exchange = 1;
    //exchange作用是标志一次循环中是否发生交换，
    //如果没有发生交换，则说明数组已经排好序，无需继续排了 

    for(i=0; (i<len) && exchange; i++)
    {
        exchange = 0;        
        for(j=len-1; j>i; j--)
        {
            if(array[j] < array[j-1])
            {
                swap(array, j, j-1);                
                exchange = 1;
            }
        }
    }
}

int main()
{
    int array[] = {21, 25, 49, 25, 16, 8};
    int len = sizeof(array) / sizeof(*array); 

    println(array, len);  
    BubbleSort(array, len);   
    println(array, len);

    return 0;
}

小结

选择排序，插入排序以及冒泡排序的算法思想简单，且算法的时间复杂度同为O(n2)量级。
这3种排序算法的排序结果都是稳定的。