java的各种算法Word文档格式.docx
《java的各种算法Word文档格式.docx》由会员分享，可在线阅读，更多相关《java的各种算法Word文档格式.docx（48页珍藏版）》请在冰豆网上搜索。
a[i]>
keys）{
a[i+1]=a[i];
i--;
a[i+1]=keys;
InsertSorti=newInsertSort（）;
int[]f={5,2,4,6,1,3,0};
i.sort（f）;
System.out.println（Arrays.toString（f））;
3MergeSort
publicclassMergeSortTest{
privateint[]l,r1;
publicvoidmerge（int[]a,intp,intq,intr）{
intn1=q-p+1;
intn2=r-q;
l=newint[n1];
r1=newint[n2+1];
l[i]=a[p+i];
l[n1-1]=Integer.MAX_VALUE;
r1[i]=a[q+i];
r1[n2]=Integer.MAX_VALUE;
inti=0;
intj=0;
for（intk=p;
k
if（l[i]<
=r1[j]）{
a[k]=l[i];
i=i+1;
}else{
a[k]=r1[j];
j=j+1;
publicvoidmergeSort（int[]a,intp,intr）{
if（p+1
intq=（p+r）/2;
mergeSort（a,p,q）;
mergeSort（a,q,r）;
merge（a,p,q,r）;
int[]a1={3,41,52,26,38,57,9,49};
MergeSortTestmst=newMergeSortTest（）;
mst.mergeSort（a1,0,a1.length）;
System.out.println（Arrays.toString（a1））;
4SelectionSort
5HeapSort
publicclassHeapSort{
privateintlargest;
publicintleft（inti）{
return2*i+1;
publicintright（intj）{
return2*j+2;
publicvoidmaxHeapify（int[]a,inti）{
intl=left（i）;
intr=right（i）;
if（（la[i]））{
largest=l;
largest=i;
if（（ra[largest]））{
largest=r;
if（largest!
=i）{
inttemp=a[i];
a[i]=a[largest];
a[largest]=temp;
maxHeapify（a,largest）;
publicvoidbuildMaxHeap（int[]a）{
for（inti=a.length/2;
i>
=0;
--i）{
maxHeapify（a,i）;
buildMaxHeap（a）;
//System.out.println（Arrays.toString（a））;
for（inti=a.length-1;
=1;
inttemp=a[0];
a[0]=a[i];
a[i]=temp;
int[]b=newint[i];
System.arraycopy（a,0,b,0,i-1）;
maxHeapify（b,0）;
System.arraycopy（b,0,a,0,i-1）;
HeapSorths=newHeapSort（）;
int[]a={23,17,14,6,13,10,1,5,7};
hs.sort（a）;
6BucketSort
publicclassBucketSort{
/**
*@paramargs
*/
privateLinkedList[]b;
publicvoidsort（double[]a）{
intn=a.length;
b=newLinkedList[a.length];
b[（int）（n*a[i]）]=newLinkedList（）;
b[（int）（n*a[i]）].add（Double.valueOf（a[i]））;
//System.out.println（b[（int）（n*a[i]）]）;
//System.out.println（Arrays.toString（b））;
if（b[i]==null）{
continue;
Collections.sort（b[i]）;
publicstaticvoidmain（String[]args）{
//TODOAuto-generatedmethodstub
double[]a={0.79,0.13,0.16,0.64,0.39,0.20,0.89,0.53,0.71,0.42};
BucketSortbs=newBucketSort（）;
if（bs.b[i]==null）{
Iteratorit=bs.b[i].iterator（）;
while（it.hasNext（））{
System.out.print（it.next（）+"
"
）;
//System.out.println（Arrays.toString（bs.b））;
}
7CountingSort
publicclassCountingSort{
publicvoidSort（int[]a,int[]b,intk）{
int[]c=newint[k+1];
for（intj=0;
c[a[j]]=c[a[j]]+1;
for（inti=1;
c[i]=c[i]+c[i-1];
b[c[a[j]]-1]=a[j];
c[a[j]]=c[a[j]]-1;
int[]a=newint[]{3,1,12,11,4,13};
CountingSortcs=newCountingSort（）;
int[]b=newint[a.length];
cs.Sort（a,b,13）;
System.out.println（Arrays.toString（b））;
1Fibonacci
Fibonacci为1200年代的欧洲数学家，在他的著作中曾经提到：
若有一只兔子每个月生一只小兔子，一个月后小兔子也开始生产。
起初只有一只兔子，一个月后就有两只兔子，两个月后有三只兔子，三个月后有五只兔子（小兔子投入生产）……
这就是Fibonacci数列，一般习惯称之为费式数列，例如：
1，1，2，3，5，8，13，21，34，55，89，……
publicclassFibonacci{
publicstaticvoidmain（String[]args）{
int[]fib=newint[20];
fib[0]=0;
fib[1]=1;
for（inti=2;
i<
fib.length;
i++）
fib[i]=fib[i-1]+fib[i-2];
for（inti=0;
System.out.print（fib[i]+"
System.out.println（）;
}
2巴斯卡（Pascal）
三角形基本上就是在解nCr，因为三角形上的每一个数字各对应一个nCr，其中n为row，而r为colnmu
importjava.awt.*;
importjavax.swing.*;
publicclassPascalextendsJFrame{
publicPascal（）{
setBackground（Color.white）;
setTitle（"
巴斯卡三角形"
setSize（520,350）;
setDefaultCloseOperation（JFrame.EXIT_ON_CLOSE）;
show（）;
privatelongcombi（intn,intr）{
inti;
longp=1;
for（i=1;
=r;
p=p*（n-i+1）/i;
returnp;
publicvoidpaint（Graphicsg）{
finalintN=12;
intn,r,t;
for（n=0;
n<
=N;
n++）{
for（r=0;
r<
=n;
r++）
g.drawString（"
+combi（n,r）,
（N-n）*20+r*40,n*20+50）;
publicstaticvoidmain（Stringargs[]）{
Pascalfrm=newPascal（）;
3ThreeColorFlags
ThreeColorFlags问题最早由E.W.Dijkstra所提出，塔所使用的用语为DutchNationFlag（Dijkstra为荷兰人），而多数的作者则使用Three-ColorFlag来说明。
假设有一条绳子，上面有红，白，蓝三种颜色的旗子，起初绳子上的旗子颜色并没有顺序，您希望将之分类，并排列蓝，白，红的顺序，要如何移动次数才会最少，注意您只能在绳子上进行这个动作，而且一次只能调换两个旗子。
importjava.io.*;
publicclassThreeColorsFlags{
privatevoidswap（char[]flags,intx,inty）{
chartemp;
temp=flags[x];
flags[x]=flags[y];
flags[y]=temp;
publicStringmove（char[]flags）{
intwFlag=0;
intbFlag=0;
intrFlag=flags.length-1;
while（wFlag<
=rFlag）{
if（flags[wFlag]=='
W'
）{
wFlag++;
elseif（flags[wFlag]=='
B'
swap（flags,bFlag,wFlag）;
bFlag++;
else{
rFlag&
flags[rFlag]=='
R'
）
rFlag--;
swap（flags,rFlag,wFlag）;
returnnewString（flags）;
publicstaticvoidmain（String[]args）
throwsIOException{
BufferedReaderbuf;
buf=newBufferedReader（
newInputStreamReader（System.in））;
System.out.print（"
输入三色旗顺序（ex.RWBBWRWR）：
"
Stringflags=buf.readLine（）;
ThreeColorsFlagsthreeColorsFlag=newThreeColorsFlags（）;
flags=threeColorsFlag.move（
flags.toUpperCase（）.toCharArray（））;
System.out.println（"
移动顺序后：
+flags）;
4Mouse
Mouse走迷宫是循环求解的基本类型，我们在二维数组中用2来表示迷宫的墙壁，使用1来表示老鼠的行走路径，并用程序求出从入口到出口的距离。
publicclassMouse{
privateintstartI,startJ;
//入口
privateintendI,endJ;
//出口
privatebooleansuccess=false;
int[][]maze={{2,2,2,2,2,2,2},
{2,0,0,0,0,0,2},
{2,0,2,0,2,0,2},
{2,0,0,2,0,2,2},
{2,2,0,2,0,2,2},
{2,2,2,2,2,2,2}};
显示迷宫：
maze.length;
i++）{
for（intj=0;
j<
maze[0].length;
j++）
if（maze[j]==2）
█"
else
Mousemouse=newMouse（）;
mouse.setStart（1,1）;
mouse.setEnd（5,5）;
if（!
mouse.go（maze））{
\n没有找到出口！
\n找到出口！
j++）{
elseif（maze[j]==1）
◇"
publicvoidsetStart（inti,intj）{
this.startI=i;
this.startJ=j;
publicvoidsetEnd（inti,intj）{
this.endI=i;
this.endJ=j;
publicbooleango（int[][]maze）{
returnvisit（maze,startI,startJ）;
privatebooleanvisit（int[][]maze,inti,intj）{
maze[j]=1;
if（i==endI&
j==endJ）
success=true;
success&
maze[j+1]==0）
visit（maze,i,j+1）;
maze[i+1][j]==0）
visit（maze,i+1,j）;
maze[j-1]==0）
visit（maze,i,j-1）;
maze[i-1][j]==0）
visit（maze,i-1,j）;
success）
maze[j]=0;
returnsuccess;
5Knighttour
骑士游戏，在十八世纪倍受数学家与拼图迷的注意，骑士的走法为西洋棋的走发，骑士可以由任何一个位置出发，它要如何走完所有的位置。
publicclassKnight{
publicbooleantravel（intstartX,
intstartY,int[][]board）{
//对应骑士可以走的八个方向
int[]ktmove1={-2,-1,1,2,2,1,-1,-2};
int[]ktmove2={1,2,2,1,-1,-2,-2,-1};
//下一个出路的位置int[]nexti=newint[board.length];
int[]nextj=newint[board.length];
//记录出路的个数
int[]exists=newint[board.length];
intx=startX;
inty=startY;
board[x][y]=1;
for（intm=2;
m<
=Math.pow（board.length,2）;
m+
升级会员 