各种排序算法的实现

首先定义个模版函数来计算数组长度：

//获取数组的长度
template <class T>
int getlenth(T & arry)
{
	return (sizeof(arry)/sizeof(arry[0]));
}

     选择排序、快速排序、希尔排序、堆排序不是稳定的排序算法，

冒泡排序、插入排序、归并排序和基数排序是稳定的排序算法。

冒泡法：  
这是最原始，也是众所周知的最慢的算法了。他的名字的由来因为它的工作看来象是冒泡：  复杂度为O(n*n)。当数据为正序，将不会有交换。复杂度为O(0)。

直接插入排序：O(n*n)

选择排序：O(n*n)

快速排序：平均时间复杂度log2(n)*n，所有内部排序方法中最高好的，大多数情况下总是最好的。

归并排序：log2(n)*n

堆排序：log2(n)*n

希尔排序：算法的复杂度为n的1.2次幂

冒泡算法实现代码：

void popsort() //冒泡排序 时间复杂度 o(n^2)
{
	int array[]={23,234,4,34,3,23,45};//定义一个长度为7的数组
	int len = getlenth(array);//长度为7
	int temp;//临时变量
	cout<<"排序前";
	for(int i = 0 ; i < len ; i++)
	{
		cout<<array[i]<<" ";
	}
	cout<<endl;
	//采用冒泡排序对它进行排序

	for(int i = 0 ; i < len - 1; i++)
		for(int j = 0 ; j <len - i - 1;j++)
		{
			if(array[j]>array[j+1]) //判断两个相邻的元素的大小
			{
				temp = array[j]; 
				array[j]=array[j+1];
				array[j+1] = temp; //将较大的元素赋值给下一个位置
			}

		}
		cout<<"排序后";
		for(int i = 0 ; i < len ; i++)
		{
			cout<<array[i]<<" ";
		}
}

希尔排序实现：

void shellsort() //希尔排序 不稳定排序
{
	int a[]={12,3,4,41,43,343,454,34,34,2,32,34,25,3,4};
	int len  = getlenth(a);
	int distence = len;
	do 
	{
		distence = distence/2;
		for (int i = distence ; i <len ;i++)
		{
			int j = i-distence; //两个数中第一个数的下标
			int temp = a[i];//待交换的数
			while(j>=0 && a[j]>temp) //比较两个数
			{
				a[distence+j] = a[j]; //像后移动数据
				j -= distence; //这里是分成几段的时候调用
			}
			if (j != i - distence)    //存在比其小的数  
				a[j+distence] = temp;  
		}
	} while (distence>1);

	for (int i = 0 ; i <len ; i ++)
	{
		cout<<a[i] <<"  ";
	}
//	cout<<len;
}

/************************************************************************/
/* 快速排序                      时间复杂度 o(n*log(n))                 */
/************************************************************************/
void QuickSort(int a[],int numsize)//a是整形数组，numsize是元素个数
{
	int i=0; //第一个开始的下标
	int j =numsize-1;//最后一个下标
	int val=a[0];//指定参考值val大小
	if(numsize>1)//确保数组长度至少为2，否则无需排序
	{
		while(i<j)//循环结束条件
		{
			for(;j>i;j--)//从后向前搜索比val小的元素，找到后填到a[i]中并跳出循环
				if(a[j]<val)
				{
					a[i]=a[j];
					break;
				}
				for(;i<j;i++)//从前往后搜索比val大的元素，找到后填到a[j]中并跳出循环
					if(a[i]>val)
					{
						a[j]=a[i];
						break;
					}
		}
		a[i]=val;//将保存在val中的数放到a[i]中
		QuickSort(a,i);//递归，对前i个数排序
		QuickSort(a+i+1,numsize-1-i);//对i+1到numsize这numsize-1-i个数排序
	}
}

快排的另外一种写法

int myparton(int a[],int low,int hight )
{
	int key = a[low];//将第一个记录为key
	while(low<hight)
	{
	while (low<hight&&key>a[hight])	
		hight--;
	if (low<hight)
	{
		a[low] = a[hight];
		low++;
	}
	while (low<hight&&key<a[low])
		low++;
	if (low<hight)
	{
		a[hight] = a[low];
		hight--;
	}
	
	}
	a[low] = key;
	return low;

}
void myQucksort(int a[],int low,int hight)
{
	if (low < hight)
	{
		int hub = myparton(a,low,hight);
		myQucksort(a,low,hub-1);
		myQucksort(a,hub+1,hight);
	}
	
	
}

/************************************************************************/
/* 二分找碴 对已经排序好的数查找                                        */
/************************************************************************/
template <class Type>
Type  BinarySeach(Type serch[],Type x,int len)
{
	
	int left = 0 ; 
	int right = len - 1;
	while (left<right)
	{
		int mid = (left+right)/2;
		if(x == serch[mid])
			return mid;
		if (x > serch[mid])
		{
			left = mid+1;
		}
		else
		{
			right = mid-1;
		}
	}
}

/************************************************************************/
/* 选择排序                     时间复杂读o(n^2)       不稳定排序       */
/************************************************************************/

void sortchoose()
{
	int s[]={12,23,4,54};
	int len = getlenth(s);
	for (int i = 0 ; i < len - 1 ; i++)
	{
		int min = i;
		for (int j = i+1; j < len ; j++)
		{
			if (s[min] > s[j]) //找茬剩下的最大的下标
			{
				min = j ;
			}
		}
		if (min != i)
		{
			s[min] = s[min]^s[i];
			s[i] = s[min]^s[i];
			s[min] = s[min]^s[i];
		}
	}
	
	for (int i = 0 ; i < len ; i ++)
	{
		printf("%d\t",s[i]);
	}
}

/***
插入排序 时间复杂度o（n^2） 稳定
*/
void insertSort()
{
	int s[]={12,23,4,54};
	int len = getlenth(s);
	for(int i = 2; i <len; i++)
	{
		int  j = 0; 
		while(j<len&& s[j]<s[i]) //找茬插入位置
			j++;
		if(j < i) //i位置之前，有比s[i]大的数，则进行挪动和插入 
		{
			int k = i;   //挪动前面的往后面挪动
			int temp = s[i];  
			while (k > j)    //挪动位置  
			{  
				s[k] = s[k-1];  
				k--;  
			}  
			s[k] = temp;    //插入  
		}

	}
	for (int i = 0 ; i < len ; i ++)
	{
		printf("%d\t",s[i]);
	}
}