几种常见的排序

一、插入排序

思想：将数组中的每一个数字与其前面的数字进行比较，当该数字大于前面的数字，则不处理，当其小于前面的数字将后面的数字，则将数据移位，将其插入。

给每个数字在其前面所有的数字之中找到合适的位置，并插入。插入排序中数据待插入的前面序列的数据是有序的。

void Sort(int *arr,int len)//插入排序
{
	int i,j;
	for( i = 1;i<len;i++)
	{
		int tmp = arr[i];  //需要比较的数据
		for( j = i-1;j>=0;j--)//与其前面的所有数据进行比较
		{
			if(arr[j]<= tmp) //大于前面的数，不移动
			{
 				break;
			}
			else                  //小于前面的数，将移动数据给tmp空出位置
			{
				arr[j+1] = arr[j];
			}
		}
				arr[j+1] =tmp;//放入tmp
	}
}

二、冒泡排序

思想：对数组进行循环遍历，每次把最大的数字沉入最后，相邻两个数字之间进行比较，如果前面的数字大于后面的数字，将两个数字进行交换，继续比较，就可以使最大的数字保存于最后面。

void Sort(int *arr,int len)
{
	for(int i = 0;i<len;i++)  
	{
		for(int j = 0;j<len-1-i;j++)//每个数，往后沉一次,最后一个位置为最大的数
		{
			if(arr[j] >arr[j+1])
			{
				int tmp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = tmp;
			}
		}
	}
}

三、快速排序

思想：快速排序是将一组数据按照一个基准进行划分，比基准小的全部在基准的前面，比基准大的全部在基准的后面，这就是快排的一次划分。快排的基准一般是第一个数来充当，一次划分之后基准就在正确的位置上，之后对基准的前面和后面的数据分别进行处理。

快排有两种实现方式：递归和非递归。递归快排的空间消耗比较大，递归没有全部完成就不会返回，非递归的实现是依靠栈来实现的。

首先来看一下递归实现

int SortPart(int* arr,int low,int high) //快排的一次划分
{
	int tmp = arr[low];
	while(low < high)
	{
		while((low<high )&& (arr[high]>=tmp))
		{
			high--;
		}
		if(low == high)
		{
			break;
		}
		else
		{
			arr[low] = arr[high];
		}
		while((low<high )&& (arr[low]<tmp))
		{
			low++;
		}
		if(low == high)
		{
			break;
		}
		else
		{
			arr[high] = arr[low];
		}
	}
	arr[low] = tmp;
	return low;
}
void Sortonce(int* arr,int low,int high) //多次递归的进行划分
{
	int par = SortPart( arr,low,high);
	if(low+1<par)
	{
		 Sortonce(arr,low,par-1);
	}
	if(par<high-1)
	{
		Sortonce(arr,par+1,high);
	}
}
void Sort(int *arr,int len)
{
	Sortonce(arr,0,len-1);
}


int main()
{
	int arr[] = {5,8,6,3,89,56,85,26,0,97,4,9,2,5,73,66};
	int len = sizeof(arr)/sizeof(arr[0]);
	Sort(arr,len);
	for(int i = 0;i<len;i++)
	{
		printf("%d ",arr[i]);
	}
	return 0;
}

非递归实现，依靠栈的特性，根据 low 与 high 的值，进行一次划分，将数据保存于栈中，栈中存在一次划分后的两段数据，low  par-1与par+1  high。进入while循环，先出栈进行新区域的再次划分，将返回的两段数据进行入栈。

//快排的非递归使用栈进行排序

void Quick_sort(int *arr,int len)

{

    int size = (int)(log10((double)len))/(log10((double)2));

    int *stack = (int *)malloc(size*sizeof(int)*2);

    int top = 0;

    int low = 0;

    int high = len - 1;

    int par = patition(arr,low,high);

    if(low + 1 < par)

    {                                      //把low、high的数据压入栈

        stack[top++] = low;

        stack[top++] = par - 1;

    } 

    if(high - 1 > par)

    {

        stack[top++] = par + 1;

        stack[top++] = high;

    }

    while(top > 0)

    {

        high = stack[top--];                 //出栈

        low = stack[top--];

        par = patition(arr,low,high);

        if(low + 1 < par)

        {

            stack[top++] = low;

            stack[top++] = par - 1;

        } 

        if(high - 1 > par)

        {

            stack[top++] = par + 1;

            stack[top++] = high;

        }

 

    }

}