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