内部排序算法实现C#语言.docx
《内部排序算法实现C#语言.docx》由会员分享,可在线阅读,更多相关《内部排序算法实现C#语言.docx(14页珍藏版)》请在冰豆网上搜索。
内部排序算法实现C#语言
这里将介绍几种常见的内部排序算法,包括:
直接插入排序、二分查找插入排序、希尔排序、选择排序、堆排序、冒泡排序、快速排序、归并排序。
假设待排序的对象是整型数组,排序操作直接在数组上进行。
下面直接上代码及相应注释。
///
///各种排序算法实现
///
classInnerSortAlgorithm
{
///
///直接插入排序算法。
///
///往已经排好序的序列中插入待排元素,在查找待排元素位置时顺便进行元素移动。
///
///
///给定待排序数组
publicvoidInnerSort_DirectInsert(int[]iArr)
{
intlen=iArr.Length;
inttempI;
intj;
for(inti=1;i{
tempI=iArr[i];
j=i-1;
while(j>=0&&iArr[j]>tempI)
{
iArr[j+1]=iArr[j];
j--;
}
iArr[j+1]=tempI;
}
}
///
///二分查找插入排序。
///
///在已排好序的序列中插入元素,插入位置通过二分查找获得。
///
///
///给定待排序数组
publicvoidInnerSort_BinaryInsert(int[]iArr)
{
intlen=iArr.Length;
intpos;
inttempI;
for(inti=1;i{
tempI=iArr[i];
pos=FindInsertPosition(iArr,i-1,tempI);//查找待插入位置
for(intj=i;j>pos;j--)
{
iArr[j]=iArr[j-1];
}
iArr[pos]=tempI;
}
}
///
///二分查找确定待插入位置。
///
///给定数组
///已排序序列末尾下标
///待插入元素
///返回插入位置
privateintFindInsertPosition(int[]iArr,intendPos,inttempI)
{
intstartPos=0;
intmidPos;
while(startPos<=endPos)
{
midPos=(startPos+endPos)/2;
if(iArr[midPos]>tempI)
{
endPos=midPos-1;
}
else
{
startPos=midPos+1;
}
}
returnstartPos;
}
///
///希尔排序算法。
///
///分组插入排序,按一定间隔先将序列分成n组,组内进行直接插入排序,再减小间隔直至1,完成排序。
///
///
///给定待排序数组
publicvoidInnerSort_Shell(int[]iArr)
{
intlen=iArr.Length;
intinterval=len/2;
inttempI;
intj;
while(interval>=1)
{
for(inti=interval;i{
tempI=iArr[i];
j=i-interval;
while(j>=0&&iArr[j]>tempI)
{
iArr[j+interval]=iArr[j];
j-=interval;
}
iArr[j+interval]=tempI;
}
interval/=2;
}
}
///
///选择排序算法。
///
///每一次都是在待排序列中选出最小的元素,将其放置于有序序列之后。
///
///
///给定待排序数组
publicvoidInnerSort_Selection(int[]iArr)
{
intlen=iArr.Length;
intpos;
intmin;
for(inti=0;i{
pos=i;
min=iArr[i];
for(intj=i+1;j{
if(iArr[j]{
pos=j;
min=iArr[j];
}
}
if(pos!
=i)
{
Swap(iArr,pos,i);
}
}
}
///
///交换数组中两个不同位置的元素。
///
///给定数组
///待交换位置1
///待交换位置2
privatevoidSwap(int[]iArr,intpos1,intpos2)
{
if(pos1!
=pos2)
{
iArr[pos1]^=iArr[pos2];
iArr[pos2]^=iArr[pos1];
iArr[pos1]^=iArr[pos2];
}
}
///
///(大顶)堆排序算法。
///
///大顶堆特点:
父节点元素均不小于子节点元素。
///
///
///构建大顶堆,将堆顶元素与堆中最后一个元素调换,然后在剩余元素中重新构建大顶堆,重复该过程。
///
///
///给定待排序数组
publicvoidInnerSort_Heap(int[]iArr)
{
intlen=iArr.Length;
if(len>1)
{
ConstructMaxHeap(iArr,len-1);//先将原数组构建成一个大顶堆
Swap(iArr,0,len-1);
for(inti=0;i{
AdjustMaxHeap(iArr,0,len-2-i);//将数组剩余部分重新调整成大顶堆
Swap(iArr,0,len-2-i);
}
}
}
///
///将给定元素序列构建成大顶堆。
///
///从堆中最后一个元素的父节点开始调整,使该节点以下部分成为大顶堆,然后一直调整到根节点。
///
///
///给定数组
///待调整堆末尾位置
privatevoidConstructMaxHeap(int[]iArr,intlastPos)
{
for(inti=(lastPos-1)/2;i>=0;i--)
{
AdjustMaxHeap(iArr,i,lastPos);
}
}
///
///调整除堆顶位置外,其他位置均符合大顶堆性质的堆为大顶堆。
///
///给定数组
///待调整堆起始位置
///待调整堆末尾位置
privatevoidAdjustMaxHeap(int[]iArr,intstartPos,intlastPos)
{
intleftChild;
intlargePos;
while(startPos*2+1<=lastPos)
{
leftChild=startPos*2+1;
largePos=leftChild;
if(leftChild+1<=lastPos&&iArr[leftChild]{
largePos=leftChild+1;
}
if(iArr[startPos]{
Swap(iArr,startPos,largePos);
startPos=largePos;
}
else
{
break;
}
}
}
///
///冒泡排序算法。
///
///每次比较相邻两个元素,将较大元素往后移
///
///
///给定待排序数组
publicvoidInnerSort_Bubble(int[]iArr)
{
intlen=iArr.Length;
/*boolisFinish;//额外设计一个标志,判断是否已经排序完
for(inti=len-1;i>0;i--)
{
isFinish=true;
for(intj=0;j
{
if(iArr[j]>iArr[j+1])
{
Swap(iArr,j,j+1);
isFinish=false;
}
}
if(isFinish)
{
break;
}
}*/
intlastPos;
inti=len-1;
while(i>0)
{
lastPos=0;
for(intj=0;j
{
if(iArr[j]>iArr[j+1])
{
Swap(iArr,j,j+1);
lastPos=j;
}
}
i=lastPos;
}
}
///
///快速排序算法。
///
///先选择一个枢轴元素,以该元素为基准将序列划分成两部分,前半部分元素值均小于枢轴元素,
///后半部分均大于,然后递归处理前后两部分。
///
///
///给定待排序数组
publicvoidInnerSort_Quick(int[]iArr)
{
QSort(iArr,0,iArr.Length-1);
}
///
///通过递归实现给定起始位置和末尾位置序列的快速排序。
///
///给定数组
///待排序起始位置
///待排序末尾位置
privatevoidQSort(int[]iArr,intstartPos,intendPos)
{
if(startPos{
intpivotPos=Partition(iArr,startPos,endPos);//进行一次划分
QSort(iArr,startPos,pivotPos-1);
QSort(iArr,pivotPos+1,endPos);
}
}
///
///获取枢轴元素在序列划分后的位置。
///
///划分过程中同时将相应元素进行移动,枢轴元素只在最终确实位置时移动。
///
///
///给定数组
///待划分序列起始位置
///待划分序列末尾位置
///返回枢轴量所处位置
privateintPartition(int[]iArr,intstartPos,intendPos)
{
inttempI=iArr[startPos];
while(startPos{
while(startPos=tempI)
{
endPos--;
}
iArr[startPos]=iArr[endPos];
while(startPos{
startPos++;
}
iArr[endPos]=iArr[startPos];
}
iArr[startPos]=tempI;
returnstartPos;
}
///
///归并排序算法。
///
///将待排序序列分成两个有序序列,进而合并两个有序序列为一个有序序列。
///
///
///对于划分出的序列进行排序,可递归实现。
///
///
///给定待排序数组
publicvoidInnerSort_Merge(int[]iArr)
{
MSort(iArr,0,iArr.Length-1);
}
///
///通过递归实现给定起始位置和末尾位置序列的归并排序。
///
///给定数组
///待排序序列起始位置
///待排序序列末尾位置
privatevoidMSort(int[]iArr,intstartPos,intendPos)
{
if(startPos{
intmidPos=(startPos+endPos)/2;
MSort(iArr,startPos,midPos);
MSort(iArr,midPos+1,endPos);
Merge(iArr,startPos,midPos,endPos);
}
}
///
///合并两个有序序列。
///
///给定数组
///第一个有序序列起始位置
///第一个有序列末尾位置
///第二个有序序列末尾位置
privatevoidMerge(int[]iArr,intstartPos,intmidPos,intendPos)
{
int[]tempArr=newint[endPos-startPos+1];
intpos=0;
inti=startPos;
intj=midPos+1;
while(i<=midPos&&j<=endPos)
{
if(iArr[i]<=iArr[j])
{
tempArr[pos]=iArr[i];
i++;
}
else
{
tempArr[pos]=iArr[j];
j++;
}
pos++;
}
while(i<=midPos)
{
tempArr[pos]=iArr[i];
i++;
pos++;
}
while(j<=endPos)
{
tempArr[pos]=iArr[j];
j++;
pos++;
}
for(i=0;i{
iArr[startPos+i]=tempArr[i];
}
}
}