数据结构（三）---双向循环链表的实现---java版

节点设置

package com.cn.hbut.domain;


/**
 * @author Administrator
 * 双向循环链表的节点设置
 */
public class DNode {
//节点，前驱与后继
DNode prior,next;
//数据
Object data;
public DNode(DNode prior, DNode next, Object data) {
this.prior = prior;
this.next = next;
this.data = data;
}

public DNode() {
this(null,null,null);
}


public DNode getPrior() {
return prior;
}


public void setPrior(DNode prior) {
this.prior = prior;
}


public DNode getNext() {
return next;
}


public void setNext(DNode next) {
this.next = next;
}


public Object getData() {
return data;
}


public void setData(Object data) {
this.data = data;
}


@Override
public String toString() {
return "DNode [prior=" + prior + ", next=" + next + ", data=" + data
+ "]";
}



}

--------------------------------------------------------------------------------------------

具体的实现

package com.cn.hbut.daoImpl;


import com.cn.hbut.dao.DefineList;
import com.cn.hbut.domain.DNode;


public class DList implements DefineList{
DNode d1;
int size;
//创建一个双向链表，数据为数组a里面的数据
public DList(Object []a) {
d1 = new DNode();
d1.setNext(d1);
d1.setPrior(d1);
for(int i=a.length-1;i>=0;i--){
DNode p=new DNode(d1,d1.getNext(),a[i]);
//记得把p的下一个节点的前驱设置为p
d1.getNext().setPrior(p);
d1.setNext(p);


}
size=a.length;
}
public DList(){
//创建一个双向链表，数据域为null
size=0;
d1 = new DNode();
d1.setPrior(d1);
d1.setNext(d1);
}
//取双向循环链表中的第i个节点
public DNode index(int i){
if(i<0||i>size){
return null;
}
//第0个节点并没有设置值
if(i==0){
return d1;
}
//从第一个节点开始有数据
int index=1;
//第二个节点
DNode p = d1.getNext();
while((index<i)&&(p!=d1)){
p=p.getNext();
index++;
}
return p;
}

@Override
public void clear() {
d1 = new DNode();
d1.setNext(d1);
d1.setPrior(d1);
size=0;

}
//获取第i个节点的对象
@Override
public Object gete(int i) {
if(i<0||i>size){
return null;
}
return index(i).getData();
}


@Override
public int length() {

return size;
}
//获取某个元素的位置
@Override
public int loc(Object e) {
for(int i=0;i<size;i++){
if(gete(i).equals(e)){
return i;
}
}
return -1;
}
//在位置loc插入元素e
@Override
public boolean inset(int loc, Object e) {
if(loc<0||loc>size){
return false;
}
//需要插入的前一个节点
DNode p=index(loc);

//等待插入的节点
DNode node = new DNode(p, p.getNext(), e);
p.setNext(node);
p.getNext().setPrior(node);
size++;
return true;
}


@Override
public Object dele(int loc) {
if(loc<0||loc>size){
return null;
}
//删除节点的前一个节点
DNode p=index(loc-1);
//需要删除的节点
DNode q=index(loc);

p.setNext(q.getNext());
q.getNext().setPrior(p);
size--;
return q.getData();
}
//判断是否已满
@Override
public boolean full() {
return false;
}
//判断是否为空
@Override
public boolean empty() {
return d1.getNext()==d1;
}

public DNode getD1() {
return d1;
}
public void setD1(DNode d1) {
this.d1 = d1;
}
public int getSize() {
return size;
}
public void setSize(int size) {
this.size = size;
}
//程序主入口，测试双向循环链表
public static void main(String[] args) {
System.out.println("run...");
//创建一个对象数组
Object [] a = {1,3,5};
//创建一个双向循环链表，初始化n个节点
DList dlist = new DList(a);
//取第一个节点
DNode node=dlist.index(1);
//打印第一个节点的值
System.out.println("获取的第1个节点的值:"+node.getData());
//在第i个节点插入一个节点后为,1,6,3,5
dlist.inset(1, 6);
System.out.println("获取的第2个节点的值:"+dlist.gete(2));
System.out.println("双向链表的大小:"+dlist.size);
System.out.println("删除的节点:"+dlist.dele(2));
System.out.println("获取的第2个节点的值:"+dlist.gete(2));
System.out.println("双向链表的大小:"+dlist.size);
System.out.println("over...");
}
}