内部排序算法实现C语言.docx
《内部排序算法实现C语言.docx》由会员分享，可在线阅读，更多相关《内部排序算法实现C语言.docx（16页珍藏版）》请在冰豆网上搜索。
内部排序算法实现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];
}
}
}
升级会员 