Java中各种排序算法是怎么实现的一般是上机或者描述文档格式.docx
《Java中各种排序算法是怎么实现的一般是上机或者描述文档格式.docx》由会员分享，可在线阅读，更多相关《Java中各种排序算法是怎么实现的一般是上机或者描述文档格式.docx（14页珍藏版）》请在冰豆网上搜索。
冒泡排序:
publicclassBubbleSortimplementsSortUtil.Sort{
for（inti=0;
for（intj=data.length-1;
j>
i;
j）{
if（data[j]
选择排序:
publicclassSelectionSortimplementsSortUtil.Sort{
/*
*（non-Javadoc）
*
for（inti=0;
i>
intlowIndex=i;
for（intj=data.length1;
j>
i;
j）{
if（data[j]
lowIndex=j;
SortUtil.swap（data,i,lowIndex）;
Shell排序:
publicclassShellSortimplementsSortUtil.Sort{
for（inti=data.length/2;
i>
2;
i/=2）{
for（intj=0;
j
insertSort（data,j,i）;
insertSort（data,0,1）;
*@paramdata
*@paramj
*@parami
privatevoidinsertSort（int[]data,intstart,intinc）{
for（inti=start+inc;
=inc）（data[j]
SortUtil.swap（data,j,j-inc）;
快速排序:
publicclassQuickSortimplementsSortUtil.Sort{
quickSort（data,0,data.length-1）;
privatevoidquickSort（int[]data,inti,intj）{
intpivotIndex=（i+j）/2;
//swap
SortUtil.swap（data,pivotIndex,j）;
intk=partition（data,i-1,j,data[j]）;
SortUtil.swap（data,k,j）;
if（（k-i）>
1）quickSort（data,i,k-1）;
if（（j-k）>
1）quickSort（data,k+1,j）;
*@return
privateintpartition（int[]data,intl,intr,intpivot）{
do{
while（data[++l]
while（（r!
=0）data[--r]>
pivot）;
SortUtil.swap（data,l,r）;
while（l
returnl;
改进后的快速排序:
publicclassImprovedQuickSortimplementsSortUtil.Sort{
privatestaticintMAX_STACK_SIZE=4096;
privatestaticintTHRESHOLD=10;
int[]stack=newint[MAX_STACK_SIZE];
inttop=-1;
intpivot;
intpivotIndex,l,r;
stack[++top]=0;
stack[++top]=data.length-1;
while（top>
0）{
intj=stack[top--];
inti=stack[top--];
pivotIndex=（i+j）/2;
pivot=data[pivotIndex];
//partition
l=i-1;
r=j;
=0）（data[--r]>
pivot））;
SortUtil.swap（data,l,j）;
if（（l-i）>
THRESHOLD）{
stack[++top]=i;
stack[++top]=l-1;
if（（j-l）>
stack[++top]=l+1;
stack[++top]=j;
//newInsertSort（）.sort（data）;
insertSort（data）;
privatevoidinsertSort（int[]data）{
归并排序:
publicclassMergeSortimplementsSortUtil.Sort{
int[]temp=newint[data.length];
mergeSort（data,temp,0,data.length-1）;
privatevoidmergeSort（int[]data,int[]temp,intl,intr）{
intmid=（l+r）/2;
if（l==r）return;
mergeSort（data,temp,l,mid）;
mergeSort（data,temp,mid+1,r）;
for（inti=l;
temp[i]=data[i];
inti1=l;
inti2=mid+1;
for（intcur=l;
cur
if（i1==mid+1）
data[cur]=temp[i2++];
elseif（i2>
r）
data[cur]=temp[i1++];
elseif（temp[i1]
else
改进后的归并排序:
publicclassImprovedMergeSortimplementsSortUtil.Sort{
privatestaticfinalintTHRESHOLD=10;
privatevoidmergeSort（int[]data,int[]temp,intl,intr）{
inti,j,k;
intmid=（l+r）/2;
if（l==r）
return;
if（（midl）>
=THRESHOLD）
mergeSort（data,temp,l,mid）;
insertSort（data,l,midl+1）;
if（（rmid）>
THRESHOLD）
mergeSort（data,temp,mid+1,r）;
insertSort（data,mid+1,rmid）;
for（i=l;
i
temp[i]=data[i];
for（j=1;
j
temp[r-j+1]=data[j+mid];
inta=temp[l];
intb=temp[r];
for（i=l,j=r,k=l;
k
if（a
data[k]=temp[i++];
a=temp[i];
}else{
data[k]=temp[j--];
b=temp[j];
*@paraml
privatevoidinsertSort（int[]data,intstart,intlen）{
for（inti=start+1;
start）data[j]
堆排序:
publicclassHeapSortimplementsSortUtil.Sort{
MaxHeaph=newMaxHeap（）;
h.init（data）;
h.remove（）;
System.arraycopy（h.queue,1,data,0,data.length）;
privatestaticclassMaxHeap{
voidinit（int[]data）{
this.queue=newint[data.length+1];
queue[++size]=data[i];
fixUp（size）;
privateintsize=0;
privateint[]queue;
publicintget（）{
returnqueue[1];
publicvoidremove（）{
SortUtil.swap（queue,1,size）;
fixDown
（1）;
//fixdown
privatevoidfixDown（intk）{
intj;
while（（j=k>
if（j
j++;
if（queue[k]>
queue[j]）//不用交换
break;
SortUtil.swap（queue,j,k）;
k=j;
privatevoidfixUp（intk）{
while（k>
1）{
intj=k>
>
1;
if（queue[j]>
queue[k]）
SortUtil:
packageorg.rut.util.algorithm;
importorg.rut.util.algorithm.support.BubbleSort;
importorg.rut.util.algorithm.support.HeapSort;
importorg.rut.util.algorithm.support.ImprovedMergeSort;
importorg.rut.util.algorithm.support.ImprovedQuickSort;
importorg.rut.util.algorithm.support.InsertSort;
importorg.rut.util.algorithm.support.MergeSort;
importorg.rut.util.algorithm.support.QuickSort;
importorg.rut.util.algorithm.support.SelectionSort;
importorg.rut.util.algorithm.support.ShellSort;
publicclassSortUtil{
publicfinalstaticintINSERT=1;
publicfinalstaticintBUBBLE=2;
publicfinalstaticintSELECTION=3;
publicfinalstaticintSHELL=4;
publicfinalstaticintQUICK=5;
publicfinalstaticintIMPROVED_QUICK=6;
publicfinalstaticintMERGE=7;
publicfinalstaticintIMPROVED_MERGE=8;
publicfinalstaticintHEAP=9;
publicstaticvoidsort（int[]data）{
sort（data,IMPROVED_QUICK）;
privatestaticString[]name={
insert,bubble,selection,shell,quick,improved_quick,merge,improved_merge,heap
};
privatestaticSort[]impl=newSort[]{
newInsertSort（）,
newBubbleSort（）,
newSelectionSort（）,
newShellSort（）,
newQuickSort（）,
newImprovedQuickSort（）,
newMergeSort（）,
newImprovedMergeSort（）,
newHeapSort（）
publicstaticStringtoString（intalgorithm）{
returnname[algorithm-1];
publicstaticvoidsort（int[]data,intalgorithm）{
impl[algorithm-1].sort（data）;
publicstaticinterfaceSort{
publicvoidsort（int[]data）;
publicstaticvoidswap（int[]data,inti,intj）{
inttemp=data[i];
data[i]=data[j];
data[j]=temp;
升级会员 