排序算法（插入排序、shell排序、冒泡排序、选择排序、合并排序、堆排序、快速排序、计数排序、基数排序、桶排序）

排序算法分两种：

1.比较排序，时间复杂度最少达到O(n*lg n)，主要有：插入排序，冒泡排序，选择排序，合并排序，堆排序，快速排序等。

2.非比较排序，时间复杂度可以达到O(n)，主要有：计数排序，基数排序，桶排序等。

输入：n个数<a1,a2,a3.............an>

输出：输入序列的一个重排列<a'1,a'2,a'3........a'n>，使a'1<a'2<a'3<........<a'n

插入排序（有一个已经有序的数据序列，要求在这个已经排好的数据序列中插入一个数，但要求插入后此数据序列仍然有序，这个时候就要用到一种新的排序方法——插入排序法）

c实现：

#include <stdio.h>

#define len 8
void insertSort(int *,int);

int main(int argc,char * argv[])
{
	int arr[len]={5,8,6,7,9,4,3,2};
	insertSort(arr,len);
	for(int i=0;i<len;i++)
		printf("%d ",arr[i]);
	printf("\n");
	return 0;
}

void insertSort(int * arr,int length)
{
	int key;
	for(int i=1;i<length;i++)
	{
 		key=arr[i];
 		int j=i-1;
 		while(j>=0&&arr[j]>key)
 		{
			arr[j+1]=arr[j];
			j--;	 	
 		}
 		arr[j+1]=key;
	}
}

shell排序（插入排序的改进版）

C语言实现：

#include <stdio.h>

void shellSort(int [],int );

int main(int args,char *argv[])
{
	int arr[8]={5,8,6,7,9,4,3,2};
	shellSort(arr,8);
	for(int i=0;i<8;i++)
	{
		printf("%d ",arr[i]);
	}
	printf("\n");
	return 0;	
}

void shellSort(int arr[],int n)
{
	int i,j,step;
	for(step=n/2;step>0;step/=2)
	{
		for(i=0;i<step;i++)
			for(j=step+i;j<n;j+=step)
			{
				int key=arr[j];
				int k=j-step;
				while(k>=0&&arr[k]>key)
				{
					arr[k+step]=arr[k];
					k-=step;	
				}
				arr[k+step]=key;	
			}
	}
}

冒泡排序（　冒泡排序（BubbleSort）的基本概念是：依次比较相邻的两个数，将小数放在前面，大数放在后面。由于在排序过程中总是小数往前放，大数往后放，相当于气泡往上升，所以称作冒泡排序。）

c实现：

#include <stdio.h>

void bubbleSort(int arr[],int n)
{
	int j;
	bool tag=true;
	while(tag)
	{
		tag=false;
		for(j=1;j<n;j++)
		if(arr[j-1]>arr[j])
		{
			int tmp=arr[j];
			arr[j]=arr[j-1];
			arr[j-1]=tmp;
			tag=true;
		}
		n--; 
	}		
}

int main(int args,char * argv[])
{
	int arr[8]={5,8,6,7,9,4,3,2};
	bubbleSort(arr,8);
	for(int i=0;i<8;i++)
		printf("%d ",arr[i]);
	printf("\n");
	return 0;
}

选择排序（每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法。）

c实现：

#include <stdio.h>

void selectSort(int arr[],int n)
{
	int i,j,pos;
	for(i=0;i<n-1;i++)
	{
		pos=i;
		for(j=i+1;j<n;j++)
		if(arr[pos]>arr[j]) pos=j;
		if(pos!=i)
		{
			int tmp=arr[i];
			arr[i]=arr[pos];
			arr[pos]=tmp;
		} 
	}		
}

int main(int args,char * argv[])
{
	int arr[8]={5,8,6,7,9,4,3,2};
	selectSort(arr,8);
	for(int i=0;i<8;i++)
		printf("%d ",arr[i]);
	printf("\n");
	return 0;
}

合并排序（也叫归并排序，它是建立在归并操作上的一种排序算法，要理解归并排序在于理解要排序数列的更新过程，（1和2按有序合并）-----（1，2和3，4按有序合并）-----（1，2，3，4和4,5,6,7按有序合并）---...）

c实现：

#include <stdio.h>

#define MAX 1000

void mergeArray(int [],int ,int,int,int []);
void mergeSort(int [],int,int,int []);

int main(int args,char* argv[])
{
	int arr[8]={5,8,6,7,9,4,3,2};
	int arrtmp[MAX];
	mergeSort(arr,0,8-1,arrtmp);
	for(int i=0;i<8;i++)
		printf("%d ",arr[i]);
	printf("\n");
	return 0;
}

void mergeSort(int arr[],int first,int last,int q[])
{
	if(first<last)
	{
		int mid=(first+last)/2;
		mergeSort(arr,first,mid,q);
		mergeSort(arr,mid+1,last,q);
		mergeArray(arr,first,mid,last,q);
	}
}

void mergeArray(int arr[],int first,int mid,int last,int q[])
{
	int i=first,j=mid+1;
	int m=mid,n=last;
	int k=0;
	while(i<=m && j<=n)
	{
		if(arr[i]<arr[j])
		{
			q[k++]=arr[i++];
		}else{
			q[k++]=arr[j++];
		}
	}
	while(i<=m)
	q[k++]=arr[i++];
	while(j<=n)
	q[k++]=arr[j++];
	for(i=0;i<k;i++)
		arr[first+i]=q[i];//更新数位置是从first开始 
	/*for(int i=0;i<8;i++)
		printf("%d ",arr[i]);
	printf("\n");*/
}

堆排序（堆排序（HeapSort）是一树形选择排序。定义： n个关键字序列Kl，K2，…，Kn称为（Heap），当且仅当该序列满足如下性质（简称为堆性质）： (1)ki<=k(2i）且ki<=k(2i+1)(1≤i≤ n），当然，这是小根堆，大根堆则换成>=号。//k(i）相当于 二叉树 的 非叶 结点，K(2i）则是左孩子，k(2i+1）是右孩子 若将此序列所存储的向量R[1..n]看做是一棵 完全二叉树 的 存储结构 ，则堆实质上是满足如下性质的完全二叉树： 树中任一非叶结点的关键字均不大于（或不小于）其左右孩子（若存在）结点的关键字。关键字序列（10，15，56，25，30，70）和（70，56，30，25，15，10）分别满足堆性质（1）和（2），故它们均是堆。 ）

c实现：

#include <stdio.h>

void maxheapAdjust(int arr[],int i,int n);/*arr待调整的堆数组，i是待调整的数组元素的位置，n数组长度*/
void heapSort(int arr[],int n);
void swap(int *,int *);
int main()
{
	int arr[8]={5,8,6,7,9,4,3,2};
	heapSort(arr,8);
	for(int i=0;i<8;i++)
	{
		printf("%d ",arr[i]);	
	}
	printf("\n");
	return 0;
}
void heapSort(int arr[],int n)
{
	for(int i=n/2-1;i>=0;i--)
	{
		maxheapAdjust(arr,i,n);
	}
	for(int j=n-1;j>=0;j--)
	{
		swap(&arr[0],&arr[j]);
		maxheapAdjust(arr,0,j);
	}
}

void maxheapAdjust(int arr[],int i,int n)
{
	int tmp=arr[i];
	int j=2*i+1;
	while(j<n)
	{
		if(j+1<n && arr[j+1] > arr[j])
		j++;
		if(arr[j]<=tmp)
		break;
		arr[i]=arr[j];
		i=j;
		j=2*i+1;
	}
	arr[i]=tmp;
}

void swap(int *a,int *b)
{
	int tmp=*a;
	*a=*b;
	*b=tmp;
}

快速排序（它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。设要排序的数组是A[0]……A[N-1]，首先任意选取一个数据（通常选用第一个数据）作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一趟快速排序。）

c实现：

#include <stdio.h>

void quickSort(int [],int i,int j);/*第一个参数：要排序数组，第二个参数：基准点元素的下标，第三个参数：区间最后元素的下标 i<j*/

int main()
{
	int arr[8]={5,8,6,7,9,4,3,2};
	quickSort(arr,0,7);
	for(int i=0;i<8;i++)
	{
		printf("%d ",arr[i]);	
	}
	printf("\n");
	return 0;
}

void quickSort(int arr[],int start,int num)
{
	int i=start,j=num;
	int x=arr[i];
	if(i<j)
	{
		while(i<j)
		{
			while(i<j && arr[j]>x) j--;
			if(i<j)
			{
				arr[i++]=arr[j];
			}
			while(i<j && arr[i]<=x) i++;
			if(i<j)
			{
				arr[j--]=arr[i];
			}
		}
		arr[i]=x;
		quickSort(arr,start,i-1);
		quickSort(arr,i+1,num);
	}
}

计数排序

c实现：

基数排序

c实现：

桶排序

c实现：

七种常用的排序方法的关系。

正在更新中....