常见的排序算法 :冒泡排序 、选择排序、插入排序、归并排序、快速排序、堆排序
https://www.cnblogs.com/eniac12/p/5329396.html
#include<iostream>
using namespace std;
void Swap(int A[],int i,int j)
{
int temp=A[j];
A[j]=A[i];
A[i]=temp;
}
//冒泡法 平均时间复杂度 o(n^2)
void BubbloSort(int A[],int n)
//void BubbloSort(int *A,int n)
//因为不能拷贝数组,所以我们无法以值传递的方式使用数组参数。
//因为数组会被转换成指针,所以当我们为函数传递一个数组时,
//实际上传递的是指向数组首元素的指针。
{
if(A==NULL*&&n<2)
{
return;
}
for(int i=0;i<n-1;i++)
{
for(int j=0;j<n-1-i;j++)
if(A[j]>A[j+1])
Swap(A,j,j+1); //数组A被转换成int*并指向A[0]
}
}
//鸡尾酒排序 平均时间复杂度 o(n^2)
void CocktailSort(int *A,int n)
{
if(n<0)
return ;
int left=0;
int right=n-1;
while(left<right)
{
for(int i=left;i<right;i++) //前半轮,排序最大数
{ if(A[i]>A[i+1])
Swap(A,i,i+1);
}
right--;
for(int i=right;i>0;i--) //后半轮,排序最小数
{
if(A[i-1]>A[i])
Swap(A,i-1,i);
}
left++;
}
}
//选择排序 不稳定排序 O(n^2)
void SelectionSort(int A[],int n)
{
if(A==NULL*&&n<2)
{
return;
}
for(int i=0;i<n-1;i++)
{
int min=i;
for(int j=i+1;j<n;i++)
{
if(A[j]<A[min])
min=j;
}
if(min!=i)
Swap(A,min,i);
}
}
//插入排序
void InsertSort(int *A,int len)
{
if(A==NULL*&&n<2)
{
return;
}
for(int i=1;i<n;i++)
{
for(int j=i-1;j>=0&&A[j]>A[j+1];j--)
swap(A,j,j+1);
}
}
//归并排序
void MergeSort(int *A,int len)
{
if(A==NULL*&&len<2)
{
return;
}
mergeSort(A,0,len-1)
}
//递归过程
void mergeSort(int *A,int L,int R)
{
if(L<R)
{
int mid=L+(R-L)>>1;
mergeSort(A,L,mid);
mergeSort(A,mid+1,R);
merge(A,L,mid,R);
}
}
//左右两部分排序
void merge(int *A,int left,int midum,int right)
{
int* help=new int[right-left+1];
int i=0;
int p=left;
int q=midum+1;
while(p<=midum&&q<=right)
help[i++]=A[p]<A[q]?A[p++]:A[q++];
while(p<=midum)
help[i++]=A[p++];
while(q<=right)
help[i++]=A[q++];
for(int i=0;i<help.size();i++)
A[left+i]=help[i++];
}
//随机快速排序 荷兰国旗问题
void QuickSoit(int *A,int len)
{
if(A==NULL*&&len<2)
{
return;
}
quickSort(A,0,len-1);
}
void quickSort(int *A,int L,int R)
{
if(L<R)
{
swap(A,(int) (Math.random() * (R - L + 1)),R);
int Array[]=partiton(A,L,R);
quickSort(A,0,Array[0]-1);
quickSort(A,Array[1]+1,R);
}
}
int partiton(int *A,int L,int R)
{
int less=L-1;
int more=R;
while(L<more)
{
if(A[L]<A[R])
swap(A,++less,L++);
else if(A[L]>A[R])
swap(A,--more,L);
else
L++;
}
swap(A,more,R);
return new int []{less+1,more};
}
//堆排序
void HeapInsert(int *A,int len)
{
if(A==NULL*&&len<2)
{
return;
}
for(int i=0;i<len;i++)
{
heapInsert(A,i);
}
int heapSize=len;
swap(A,0,--heapSize);
while(heapSize>0)
{
heapify(A,0,heapSize);
swap(A,0,--heapSize);
}
}
void heapInsert(int *A,int index)
{
while(A[index]>A[(index-1)/2])
{
swap(A,index,(index-1)/2);
index=(index-1)/2;
}
}
void heapify(int *A,int index,int heapSize)
{
int left=index*2+1;
while(left<heapSize){
int largest=left+1<heapSize&&A[left+1]>A[left]?left+1:left;
largest=A[index]>A[largest]?index:largest;
if(index==largest)
break;
swap(A,index,largest);
index=largest;
left=index*2+1;
}
}