常用的排序算法的C++实现

#include<iostream>
using namespace std;
void swap(int &i,int &j)//实现i,j交换的函数
{
	i=i^j;
	j=i^j;
	i=i^j;
}
void Display(const int *arr,int length)
{
	if(arr==NULL || length<=0)
	{
		return ;
	}
	int i;
	for(i=0;i<length;i++)
	{
		cout<<arr[i]<<" ";
	}
	cout<<endl;
}
直接插入排序//
void InsertSort(int *arr,int length)//直接插入排序
{
	if(arr==NULL || length<=1)//如果大小为1也无需再排序
	{
		return ;
	}
	int i;
	for(i=1;i<length;i++)//从第二个值开始插
	{
		int temp=arr[i];//先保存待插入的值，因为移动会被覆盖
		int j;
		for(j=i-1;j>=0 && arr[j]>temp;j--)//一边比较一边移动
		{
			arr[j+1]=arr[j];
		}
		if(i!=j+1)//如果前面存在比a[i]小的数
		{
			arr[j+1]=temp;//在当前值的下一个位置插入
		}
	}
}

///冒泡排序
void BubbleSort(int *arr,int length)//冒泡排序
{
	if(arr==NULL || length<=1)
	{
		return ;
	}
	int i,j;
	bool change=true;//对冒泡排序的优化
	for(i=0;i<length-1 && change;i++)//i表示最多冒泡的次数
	{
		change=false;
		for(j=0;j<length-1-i;j++)
		{
			if(arr[j]>arr[j+1])//通过异或实现高效数据交换
			{
				swap(arr[j],arr[j+1]);
				change=true;
			}
		}
	}
}

/简单选择排序//
void SelectSort(int *arr,int length)//简单选择排序
{
	if(arr==NULL || length<=1)
	{
		return ;
	}
	int i,min;
	for(i=0;i<length-1;i++)
	{
		min=i;//每次假设第一个值为最小值
		int j;
		for(j=i+1;j<length;j++)
		{
			if(arr[min]>arr[j])
			{
				min=j;//记下当前最小值的位置
			}
		}
		if(min!=i)
		{
			swap(arr[i],arr[min]);
		}
	}
}
快速排序
int Partition(int *arr,int left,int right)//将数组一分为二，并寻找支点的位置
{
	int x=arr[left];//每次将第一个值作为支点的值
	while(left<right)
	{
		while(arr[right]>=x && left<right)//从右向左扫描,注意是小于等于
		{
			right--;
		}
		while(arr[left]<=x && left<right)//从左向右扫描，注意是小于等于
		{
			left++;
		}
		if(left<right)
		{
			swap(arr[left],arr[right]);
		}
	}
	return left;//此时left等于right
}

void QSort(int *arr,int left,int right)//快速排序,left=0,right=length-1
{
	if(left<right)
	{
		int mid=Partition(arr,left,right);
		QSort(arr,left,mid-1);
		QSort(arr,mid+1,right);
	}
}

void QuickSort(int *arr,int length)
{
	if(arr==NULL || length<=1)
	{
		return ;
	}
	QSort(arr,0,length-1);
}

//归并排序/
void Merge(int *arr,int first,int mid,int last,int *temp)//将arr[first...mid]与arr[mid+1...last]归并
{
	int i,j;
	int k=0;
	for(i=first,j=mid+1;i<=mid && j<=last;)
	{
		if(arr[i]<=arr[j])//所以是稳定排序
		{
			temp[k++]=arr[i++];
		}
		else
		{
			temp[k++]=arr[j++];
		}
	}
	while(i<=mid)
	{
		temp[k++]=arr[i++];
	}
	while(j<=last)
	{
		temp[k++]=arr[j++];
	}
	for(i=0;i<k;i++)//将合并后的数组temp[]还原到arr[]
	{
		arr[first+i]=temp[i];//是arr[low+i]不是arr[i]
	}
}
void Msort(int *arr,int first,int last,int *temp)
{
	if(first==last)
	{
		temp[first]=arr[first];
	}
	else if(first<last)
	{
		int mid=(first+last)/2;
		Msort(arr,first,mid,temp);
		Msort(arr,mid+1,last,temp);
		Merge(arr,first,mid,last,temp);
	}
}
void MergeSort(int *arr,int length)//归并排序
{
	if(arr==NULL || length<=1)
	{
		return ;
	}
	int *temp=new int [length];
	Msort(arr,0,length-1,temp);
	delete []temp;
}

//希尔排序
void ShellInsert(int *arr,int length,int d)
{
	int i,j;
	for(i=d;i<length;i++)
	{
		int temp=arr[i];
		for(j=i-d;j>=0 && arr[j]>temp;j-=d)
		{
			arr[j+d]=arr[j];
		}
		if(j!=i-d)
		{
			arr[j+d]=temp;
		}
	}
}

void ShellSort(int *arr,int length)//希尔排序
{
	if(arr==NULL || length<=1)
	{
		return ;
	}
	int d=length/2;
	while(d>=1)
	{
		ShellInsert(arr,length,d);
		d/=2;
	}
}

堆排序(大顶堆)//
///堆是一个完全二叉树，若结点索引从0开始，则i结点的左孩子为2*i+1,右为2*i+2
void HeapAdjustDown(int *arr,int length,int i)//对第i个值做向下调整，i=0,...,length-1
{
	if(arr==NULL || length<=0 || i<0)
	{
		return ;
	}
	int temp=arr[i];
	int j;//i相当于前驱，j相当于后继
	for(j=2*i+1;j<length;)//即j<=length-1
	{
		if(j+1<length && arr[j]<arr[j+1])//如果存在右孩子，且右孩子值待遇
		{
			j++;//与右孩子交换
		}
		if(arr[j]<=temp)//如果左右孩子中的较大值小于该结点值，则说明无需向下调整了
		{
			break;
		}
		else//如果左右孩子中的较大值大于该结点值，则想到直接插入排序
		{
			arr[i]=arr[j];//孩子结点值中较大的上移动
			i=j;//i用于追踪待插入点的位置
			j=2*i+1;
		}
	}
	if(arr[i]!=temp)//如果i的值发生了移动
	{
		arr[i]=temp;//将最初第i个节点值放入合适的位置
	}

}
void CreateHeap(int *arr,int length)//创建一个堆
{
	if(arr==NULL || length<=0)
	{
		return ;
	}
	int i;
	for(i=(length-2)/2;i>=0;i--)//最后一个元素的序号为length-1,故该结点的父结点为(length-2)/2
	{
		HeapAdjustDown(arr,length,i);//从倒数第二行开始倒着向下调整
	}
}
void HeapDelete(int *arr,int len)//删堆顶元素，len表示当前表的长度
{
	if(arr==NULL || len<=0 || len==1)//len=1,表示当堆中只有一个元素时，无需排序
	{
		return ;
	}
	else
	{
		swap(arr[0],arr[len-1]);
		HeapAdjustDown(arr,len-1,0);//删除后，数组长度减1了
	}
}

void HeapSort(int *arr,int length)//堆排序
{
	if(arr==NULL || length<=1)
	{
		return ;
	}
	CreateHeap(arr,length);//先创建一个堆0
	int i;
	for(i=0;i<=length-1;i++)//删除length-1次即可，因为最后一个元素就剩自己了
	{
		HeapDelete(arr,length-i);
	}
}
int main()
{
	int a[]={2,6,3,1,4,5,1,21,12,3};
	Display(a,sizeof(a)/sizeof(int));//显示排序前的元素
	//void (*pSort)(int*,int)=NULL;//定义一个函数指针,方法一
	typedef void (*Fun)(int *,int);//Fun为函数指针类
	Fun pSort=NULL;//定义函数指针，方法二，与上面等价
//	pSort=InsertSort;
//	pSort=BubbleSort;
//	pSort=SelectSort;
//	pSort=QuickSort;
//	pSort=ShellSort;
	pSort=HeapSort;
	if(pSort)
	{
		pSort(a,sizeof(a)/sizeof(int));//显示排序后的元素
	}
	Display(a,sizeof(a)/sizeof(int));
	return 0;
}