常见排序算法（C++）

#include<iostream>

using namespace std;

void swap(int arr[],int i,int j){
	int temp=arr[i];
	arr[i]=arr[j];
	arr[j]=temp;
}
void print(int arr[],int n){
	for(int i=0;i<5;i++){
		cout<<arr[i]<<" ";
	}
	cout<<endl;
}
//冒泡排序:每次将最大的数放到最后的位置pos上，pos--，最终使原数组从小到大排序
void b_sort(int arr[],int n){
	for(int i=0;i<n;i++)
		for(int j=0;j<n-i-1;j++){
			if(arr[j]>arr[j+1])
				swap(arr[j],arr[j+1]);
		}
}

//选择排序：每次将最小的数放到最前的位置pos上，pos++，最终生成使原数组从小到大排序
void s_sort(int arr[],int n){
	for(int i=0;i<n;i++){
		int minindex=i;
		for(int j=i+1;j<n;j++){
			minindex=arr[minindex]>arr[j]?j:minindex;//索引值
		}
		swap(arr,minindex,i);//交换最小索引位置上的数。
	}
}
//插入排序
void insert_sort(int arr[],int n){
	for(int i=1;i<n;i++)
		for(int j=i-1;j>=0;j--){//从后向前进行比较****，相当于插牌操作
			if(arr[j]>arr[j+1])
				swap(arr,j,j+1);
		}
}
//归并排序：
void merge(int arr[],int L,int mid,int R){
	int n=R-L+1;
	int*help=new int[n];//辅助数组
	int i=0;
	int p1=L;
	int p2=mid+1;
	while(p1<=mid&&p2<=R){//哪个压入哪个
			help[i++]=arr[p1]<arr[p2]?arr[p1++]:arr[p2++];
	}
	while(p1<=mid){
		help[i++]=arr[p1++];
	}
	while(p2<=R){
		help[i++]=arr[p2++];
	}
	for(int i=0;i<n;i++){
		arr[L+i]=help[i];
	}
	delete[] help;
}
void merge_sort(int arr[],int L,int R){
	if(L==R)return;//终止条件
	int mid=L+(R-L)/2;
	merge_sort(arr,L,mid);
	merge_sort(arr,mid+1,R);
	merge(arr,L,mid,R);
}
//快速排序
int* partion(int arr[],int L,int R){//分成小于，等于，大于边界值的三个区域。
	int less=L-1;//表示小与R的区域开始端
	int more=R;//以最后值来划分，大于R的区域的结束端
	int cur=L;
	while(cur<more){
		if(arr[cur]<arr[R]){
			swap(arr,++less,cur++);//小于区域扩展1，cur向下移动一位
		}
		else if(arr[cur]>arr[R]){
			swap(arr,--more,cur);//将大于区域扩展1，但cur不移动（再将换过来的数进行比较）
		}
		else
			cur++;//等于时候，cur向下移动一位，各区域不变。

	}
	swap(arr,more,R);//将最后一个数放在等于区域的最后一个数
	int*result=new int[2];
	result[0]=less+1;
	result[1]=more;
	return result;
}
void quick_sort(int arr[],int L,int R){
	if(L<R){
		int*p=partion(arr,L,R);
		quick_sort(arr,L,p[0]-1);//小于区进行排序
		quick_sort(arr,p[1]+1,R);//大于区进行排序
	}
	
}
//堆排序
//步骤：1.让数组变成大根堆
//2.最后位置与堆顶元素进行交换。减少heapsize（当前堆的个数）的值，得到最大值固定在最后，并且重新调整为大根堆
//3.一直进行2步骤，知道heapsize=0
void heapInsert(int arr[],int index){//构建大根堆，从上到下构建，复杂度为O（N）
	int fnode=(index-1)/2;
	while(arr[index]>arr[fnode]){//如果当前节点小于其父节点，则值进行交换，并且当前节点索引值来到其父节点所在的位置
		swap(arr,index,fnode);
		index=fnode;
	}
}
void heapify(int arr[],int index,int heapsize){//每次将换过来的一个数进行重新调整
	int left=index*2+1;
	while(left<heapsize){
		int largest=left+1<heapsize&&arr[left+1]>arr[left]?left+1:left;//left+1表示左节点
		largest=arr[index]>arr[largest]?index:largest;
		if(largest==index)break;//不需要再调整，仍为大根堆
		swap(arr,index,largest);
		index=largest;//当前节点索引值指向最大值的位置，再进行比较
		left=index*2+1;//再找到当前节点的左节点，再进行村换
	}
}
void heap_sort(int arr[],int n){
	for(int i=0;i<n;i++)
		heapInsert(arr,i);
	int heapsize=n;
	swap(arr,0,--heapsize);//将第0位置上的元素与最后位置上的元素交换。
	while(heapsize>0){
		heapify(arr,0,heapsize);//重新调整为大根堆
		swap(arr,0,--heapsize);//当前最后位置与堆顶元素，进行元素交换
	}
}
int main()
{
	int arr[5]={5,9,7,6,1};
	//b_sort(arr,5);
	//s_sort(arr,5);
	//insert_sort(arr,5);
	//merge_sort(arr,0,4);
	//quick_sort(arr,0,4);
	heap_sort(arr,5);
	print(arr,5);

}