常用的排序算法

1.插入排序

插入排序的思想就是将不符合排序条件的元素依次后移，并在符合条件处插入要排序的数据。

void insert_sort(int* a,int len)

{
int i = 0;
int j = 0;
for(i=1;i<len;i++)
{
int temp = a[i];
for(j=i-1;j>=0 && a[j] > temp;j--)
a[j+1]=a[j];
a[j+1] = temp;
}

}

2.shell排序

shell排序的思想就是先将要排序的数组用一个较大的增量去分组，再对每个分组进行插入排序，这样刚开始时分组数较多，每组元素个数较少，但随着分组的增量逐渐减小，每组中的数据量逐渐增多，但已接近有序，所以效率要比插入排序要高。

void shell_sort(int* a,int len)

{
    int h = len/2;
    for(;h > 0;h/=2)
    {
        int i = h;
        for(;i<len;i++)
        {
            int j = i-h;
            int temp = a[i]; 
            for(;j>=0 && temp < a[j];j-=h)
                a[j+h]= a[j];
            a[j+h]= temp;
        }
    }

}

3.冒泡排序

冒泡排序的思想就是用当前的值和所有的值进行比较，如果不满足条件就进行交换，直到选出最合适的值为止。

void bubble_sort(int a[],int len)

{
    int i = 0;
    for(;i< len-1 ;i++)
    {
        int j = i+1;
        for(;j<len;j++)
        {
            if(a[i] > a[j])
            {
                a[i] = a[i]+a[j];
                a[j] = a[i]-a[j];
                a[i] = a[i]-a[j];
            }
        }
    }

}

4.选择排序

选择排序的思想就是用一个变量记录当前所有数据中最符合条件的索引值并进行交换。

void select_sort(int* a,int len)

{
    int i =0;
    for(;i<len-1;i++)
    {
        int min_index = i;
        int min_value = a[i];
        int j = i+1;
        for(;j<len;j++)
        {
            if(a[min_index] > a[j])
                min_index = j;
        }
        a[i] = a[min_index];
        a[min_index] = min_value;
    }

}

5.快速排序

快速排序的思想就是选出一个基值作为分界线，把小于该基值的放在左边，大于该基值的放于右边，依此递归。

void quick_sort(int* a,int left,int right)

{
    if(left < right)
    {
        int pivot = a[left];
        int i = left;
        int j = right;
        while(i<j)
        {
            while(i < j && a[j] > pivot)
                j--;
            if(i < j)
                a[i++] = a[j];
            while(i < j && a[i] < pivot)
                i++;
            if(i < j)
                a[j--] = a[i];
        }
        a[i] = pivot;
        quick_sort(a,left,i-1);
        quick_sort(a,i+1,right); 
    }

}

6.归并排序

归并排序的思想就是将数据分组排序，刚开始分组数较多，但每组元素较少，随着递归的深入，分组越来越少，要排序的元素越来越多，但已接近有序。

static void merge_sort_2(int* a,int* temp,int left,int middle,int right)

{
    int l_start = left;
    int r_end = right;
    int l_end = middle;
    int r_start = middle+1;
    int temp_index = left;
    int len = right - left + 1;
    while(l_start <= l_end && r_start <= r_end)
    {
        if(a[l_start] >= a[r_start])
            temp[temp_index++] = a[r_start++];
        else
            temp[temp_index++] = a[l_start++];
    }
    while(l_start <= l_end)
        temp[temp_index++] = a[l_start++];
    while(r_start <= r_end)
        temp[temp_index++] = a[r_start++];
    for(temp_index=temp_index-1;temp_index >= left;temp_index--)
        a[temp_index] = temp[temp_index];
}


static void merge_sort_1(int*a,int* temp,int left,int right)
{
    if(left < right)
    {
        int middle = (left+right)/2;
        merge_sort_1(a,temp,left,middle);
        merge_sort_1(a,temp,middle+1,right);
        merge_sort_2(a,temp,left,middle,right);
    }
}
void merge_sort(int* a,int left,int right)
{
    int* temp = (int*)malloc(sizeof(int)*(right-left+1));
    if(temp == NULL)
    {
        printf("can't malloc memory\n");
        return;
    }
    merge_sort_1(a,temp,left,right);
    free(temp);
}