（非降序）冒泡 插入 快排 归并 选择

算法复杂度的对比 http://wenku.baidu.com/view/d923bd1a6bd97f192279e929.html

冒泡排序 http://zh.wikipedia.org/wiki/%E5%86%92%E6%B3%A1%E6%8E%92%E5%BA%8F
口语化原理：从前往后扫描并对相邻的两个元素做比较，不符合要求的顺序则交换两个位置的值（每遍历一次都把最大或最小的元素冒泡到最后位置上），直到某次遍历过程发现全部都符合要求（没有交换发生）
最差时间复杂度：O(n^2)
最优时间复杂度：O(n)
平均时间复杂度：O(n^2)
空间复杂度：O(n) total, O(1) auxiliary （维基）
稳定排序：是
适用性：适合数据量比较小的排序

#include <stdio.h>  
#include <stdlib.h>  
  
void bubble_sort( int arr[], int sum)  
{  
        if ( sum < 2 )   
                return;  
        for ( int right = sum-1; right > 1; --right ) { //gcc下编译需要加上--std=c99，否则会因为for的初始化部分定义变量而报错  
                int goon = 0;
                for ( int i = 0; i < right; ++i ) {
                        if ( arr[i] > arr[i+1] ) {
                                int tmp = arr[i];
                                arr[i] = arr[i+1];
                                arr[i+1] = tmp;
                                goon = 1;
                        }
                }  
                if (goon == 0)
                        break;
        }  
}  
  
int main(int argc, char** argv)  
{  
        int sum = 0;  
        printf("input array sum:");  
        scanf("%d", &sum);  
        int* myArray = (int*)malloc(sizeof(int)*sum);  
        int tmp = 0;  
        for ( int i = 0; i < sum; ++i ) {  
                printf("element:");  
                scanf("%d",&tmp);  
                myArray[i] = tmp;  
        }  
  
        bubble_sort(myArray,sum);  
        for ( int i = 0; i < sum; ++i )  
                printf("%d\t",myArray[i]);  
        printf("\n");  
        free(myArray);  
 }

插入排序 http://zh.wikipedia.org/wiki/%E6%8F%92%E5%85%A5%E6%8E%92%E5%BA%8F
口语化原理：从前往后依次找到每个元素在它前面的有序队列中的位置，并进行插入
最差时间复杂度：O(n^2)
最优时间复杂度：O(n)
平均时间复杂度：O(n^2)
空间复杂度：0(1)
稳定排序：是
适用性：适合数据量比较小的排序

#include <stdio.h>  
#include <stdlib.h>  
  
void insert_sort( int arr[], int sum)
{
        for (int i = 1; i < sum; ++i) {
                int tmp = arr[i];
                //个人觉得这里找到合适的插入位置后直接对需要右移的数据进行memmove会更高效
                int j = i;
                for ( ; (j>0) && (tmp<arr[j-1]); j--)
                        arr[j] = arr[j-1];
                arr[j] = tmp;
        }
}
 
int main(int argc, char** argv)  
{  
        int sum = 0;  
        printf("input array sum:");  
        scanf("%d", &sum);  
        int* myArray = (int*)malloc(sizeof(int)*sum);  
        int tmp = 0;  
        for ( int i = 0; i < sum; ++i ) {  
                printf("element:");  
                scanf("%d",&tmp);  
                myArray[i] = tmp;  
        }  
  
        insert_sort(myArray,sum);  
        for ( int i = 0; i < sum; ++i )  
                printf("%d\t",myArray[i]);  
        printf("\n");  
        free(myArray);  
}

快速排序 http://zh.wikipedia.org/wiki/%E5%BF%AB%E9%80%9F%E6%8E%92%E5%BA%8F
口语化原理：以第一个元素为基准，把比它小的放左边，比它大的放右边，它放中间。对左边和右边的小序列重复执行这个操作。分治法的一种。下面是原地排序的实现版本，原地排序版本寻找基准元素的位置和移动比其大(小)的方法很奇特。
最差时间复杂度：O(n^2)
最优时间复杂度：O(nlogn)
平均时间复杂度：O(nlogn)
空间复杂度：据实现方式而定
稳定排序：否
适用性：

#include <stdio.h>  
#include <stdlib.h>  
  
void quick_sort( int myArray[], int left, int right )  
{  
        if ( left == right )  
                return;  
  
        int init_left = left;  
        int init_right = right;  
        int middleElement = myArray[left];  
        while ( left < right ) {  
                while ( (myArray[right]>=middleElement) && (right>left) ) right--;  
                if ( right != left ) {  
                        myArray[left] = myArray[right];  
                        left++;  
                }  
                while ( (myArray[left]<=middleElement) && (left<right) ) left++;  
                if ( left != right ) {  
                        myArray[right] = myArray[left];  
                        right--;  
                }  
        }  
        myArray[left] = middleElement;  
        if ( init_left != left )  
                quick_sort(myArray, init_left, left-1);  
        if ( left != init_right )  
                quick_sort(myArray, left+1, init_right);  
}  
  
int main( int argc, char** argv)  
{  
        int sum = 0;  
        printf("input array sum:");  
        scanf("%d",&sum);  
        int* myArray = (int*)malloc(sizeof(int)*sum);  
        int tmp = 0;  
        for ( int i = 0; i < sum; ++i ) {  
                printf("element:");  
                scanf("%d",&tmp);  
                myArray[i] = tmp;  
        }  
        quick_sort(myArray, 0, sum-1);  
        for ( int i = 0; i < sum; ++i )  
                printf("%d\t",myArray[i]);  
        printf("\n");  
        free(myArray);  
}

归并排序 http://zh.wikipedia.org/zh-cn/%E5%BD%92%E5%B9%B6%E6%8E%92%E5%BA%8F
口语化原理：把两个已经有序的序列合并成一个序列。分治法的一种。
最差时间复杂度：Θ(nlogn)
最优时间复杂度：Θ(n)
平均时间复杂度：Θ(nlogn)
空间复杂度：Θ(n)
稳定排序：是
适用性：需要额外的跟原序列大小相同的空间，如果数据量大、内存吃紧是不能用这种方法的

#include <stdio.h>  
#include <stdlib.h>  
  
void merge_sort(int extArray[], int myArray[], int left, int right)  
{  
        //printf("left=%d right=%d \n", left, right);  
        if ( left == right )  
                return;  
        int mid = (right-left+1)/2 - 1 + left;  
        if ( left < mid )  
                merge_sort(extArray, myArray, left, mid);  
        if ( mid+1 < right )  
                merge_sort(extArray, myArray, mid+1, right);  
        int i = left;  
        int j = mid+1;  
        int k = left;  
        //printf("i=%d j=%d k=%d\n",i,j,k);  
        while ( (i<=mid) && (j<=right) ) {  
                if ( myArray[i] < myArray[j] ) {  
                        extArray[k++] = myArray[i++];  
                } else if ( myArray[i] == myArray[j] ) {  
                        extArray[k++] = myArray[i++];  
                        extArray[k++] = myArray[j++];  
                } else {  
                        extArray[k++] = myArray[j++];  
                }  
        }  
        if ( i > mid ) {  
                while ( j <= right )  
                        extArray[k++] = myArray[j++];  
        }else if ( j > right ) {  
                while ( i <= mid )  
                        extArray[k++] = myArray[i++];  
        }  
        for ( int i = left; i <= right; ++i )  
                myArray[i] = extArray[i];  
}  
  
int main( int argc, char** argv)  
{  
        int sum = 0;  
        printf("input array sum:");  
        scanf("%d",&sum);  
        int* myArray = (int*)malloc(sizeof(int)*sum);  
        int tmp = 0;  
        for ( int i = 0; i < sum; ++i ) {  
                printf("element:");  
                scanf("%d",&tmp);  
                myArray[i] = tmp;  
        }  
        int* extArray = (int*)malloc(sizeof(int)*sum);  
        merge_sort(extArray, myArray, 0, sum-1);  
        for ( int i = 0; i < sum; ++i )  
                printf("%d\t",myArray[i]);  
        printf("\n");  
        free(myArray);  
        free(extArray);  
}

选择排序 http://zh.wikipedia.org/wiki/%E9%80%89%E6%8B%A9%E6%8E%92%E5%BA%8F
口语化原理：
最差时间复杂度：O(n^2)
最优时间复杂度：O(n^2)
平均时间复杂度：O(n^2)
空间复杂度：О(n) total, O(1) auxiliary (维基)
稳定排序：否
适用性：

#include <stdio.h>  
#include <stdlib.h>  
  
void select_sort( int myArray[], int sum )  
{ 
        for (int i = sum-1; i > 0; --i) {
                int max = 0;
                for (int j = 1; j <= i; ++j) {
                        if (myArray[j] > myArray[max])
                                max = j;
                }
                int tmp = myArray[i];
                myArray[i] = myArray[max];
                myArray[max] = tmp;
        }
}  
  
int main( int argc, char** argv)  
{  
        int sum = 0;  
        printf("input array sum:");  
        scanf("%d",&sum);  
        int* myArray = (int*)malloc(sizeof(int)*sum);  
        int tmp = 0;  
        for ( int i = 0; i < sum; ++i ) {  
                printf("element:");  
                scanf("%d",&tmp);  
                myArray[i] = tmp;  
        }  
        select_sort(myArray, sum);  
        for ( int i = 0; i < sum; ++i )  
                printf("%d\t",myArray[i]);  
        printf("\n");  
        free(myArray);  
}