arr\[j\]\=arr\[j-1\];
j\--;
}else
break;
}
arr[j]=temp;//将数放于合适位置
print(arr,n);
}
}
2、shell排序
shell排序是对插入排序的一个改装，它每次排序把序列的元素按照某个增量分成几个子序列，对这几个子序列进行插入排序，然后不断缩小增量扩大每个子序列的元素数量，直到增量为一的时候子序列就和原先的待排列序列一样了，此时只需要做少量的比较和移动就可以完成对序列的排序了。
/*
*shell排序
*/
void ShellSort(int *arr,int n)
{
int incre=n/3+1;
bool tag=true;
do
{
if(incre==1)
tag=false;
ShellSortWithIncre(arr,n,incre);
incre=incre/3+1;
}while(incre>=1&&tag);
}
/*
根据增量,使用插入排序调整顺序
*/
void ShellSortWithIncre(int *arr,int n,int incre)
{
for(int i=incre;i<n;i++)
{
int j=i;
int temp=arr[i];
while(j-incre>=0)
{
if(temp<arr[j-incre])
{
arr\[j\]\=arr\[j-incre\];
j\-=incre;
}else
break;
}
arr[j]=temp;
}
}
**3、冒泡排序**
冒泡排序算法的思想：很简单，每次遍历完序列都把最大（小）的元素放在最前面，然后再对剩下的序列从父前面的一个过程，每次遍历完之后待排序序列就少一个元素，当待排序序列减小为只有一个元素的时候排序就结束了。因此，复杂度在最坏的情况下是O（N ^ 2）
/*
*冒泡排序
*/
void BubbleSort(int *arr,int n)
{
bool exchanged=true;
for(int i=0;i<n;i++)
{
exchanged=false;
for(int j=0;j<n-i-1;j++)
{
if(arr[j]>arr[j+1])
{
std::swap(arr\[j\],arr\[j+1\]);
exchanged\=true;
}
}
if(!exchanged)
return;
}
}
**4、快速排序**
快速排序的算法思想： 选定一个枢纽元素，对待排序序列进行分割，分割之后的序列一个部分小于枢纽元素，一个部分大于枢纽元素，再对这两个分割好的子序列进行上述的过程。
/*
快速排序
*/
void QuickSort(int *arr,int start,int end)
{
int low=start,high=end-1;
int pivot;
if(low<high)
{
pivot=Partition(arr,low,high);
//print(arr,end-start+1);
QuickSort(arr,low,pivot);
QuickSort(arr,pivot+1,end);
}
}
/*
根据pivot将数组分为两部分,左边小于pivot,右边大于pivot
*/
int Partition(int *arr,int start,int end)
{
int pivot=getMediumNum(arr,start,end);
std::swap(arr[start],arr[pivot]);
int pivotNum=arr[start];
//std::cout<<"pivot is "<<pivotNum<<std::endl;
while(start<end)
{
while(start<end&&pivotNum<arr[end])
--end;
if(start<end)
arr[start++]=arr[end];
while(start<end&&arr[start]<=pivotNum)
++start;
if(start<end)
arr[end--]=arr[start];
}
arr[start]=pivotNum;
return start;
}
/*
取头,中,尾三数的中值
*/
int getMediumNum(int *arr,int start,int end)
{
int medium=(start+end)/2;
if(arr[start]<arr[medium])
{
if(arr[medium]<arr[end])
return medium;
else
if(arr[start]>arr[end])
return start;
else
return end;
}else
{
if(arr[medium]>arr[end])
return medium;
else
if(arr[start]>arr[end])
return end;
else
return start;
}
}
另一个分割方法：
int Partition(int *arr,int start,int end)
{
int x = arr[end];
int i = start - 1;
for(int j=start;j<end;j++)
{
if(arr[j]<=x)
{
++i;
swap(arr[i],arr[j]);
}
}
swap(arr[i+1],arr[end]);
return i+1;
}
**5、选择排序**
每次选择最小的数，放入该数对应的位置。
/*
选择排序
*/
void SelectSort(int *arr,int n)
{
for(int i=0;i<n;i++)
{
int min=i;
for(int j=i;j<n;j++)
{
if(arr[j]<arr[min])
min\=j;
}
if(min!=i)
std::swap(arr[i],arr[min]);
}
}
**6、堆排序**
堆的定义：
n个关键字序列Kl，K2，…，Kn称为堆，当且仅当该序列满足如下性质（简称为堆性质）：
（1） ki≤K2i且ki≤K2i+1 或（2）Ki≥K2i且ki≥K2i+1（1≤i≤）
若将此序列所存储的向量R\[1……n\]看做是一棵完全二叉树的存储结构，则堆实质上是满足如下性质的完全二叉树：树中任一非叶结点的关键字均不大于（或不小于）其左右孩子（若存在）结点的关键字。
堆的这个性质使得可以迅速定位在一个序列之中的最小（大）的元素。
堆排序算法的过程如下：1）得到当前序列的最小（大）的元素
（2）把这个元素和最后一个元素进行交换，这样当前的最小（大）的元素就放在了序列的最后，而原先的最后一个元素放到了序列的最前面
（3）的交换可能会破坏堆序列的性质（注意此时的序列是除去已经放在最后面的元素），因此需要对序列进行调整，使之满足于上面堆的性质。重复上面的过程，直到序列调整完毕为止。
/*
*堆排序
*/
void HeapSort(int *arr,int n)
{
BuildMaxHeap(arr,n);
//std::cout<<"构建的大顶堆为:";
//print(arr,n);
for(int i=n-1;i>0;i--)
{
std::swap(arr[i],arr[0]);
HeapAdjust(arr,0,i);
}
}
/*
构建大顶堆
*/
void BuildMaxHeap(int *arr,int n)
{
for(int i=n/2-1;i>=0;i--)
{
HeapAdjust(arr,i,n);
}
}
/*
*调整大顶堆
*/
void HeapAdjust(int *arr,int start,int n)
{
int rightChild=(start+1)*2;
while(rightChild<n)//左右节点都存在
{
if(arr[rightChild]<arr[rightChild-1])
--rightChild;
if(arr[start]<arr[rightChild])
{
std::swap(arr[start],arr[rightChild]);
start=rightChild;
rightChild=(start+1)*2;
}else
break;
}
if(rightChild==n)//只有左节点,没有右节点
{
if(arr[start]<arr[rightChild-1])
std::swap(arr[start],arr[rightChild-1]);
}
}
**7、归并排序**
归并排序的算法思想：把待排序序列分成相同大小的两个部分，依次对这两部分进行归并排序，完毕之后再按照顺序进行合并
/*
自底向上归并排序
*/
void MergeSort(int *arr,int n)
{
for(int i=1;i<n;i*=2)
{
MergePass(arr,i,n);
std::cout<<i<<"路归并后的结果:"<<std::endl;
print(arr,n);
}
}
/*
功能:将两个有序数组归并到一起
*/
void Merge(int *arr,int start,int mid,int end)
{
int length=end-start;
int i=start,j=mid,p=0;
int *arr2=new int[length];
while(i<mid&&j<end)
{
if(arr[i]<arr[j])
{
arr2[p++]=arr[i];
++i;
}else
{
arr2[p++]=arr[j];
++j;
}
}
while(i<mid)
arr2[p++]=arr[i++];
while(j<end)
arr2[p++]=arr[j++];
p=0;
for(i=start;i<end;i++,p++)
{
arr[i]=arr2[p];
}
delete[] arr2;
}
/*
根据间隔,进行归并
*/
void MergePass(int *arr,int interval,int n)
{
int i=0;
for(;i+2*interval<n;i+=2*interval)
{
Merge(arr,i,i+interval,i+2*interval);
}
if(i+interval<n)
