浅学排序算法

  在计算机科学与数学中，一个排序算法（英语：Sorting algorithm）是一种能将一串资料依照特定排序方式进行排列的一种算法。最常用到的排序方式是数值顺序以及字典顺序。排序算法也用在处理文字资料以及产生人类可读的输出结果。

基本上，排序算法的输出必须遵守下列两个原则：

1. 输出结果为递增序列（递增是针对所需的排序顺序而言）
2. 输出结果是原输入的一种排列或是重组

排序算法介绍

1. 冒泡排序
2. 选择排序
3. 插入排序
4. 快速排序

一、冒泡排序

  冒泡排序又称为泡式排序，是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误则交换两个元素，走访数列的工作是重复的进行直到没有需要交换的，也就是说该数列已经排序完成，这个算法名字的由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端。

1、算法描述

（1）从头开始比较每一对相邻的元素，如果第一个比第二个大，就交换他们的位置。
（2）执行完一轮后，最末尾那个元素就是最大的元素。
（3）忽略之前找到的最大元素，重复执行步骤(1)、(2)，直到元素全部有序。

2、动图演示

二、选择排序

  选择排序是一种简单直观的排序算法。它的工作原理如下：首先在未排序序列中找到最大（小）元素，存放到排序序列的起始位置，然后在从剩余的未排序的元素中据需寻找最大（小）元素，然后放到已排序的序列的末尾，依次类推，知道所有元素均排序完毕。

1、算法描述

（1）将序列中的第一个元素作为起始比较元素，
（2）逐个比较其余元素，从队列中找出最小的元素 然后与第一个元素进行交换
（3）一次循环之后会得到最小的值在最前面
（4）忽略已经找到的元素，然后循环执行2、3步操作

2、动图演示

三、插入排序

  插入排序是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序的数据，在已排序的序列中从后向前扫描，找到响应的位置并插入。插入排序类似于扑克牌的排序 可以根据日常打扑克时的思维去思考。

1、算法描述

（1）从第一个元素开始，默认为第一个元素是已经被排序的
（2）取出下一个元素，在已排序的序列中从后向前扫描
（3）如果该元素大于取出元素，则向后挪动
（4）重复步骤3 直到在已排序好的序列中找到小于或等于取出的元素的位置
（5）将取出的元素插入带该元素的位置
（6）重复步骤 2~5

2、动图演示

四、快速排序

  快速排序，又称分区交换排序，简称快排。在平均状况下，排序n个项目要O(nlogn)次比较，最坏情况下则需要O(n^2)次比较，但这种情况并不常见，事实上，快速排序O(nlogn)通常明显比其他算法更快。
  快速排序使用分治法策略来把一个序列分为较小和较大的2个子序列，然后递归的排序两个子系列。

1、算法描述

（1）从序列中选择一个基准值（pivot），假设每次选择第0个位置的元素作为基准值
（2）利用pivot将序列分割成2个子序列
（3）将随机一个基准值与第0个位置交换 （ 为避免出现最坏的时间复杂度 ）
（4）将小于pivot的元素放到pivot的前面（左侧）
（5）将大于pivot的元素放到pivot的后面（右侧）
（6）将等于pivot的元素放在哪边都可以
（7）对子序列进行1-6操作，直到不能在分割位置（自列元素中只剩下1个元素）。

2、动图演示

五、代码

#include <stdio.h>
#include <stdlib.h>
/*插入排序*/
/*
参数：
arr:原数组
arrsize:数组大小
返回：
ret_arr：排序后的数组
*/
int* Insert_Sort(int* arr,int arrsize)
{
	int i,j,temp=0;
    int* ret_arr=(int*)malloc(arrsize*sizeof(int));
    for(i=0;i<arrsize;i++)
    {
		ret_arr[i]=arr[i];
    }
    //从1到n逐个遍历
    for(i=1;i<arrsize;i++)
    {
		//当未排序的数组元素大于已排序数组最左边元素时
		if(ret_arr[i]<ret_arr[i-1])
        {
			//缓存
			temp=ret_arr[i];
			for(j=i-1;temp<ret_arr[j];j--)
            {
				//交换元素
				ret_arr[j+1]=ret_arr[j];
                ret_arr[j]=temp;
                //移动最左边后退出
                if(j==0)
					break;  
            }
        }
    }
    return ret_arr;
}
/*选择排序*/
/*
参数：
arr:原数组
arrsize:数组大小
返回：
ret_arr：排序后的数组
*/
int* Select_Sort(int* arr,int arrsize)
{
	int i,j,tmp;
    int min_index=0;
    int* ret_arr=(int*)malloc(arrsize*sizeof(int));
    for(i=0;i<arrsize;i++)
    {
		ret_arr[i]=arr[i];
    }
    //从1到n逐个遍历
    for(i=0;i<arrsize;i++)
    {
		min_index=i;
		for(j=i;j<arrsize;j++)
		{
			if(ret_arr[min_index]>ret_arr[j])
				min_index=j; 
		}
		tmp=ret_arr[min_index];
		ret_arr[min_index]=ret_arr[i];
        ret_arr[i]=tmp;
    }
    return ret_arr;
}
/*冒泡排序*/
/*
参数：
arr:原数组
arrsize:数组大小
返回：
ret_arr：排序后的数组
*/
int* Bubb_Sort(int* arr,int arrsize)
{
	int i,j,tmp=0;
    int* ret_arr=(int*)malloc(arrsize*sizeof(int));
    for(i=0;i<arrsize;i++)
    {
		ret_arr[i]=arr[i];
    }
	for(i=0;i<arrsize-1;i++)
    {
		for(j=arrsize-1;j>i+1;j--)
        {
			if(ret_arr[j]<=ret_arr[j-1])
			{
				tmp=ret_arr[j];
                ret_arr[j]=ret_arr[j-1];
                ret_arr[j-1]=tmp;
            }
        }
    }
    return ret_arr;
}
/*快速排序*/
/*
参数：
arr:原数组
arrsize:数组大小
*/
void Quick_Sort(int* arr,int low,int high){
    int i = low;
    int j = high;
    int temp = arr[i];
    if(i >= j) 
		return;
    while(i < j){
        while(i < j && arr[j] >= temp)
        {
            j--;
        }
        arr[i] = arr[j];
        
        while(i < j && arr[i] <= temp)
        {
            i++; 
        }
        arr[j] = arr[i];
    }
    arr[i] = temp;
    Quick_Sort(arr,low,i-1);
    Quick_Sort(arr,i+1,high);
}
/*打印数组各元素*/
/*
参数：
arr:原数组
arrsize:数组大小
*/
void find(int* arr,int arrsize)
{
	printf("sort result:\n");
	int i=0;
	for(i=0;i<arrsize;i++)
    {
		printf("%d ",arr[i]);
    }
    printf("\n");
}
int main()
{
	int Arr[10]={1,16,24,62,41,7,5,4,15,12};
    int ArrSize=10;
    int* Ret_Arr; 
    Ret_Arr=Insert_Sort(Arr,ArrSize);
    printf("Insert_Sort\n");
    find(Ret_Arr,ArrSize);
    Ret_Arr=Select_Sort(Arr,ArrSize);
    printf("Select_Sort\n");
    find(Ret_Arr,ArrSize);
    Ret_Arr=Bubb_Sort(Arr,ArrSize);
    printf("Bubb_Sort\n");
    find(Ret_Arr,ArrSize);
    Quick_Sort(Arr,0,ArrSize-1);
    printf("Quick_Sort\n");
    find(Arr,ArrSize);
	system("pause");
	return 0;
}

打印结果

Insert_Sort
sort result:
1 4 5 7 12 15 16 24 41 62
Select_Sort
sort result:
1 4 5 7 12 15 16 24 41 62
Bubb_Sort
sort result:
1 4 5 7 12 15 16 24 41 62
Quick_Sort
sort result:
1 4 5 7 12 15 16 24 41 62

六、qsort函数介绍

排序是程序员经常碰到的问题，数据结构与算法的教科书上已经有许多标准的排序算法。在每次需要排序的时候，都要按照教科书重写一次代码？C语言早就考虑到了这个问题，已经提前编写好了一个快速排序的库函数，就是qsort。直接调用一下库函数，很简单对吗？试试看，哇，根本不知道怎么调用。
qsort是C标准库<stdlib.h>库中的函数，使用时引入#include <stdlib.h>。

qsort函数的原型描述为：

void qsort( void *base, size_t n_elements, size_t el_size,int (*compare) (void const * , void const * ) )

这都是什么啊？解释一下，一共4个参数。第1个参数指向需要排序的数组，第2个参数指定数组中元素的数目，第3个参数指定每个元素的长度，以字节为单位，第4个参数是一个函数指针。

应用实例

#include <stdio.h>
#include <stdlib.h>
/*打印数组各元素*/
/*
参数：
arr:原数组
arrsize:数组大小
*/
void find(int* arr,int arrsize)
{
	printf("sort result:\n");
	int i=0;
	for(i=0;i<arrsize;i++)
    {
		printf("%d ",arr[i]);
    }
    printf("\n");
}
int compare(const void* _a,const void* _b)
{
	int* a=(int*)_a;
    int* b=(int*)_b;
    return *a-*b;
}
int main()
{
	int Arr[10]={1,16,24,62,41,7,5,4,15,12};
    int Arrsize=10;
    qsort(Arr,sizeof(Arr)/sizeof(Arr[0]),sizeof(Arr[0]),compare);
    find(Arr,Arrsize);
	system("pause");
	return 0;
}

打印结果

sort result:
1 4 5 7 12 15 16 24 41 62