六种排序算法代码实现(c++)

六种排序算法（冒泡排序，选择排序，插入排序，希尔排序，快速排序，归并排序）的基本思想：

1. 冒泡排序：通过对待排序序列从前往后，依次比较相邻元素的值，若比较是逆序则进行交换，使值较大的元素逐次从前向后移动，就像水底的气泡一样从下往上冒。
2. 选择排序：第一次从数组arr[0]~arr[n-1]中找出最小数与arr[0]交换（若最小数就等于arr[0]则不需要交换），第二次从数组arr[1]~arr[n-1]中找出最小值与arr[1]交换...第i次在arr[i-1]与arr[n-1]中找出最小值与arr[i-1]交换,第n-1次在arr[n-2]~arr[n-1]中找出最小值与arr[n-1]交换，这样经历了n-1次之后，就可以得到一个有序的升序数组。
3. 插入排序：把有n个数据的待排序的数组分成是一个只有一个元素的有序表和另一个有n-1个元素的无序表，排序过程中每次从无序表中取出第一个数据与有序表中的元素依次比较找到合适的位置插入。
4. 希尔排序：插入排序的优化本质也是一种插入排序。希尔排序是把记录按下标的一定增量分组，对每组直接使用插入算法进行排序：随着增量逐渐减小至1时，整个文件被分为一组，排序结束。
5. 快速排序：通过一趟排序将要排序的数组分割成两部分，其中一部分的所有数据比另一部分的所有数据都要小，然后再按次方法对这两部分数据进行快速排序，整个排序可以递归完成，以此整个数据变成有序序列。
6. 归并排序：即将序列分成一些更小的序列进行递归排序，然后再将排序好的序列补和在一起

#include<iostream>
using namespace std;

int i,j;
void bubbleSort(int arr[],int n)//冒泡排序
{
   int flag;
   int t;
   for(i=0;i<n;i++)
   {
	   flag=0;
	   for(j=0;j<n-i-1;j++)
	   {
		   if(arr[j]>arr[j+1])
		   {
			   t=arr[j];
			   arr[j]=arr[j+1];
			   arr[j+1]=t;
			   flag=1;
		   }
	   }
	   if(flag==0)
		   break;//一趟排序过后没有数据发生交换就说明数组已经有序，不用再进行排序，所以直接推出循环即可。
   }
}
void selectSort(int arr[],int k)//选择排序
{
	int min,l,t;
	for(j=0;j<k;j++)
	{
		l=j;
		min=arr[j];
	  for(i=j+1;i<k;i++)
	  {
		if(arr[i]<min)
		{min=arr[i];l=i;}
	  }
	  if(l!=j)
	  {t=arr[j];
	  arr[j]=arr[l];
	  arr[l]=t;}
	}
}
void insertionSort(int arr[],int k)//插入排序
{
	int x,l;
	for(i=1;i<k;i++)
	{
		x=arr[i];
		l=i-1;
		while(x<arr[l]&&l>=0)
		{
			arr[l+1]=arr[l];
			l--;
		}
		if(l!=i-1)
		{
			arr[l+1]=x;
		}	
	}
}
void SheelSort(int arr[],int k)//希尔排序
{
	int t,l=k/2;//
	while(l>=1)
	{
	  for(i=l;i<k;i++)
	  {
		 for(j=i-l;j>=0;j-=l)
		 {
			if(arr[j]>arr[j+l])
			{t=arr[j];arr[j]=arr[j+l];arr[j+l]=t;}
		 }
	  }
	  l/=2;
	}
}
void quickSort(int arr[],int left,int right)//快速排序
{
	int l=left;
	int r=right;
	int p=arr[(left+right)/2];//以数组的中间值作为基数
	int t;
	while(l<r)
	{
		while(arr[r]>p)//找到在p右边比p小的数退出循环
		{
			r--;
		}
		while(arr[l]<p)//找到在p左边比p大的数推出循环
		{
			l++;
		}
		if(l==r) break;
		//交换
		t=arr[r];
		arr[r]=arr[l];
		arr[l]=t;
		if(arr[l]==p) r--;
		if(arr[r]==p) l++;
	}
	if(l==r) {l++;r--;}
	if(r>left)  quickSort(arr,left,r);
	if(l<right) quickSort(arr,l,right);
}
void mergeArr(int arr[], int low, int mid, int hight)//合并算法 
 {
	int* tempArr = new int[hight - low + 1];
	int i = low, j = mid + 1, k = 0;
	while (i <= mid && j <= hight) {
		if (arr[i] < arr[j]) {
			tempArr[k] = arr[i];
			i++;
		}
		else {
			tempArr[k] = arr[j];
			j++;
		}
		k++;
	}
	// 如果 arr[low] 到 arr[mid] 区间中的数组还没有比较完成 ，直接复制到tempArr 中
	while (i <= mid) {
		tempArr[k] = arr[i];
		i++;
		k++;
	}
	// 如果 arr[mid+1] 到 arr[hight] 区间中的数组还没有比较完成 ，直接复制到tempArr 中
	while (j <= hight) {
		tempArr[k] = arr[j];
		j++;
		k++;
	}
	// 比较完成之后 将原本的数组arr 下标 low-hight 对应的内容 进行改变
	i = low;
	for (int tempK = 0;((tempK < k)&&(i<=hight));tempK++) {
		arr[i] = tempArr[tempK];
		i++;
	}
	delete[] tempArr;
	tempArr = NULL;
	
}

//拆分有序的序列两两排序-拆解结束的条件 子序列长度为1的时候
void mergeSort(int arr[], int low, int hight) {
	if (low < hight) {
		int mid = (hight + low) / 2;
		mergeSort(arr,low,mid);// 递归拆解左边的序列
		mergeSort(arr, mid + 1, hight);// 递归拆解左边的序列
		mergeArr(arr, low, mid, hight);// 将两个有序的子序列（arr[low至mid]、arr[mid+1至hight] 排序合并成一个新的有序列
	}
}


int main()
{
	int k;
	int arr[]={34,45,0,21,6,8,-12,18,3,-3,99,0};
	k=sizeof(arr)/sizeof(arr[0]);    
	//bubbleSort(arr,k);
	//selectSort(arr,k);
	//insertionSort(arr,k);
	//SheelSort(arr,k);
	//quickSort(arr,0,k-1);
	//mergeSort(arr,0,11);
	for(j=0;j<k;j++)
	(j==k-1)?(cout<<arr[j]<<endl):(cout<<arr[j]<<" ");
}