Java数据结构与经典算法高手必会.docx
《Java数据结构与经典算法高手必会.docx》由会员分享，可在线阅读，更多相关《Java数据结构与经典算法高手必会.docx（102页珍藏版）》请在冰豆网上搜索。
Java数据结构与经典算法高手必会
大O表示法：
粗略的量度方法即算法的速度是如何与数据项的个数相关的
算法大O表示法表示的运行时间
线性查找O（N）
二分查找O（logN）
无序数组的插入O
（1）
有序数组的插入O（N）
无序数组的删除O（N）
有序数组的删除O（N）
O
（1）是最优秀的,O（logN）良好,O（N）还可以,O（N2）稍差（在冒泡法中见到）
排序
publicclassJWzw{
//插入排序
publicvoidinsertArray（Integer[]in）{
inttem=0;
intnum=0;
intupnum=0;
for（inti=0;ifor（intj=i-1;j>=0;j--）{
num++;
if（in[j+1]tem=in[j+1];
in[j+1]=in[j];
in[j]=tem;
upnum++;
}
else
{
break;
}
}
}
for（inti=0;iSystem.out.print（in[i]）;
if（i{
System.out.print（","）;
}
}
System.out.println（）;
System.out.println（"插入排序循环次数:
"+num）;
System.out.println（"移动次数：
"+upnum）;
System.out.print（"\n\n\n"）;
}
//选择排序
publicvoidchooseArray（Integer[]in）{
inttem=0;
intnum=0;
intupnum=0;
for（inti=0;i{
for（intj=i;jnum++;
if（in[j+1]tem=in[j+1];
in[j+1]=in[j];
in[j]=tem;
upnum++;
}
}
}
for（inti=0;iSystem.out.print（in[i]）;
if（i{
System.out.print（","）;
}
}
System.out.println（）;
System.out.println（"选择排序循环次数:
"+num）;
System.out.println（"移动次数：
"+upnum）;
System.out.print（"\n\n\n"）;
}
//冒泡排序
publicvoidefferArray（Integer[]in）{
inttem=0;
intnum=0;
intupnum=0;
for（inti=0;ifor（intj=i;j{
num++;
if（in[j+1]tem=in[j+1];
in[j+1]=in[i];
in[i]=tem;
upnum++;
}
}
}
for（inti=0;iSystem.out.print（in[i]）;
if（i{
System.out.print（","）;
}
}
System.out.println（）;
System.out.println（"冒泡排序循环次数:
"+num）;
System.out.println（"移动次数：
"+upnum）;
System.out.print（"\n\n\n"）;
}
//打印乘法口诀
publicvoidprintMulti（）{
for（intj=1;j<10;j++）{
for（inti=1;i<=j;i++）{
System.out.print（i+"*"+j+"="+j*i+"\t"）;
}
System.out.print（"\t\n"）;
}
System.out.print（"\n\n\n"）;
}
//打印N*1+N*2+N*3=num的所有组合
publicvoidprintNumAssemble（intnum）{
for（inti=0;ifor（intj=0;jfor（intin=0;inif（i*1+j*2+in*3==num）{
System.out.println（"小马"+i+",\t中马"+j+",\t大马"+in）;
}
}
}
}
}
/**
*@paramargs
*/
publicstaticvoidmain（String[]args）{
JWzwjwzw=newJWzw（）;
intnum=3;
jwzw.printMulti（）;//打印乘法口诀
jwzw.printNumAssemble（100）;//打印N*1+N*2+N*3=num的所有组合
Integerin[]={8,89,5,84,3,45,12,33,77,98,456,878,654,213,897};
jwzw.efferArray（in）;//冒泡排序
Integerin1[]={8,89,5,84,3,45,12,33,77,98,456,878,654,213,897};
jwzw.insertArray（in1）;//插入排序
Integerin2[]={8,89,5,84,3,45,12,33,77,98,456,878,654,213,897};
jwzw.chooseArray（in2）;//选择排序
//inti=num++;
//System.out.println（i）;
System.out.println（1000>>2）;
}
}
优先级队列
classPriorityQueue{
privatelong[]a=null;
privateintnItems=0;
privateintmaxSize=0;
publicPriorityQueue（intmaxSize）{
a=newlong[maxSize];
this.maxSize=maxSize;
nItems=0;
}
publicvoidinsert（longl）{
//优先级队列的插入不是队尾,而是选择一个合适的按照某种顺序插入的
//当队列长度为0时，如下
//不为0时,将所有比要插入的数小的数据后移,这样大的数就在队列的头部了
inti=0;
if（nItems==0）{
a[0]=l;
}else{
for（i=nItems-1;i>=0;i--）{
if（la[i+1]=a[i];
else
break;
}
a[i+1]=l;
}
nItems++;
}
publiclongremove（）{
//移出的是数组最上端的数，这样减少数组元素的移动
returna[--nItems];
}
publicbooleanisEmpty（）{
return（nItems==0）;
}
publicbooleanisFull（）{
return（nItems==maxSize）;
}
publicintsize（）{
returnnItems;
}
}
publicclassduilie{//队列体类
privateduilies;
privateStringdata;
duilie（Stringdata）{
this.data=data;
}
publicStringgetData（）{
returndata;
}
publicvoidsetData（Stringdata）{
this.data=data;
}
publicduiliegetS（）{
returns;
}
publicvoidsetS（duilies）{
this.s=s;
}
}
publicclassduiliecz{//队列操作类
/**
*@paramargs
*/
privateinti=0;//队列长
privateduilietop=newduilie（""）;//队列头
privateduilieend=newduilie（""）;//队列尾
publicvoidadd（Strings）{//添加队列
duiliem=newduilie（s）;
if（i!
=0）{
m.setS（top.getS（））;
top.setS（m）;
}else{
top.setS（m）;
end.setS（m）;
}
i++;
}
队列
publicvoiddel（）{//删除队尾
if（i==0）{
return;
}elseif（i==1）{
top.setS（null）;
end.setS（null）;
}else{
duilietop1=newduilie（""）;//队列底查找用缓存
top1.setS（top.getS（））;
while（!
top1.getS（）.getS（）.equals（end.getS（）））{
top1.setS（top1.getS（）.getS（））;
}
end.setS（top1.getS（））;
}
i--;
}
publicstaticvoidmain（String[]args）{
//TODOAuto-generatedmethodstub
duilieczm=newduiliecz（）;
m.add（"1"）;
m.add（"2"）;
m.add（"3"）;
m.add（"4"）;
for（intn=0;n<4;n++）{
m.del（）;
}
}
publicintgetI（）{
returni;
}
publicduiliegetEnd（）{
returnend;
}
publicduiliegetTop（）{
returntop;
}
}
栈
publicclassStack{
int[]arr;
intlen=0;
publicStack（）{
arr=newint[100];
}
publicStack（intn）{
arr=newint[n];
}
publicintsize（）{
returnlen+1;
}
//扩大数组
publicvoidresize（）{
int[]b=newint[arr.length*2];
System.arraycopy（arr,0,b,0,arr.length）;
arr=b;
}
publicvoidshow（）{
for（inti=0;iSystem.out.print（arr[i]+""）;
}
System.out.println（）;
}
//进栈
publicvoidpush（inta）{
if（len>=arr.length）
resize（）;
arr[len]=a;
len++;
}
//出栈
publicintpop（）{
if（len==0）{
System.out.println（）;
System.out.println（"stackisempty!
"）;
return-1;
}
inta=arr[len-1];
arr[len-1]=0;
len--;
returna;
}
}
链表
classNode{
Objectdata;
Nodenext;
publicNode（Objectdata）{
setData（data）;
}
publicvoidsetData（Objectdata）{
this.data=data;
}
publicObjectgetData（）{
returndata;
}
}
classLink{
Nodehead;
intsize=0;
publicvoidadd（Objectdata）{
Noden=newNode（data）;
if（head==null）{
head=n;
}else{
Nodecurrent=head;
while（true）{
if（current.next==null）{
break;
}
current=current.next;
}
current.next=n;
}
size++;
}
publicvoidshow（）{
Nodecurrent=head;
if（current!
=null）{
while（true）{
System.out.println（current）;
if（current==null）{
break;
}
current=current.next;
}
}else{
System.out.println（"linkisempty"）;
}
}
publicObjectget（intindex）{
//....
}
publicintsize（）{
returnsize;
}
}
单链表
classNode//节点类，单链表上的节点
{
Stringdata;//数据域，存放String类的数据
Nodenext;//指向下一个节点
Node（Stringdata）{
this.data=data;//构造函数
}
Stringget（）{
returndata;//返回数据
}
}
classMyLinkList//链表类
{
Nodefirst;//头节点
intsize;//链表长度
MyLinkList（Stringarg[]）{
//Nodefirst=newNode（"head"）;//生成头节点
first=newNode（"head"）;//J.F.这里不需要定义局部变量first
//如果定义了局部变量，那成员变量first就一直没有用上
//所以，它一直为空
size=0;
Nodep=first;
for（inti=0;i{
Nodeq=newNode（arg[i]）;
q.next=p.next;//每一个节点存放一个arg数组中的元素
p.next=q;
p=p.next;
size++;
}
}
MyLinkList（）//无参数构造函数
{
//Nodefirst=newNode（"head"）;
first=newNode（"head"）;//J.F.这里犯了和上一个构造方法同样的错误
size=0;
}
intsize（）//返回链表长度
{
returnsize;
}
voidinsert（Nodea,intindex）//将节点a插入链表中的第index个位置
{
Nodetemp=first;
for（inti=0;itemp=temp.next;//找到插入节点的前一节点
}
a.next=temp.next;//插入节点
temp.next=a;
size++;
}
Nodedel（intindex）//删除第index个节点，并返回该值
{
Nodetemp=first;
for（inti=0;itemp=temp.next;//找到被删除节点的前一节点
}
Nodenode=temp.next;
temp.next=node.next;
size--;//删除该节点，链表长度减一
returnnode;
}
voidprint（）//在屏幕上输出该链表（这段程序总是出错，不知道错在哪里）
{
Nodetemp=first;
for（inti=1;i{
temp=temp.next;
System.out.print（temp.get（）+"->"）;
}
}
voidreverse（）//倒置该链表
{
for（inti=0;iinsert（del（size-1）,0）;//将最后一个节点插入到最前
//J.F.最后一个节点的index应该是size-1
//因为第一个节点的index是0
}
}
Stringget（intindex）//查找第index个节点，返回其值
{
if（index>=size）{
returnnull;
}
Nodetemp=first;
for（inti=0;itemp=temp.next;//找到被查找节点的前一节点
}
returntemp.next.get（）;
}
}
classMyStack//堆栈类，用单链表实现
{
MyLinkListtmp;
Nodetemp;
MyStack（）{
//MyLinkListtmp=newMyLinkList（）;
tmp=newMyLinkList（）;//J.F.和MyLinkList构造方法同样的错误
}
voidpush（Stringa）//压栈，即往链表首部插入一个节点
{
Nodetemp=newNode（a）;
tmp.insert（temp,0）;
}
Stringpop（）//出栈，将链表第一个节点删除
{
Nodea=tmp.del（0）;
returna.get（）;
}
intsize（）{
returntmp.size（）;
}
booleanempty（）//判断堆栈是否为空
{
if（tmp.size（）==0）
returnfalse;
else
returntrue;
}
}
publicclassMyLinkListTest//测试程序部分
{
publicstaticvoidmain（Stringarg[]）//程序入口
{
if（（arg.length==0）||（arg.length>10））
System.out.println（"长度超过限制或者缺少参数"）;
else{
MyLinkListll=newMyLinkList（arg）;//创建一个链表
ll.print（）;//先输出该链表（运行到这一步抛出异常）
ll.reverse（）;//倒置该链表
ll.print（）;//再输出倒置后的链表
Stringdata[]=newString[10];
inti;
for（i=0;idata[i]=ll.get（i）;//将链表中的数据放入数组
}
//sort（data）
升级会员 