Java基础复习笔记04数据结构线性表Word下载.docx

Java基础复习笔记04数据结构线性表Word下载.docx

《Java基础复习笔记04数据结构线性表Word下载.docx》由会员分享，可在线阅读，更多相关《Java基础复习笔记04数据结构线性表Word下载.docx（20页珍藏版）》请在冰豆网上搜索。

*/

publicclassMyArrayList<

implementsList<

{

//默认的数组长度

privatefinalintDefSize=16;

//临时变量数组

privateObject[]objects;

//记录实实在在的元素个数

privateintelementSize;

publicMyArrayList（）{

objects=newObject[DefSize];

}

/**

*增加元素，实际上就是往最后一位出入数据

@Override

publicbooleanadd（Ee）{

add（elementSize,e）;

returntrue;

*按位索引插入元素

publicvoidadd（intindex,Eelement）{

if（index==elementSize）{

objects[index]=element;

elementSize++;

return;

}

for（inti=elementSize-1;

i>

=0;

i--）{

if（i==index）{

intmovedSize=elementSize-i-1;

System.arraycopy（objects,index+1,objects,index,movedSize）;

objects[index]=element;

elementSize++;

}

*清除所有元素

publicvoidclear（）{

for（inti=0;

i<

elementSize;

i++）{

objects[i]=0;

elementSize=0;

*判断集合是否包含了某个元素

publicbooleancontains（Objecto）{

for（Objectobject:

objects）{

if（object!

=null&

&

object.equals（o））{

returntrue;

returnfalse;

*获得某位置索引的元素

publicEget（intindex）{

return（E）objects[index];

returnnull;

*实现元素定位

publicintindexOf（Objecto）{

if（o.equals（objects[i]））{

returni;

return-1;

*是否是空集合

publicbooleanisEmpty（）{

if（elementSize==0）{

returntrue;

publicintlastIndexOf（Objecto）{

if（objects==null||objects.length==0）{

return-1;

if（objects[i]==o）{

*删除某个元素

publicbooleanremove（Objecto）{

objects[i]=null;

System.arraycopy（objects,i+1,objects,i,movedSize）;

elementSize--;

*删除某个索引下的元素

publicEremove（intindex）{

if（objects[i].equals（objects[index]））{

*对已有位置设置新的元素值

publicEset（intindex,Eelement）{

objects[index]=null;

returnelement;

publicintsize（）{

//TODOAuto-generatedmethodstub

returnelementSize;

publicStringtoString（）{

StringBufferstr=newStringBuffer（"

["

）;

str.append（"

+objects[i].toString（）+"

],"

if（elementSize>

0）{

returnstr.substring（0,str.lastIndexOf（"

"

））+"

]"

;

returnstr.append（"

）.toString（）;

实际上实现Java标准的List接口还需要实现其他一些方法，只不过因为篇幅原因，在此只能实现一些核心方法，而且说实在的，根本谈不上健壮性，更不可能投入使用，线程安全也存在问题，这只是演示一下用数组实现顺序线性表的核心算法罢了。

所以说学习数据结构实际上是考验算法功底。

一个数据结构的事先是否最优，完全是底层算法的实现是否最优。

顺序线性表最大的特点就是物理上存储空间连续，内存资源使用比较节省、但是进行增加、删除元素的时候就得让别的元素挪挪地方了，用时间换取了空间的连续性，显得有点牵一发而动全身。

如果是查找某个元素操作的时候就是需要遍历整体集合。

简单测试代码如下：

publicstaticvoidmain（String[]args）{

MyArrayList<

String>

list=newMyArrayList<

（）;

list.add（"

1"

2"

3"

System.out.println（list）;

list.remove（"

System.out.println（list.contains（"

））;

System.out.println（list.isEmpty（））;

list.clear（）;

执行结果

[[1],[2],[3]]

[[1],[2]]

true

false

[]

5.线性表的非顺序实现——链式表

相对于数组的顺序存储，还可以定义一个比较特殊的链表结构，每个链表节点在内存中不一定是一块连续的区域，链表节点记录了与自身节点相关的下一个节点的位置信息。

如果链表节点仅仅记录了与其下一个Next节点的位置信息，而没有记录上一个Prev节点的信息，那么这叫做单向链表结构。

如果此节点不仅仅记录了下一个节点的信息，还记录了上一个节点的信息，那么这个情况叫做双向链表结构。

我们就用双向链表实现Java标准的List<

接口。

（实际上Java提出了一堆标准，实际上就是接口，而sun自己为自己定义的标准接口还提供了实现类，咱们一般用的就是基于sun提出标准的sun自己的实现类）。

如下代码

*自己实现的linkedList

publicclassMyLinkedList<

*双向链表结构

publicclassLinkNode{

//真正的数据域

privateEdate;

//记录上一个节点

privateLinkNodeprevLinkNode;

//记录下一个节点

privateLinkNodenextLinkNode;

publicLinkNode（）{

publicLinkNode（Edate,LinkNodeprevLinkNode,LinkNodenextLinkNode）{

this.date=date;

this.prevLinkNode=prevLinkNode;

this.nextLinkNode=nextLinkNode;

//结点个数

privateintnodeSize;

//头结点

privateLinkNodeheadNode;

//尾巴节点

privateLinkNodetailNode;

publicMyLinkedList（）{

headNode=null;

tailNode=null;

*采用尾端元素增加法，增加新元素

publicbooleanadd（Eelement）{

if（nodeSize==0）{

headNode=newLinkNode（element,null,tailNode）;

}else{

if（tailNode==null）{

tailNode=newLinkNode（element,headNode,null）;

headNode.nextLinkNode=tailNode;

nodeSize++;

LinkNodelinkNode=tailNode;

tailNode=newLinkNode（element,linkNode,null）;

linkNode.nextLinkNode=tailNode;

nodeSize++;

*根据索引号查找节点

*

*@paramindex

*@return

publicLinkNodefindLinkNodeByIndex（intindex）{

LinkNodelinkNodeNowTemp=headNode;

nodeSize;

returnlinkNodeNowTemp;

linkNodeNowTemp=linkNodeNowTemp.nextLinkNode;

*按索引位置添加元素

add（element）;

//按照元素先建立新的node

LinkNodelinkNodeNew=newLinkNode（element,null,null）;

//找到索引处的节点

LinkNodelinkNodeNowTemp=findLinkNodeByIndex（index）;

//找出索引处节点的上一个node

LinkNodelinkNodePrev=linkNodeNowTemp.prevLinkNode;

//上一个节点的下一个节点指向新node

linkNodePrev.nextLinkNode=linkNodeNew;

//新节点的上一个节点指向原位置节点上一个节点

linkNodeNew.prevLinkNode=linkNodePrev;

//新节点的下一个节点指向原位置节点

linkNodeNew.nextLinkNode=linkNodeNowTemp;

//原节点的上一个节点指向新节点

linkNodeNowTemp.prevLinkNode=linkNodeNew;

nodeSize++;

*清除所有Node元素资源

if（linkNodeNowTemp!

=tailNode&

linkNodeNowTemp!

=headNode）{

linkNodeNowTemp=linkNodeNowTemp.nextLinkNode;

linkNodeNowTemp.prevLinkNode.nextLinkNode=null;

linkNodeNowTemp.prevLinkNode.prevLinkNode=null;

linkNodeNowTemp.prevLinkNode.date=null;

linkNodeNowTemp.prevLinkNode=null;

}elseif（linkNodeNowTemp==tailNode）{

}elseif（linkNodeNowTemp==headNode）{

linkNodeNowTemp.nextLinkNode=null;

nodeSize=0;

*是否包含此元素

publicbooleancontains（Objectobject）{

if（object==linkNodeNowTemp.date）{

LinkNodelinkNode=findLinkNodeByIndex（index）;

if（linkNode!

=null）{

returnlinkNode.date;

returnnodeSize==0;

*删除元素

if（linkNodeNowTemp.date==o）{

if（linkNodeNowTemp!

LinkNodelinkNewPrev=linkNodeNowTemp.prevLinkNode;

LinkNodelinkNewNext=linkNodeNowTemp.nextLinkNode;

linkNewPrev.nextLinkNode=linkNewNext;

linkNewNext.prevLinkNode=linkNewPrev;

linkNodeNowTemp.nextLinkNode=null;

linkNodeNowTemp.prevLinkNode=null;

linkNodeNowTemp.date=null;

linkNodeNowTemp=null;

nodeSize--;

returntrue;

}elseif（linkNodeNowTemp==tailNode）{

tailNode=linkNodeNowTemp.prevLinkNode;

}elseif（linkNodeNowTemp==headNode）{

headNode=linkNodeNowTemp.nextLinkNode;

}

*删除位置标记下的元素

if（index==i）{

LinkNodelinkNewPrev=linkNodeNowTemp.prevLinkNode;