双向循环链条实现LinkList

1.Node 节点定义：

package data_table.syn.com.common.util;
/**
 * 简单封装Node节点
 * @author Administrator
 *
 */
public class Node {

private Object value;// 值
private Node next; // 下一个对象的地址值
private Node before; // 上一个对象的地址值
public Node getBefore() {
return before;
}
public void setBefore(Node before) {
this.before = before;
}
public Object getValue() {
return value;
}
public void setValue(Object value) {
this.value = value;
}

public Node getNext() {
return next;
}
public void setNext(Node next) {
this.next = next;
}
public Node() {
super();
// TODO Auto-generated constructor stub
}
public Node(Object value) {
super();
this.value = value;
}



}

2.双向循环实现LinkList:

package data_table.syn.com.common.util;


import java.util.zip.Inflater;


public class MyLinkList2 {

    private Node head=null;
private int size=0;
public int size() {
return size;
}
/**
* 添加值
* @param value
*/
public void add(Object value) {
Node newNode=new Node(value);
if (head==null) {
head=newNode;
}else {
Node temp=head;
// 获取最后一个节点
if (head.getBefore()!=null) {
temp=head.getBefore();

}

//循环结束temp为最后node
temp.setNext(newNode);
newNode.setBefore(temp);// 上一个节点
head.setBefore(newNode); // 记录最后一个节点
}
size++;
}
/**
*获取指定位置的值 
* @param index
* @return
*/
public Object get(int index) {
Node temp=head;
int len=size/2; // 当len=index前后都一样
if (index<len) {   // 从前面遍历
for(int i=0;i<index;i++) {
temp=temp.getNext();
}
}else {
// 从后面遍历

for(int i=size-1;i>=index;i--) {
temp=temp.getBefore();
}
}


return temp.getValue();

}
/**
* 给指定位置设置值
* @param index
* @param value
*/
public void set(int index,Object value) {
Node temp=head;

int len=size/2; // 当len=index前后都一样
if (index<len) {   // 从前面遍历
for(int i=0;i<index;i++) {
temp=temp.getNext();
}
}else {
// 从后面遍历

for(int i=size-1;i>=index;i--) {
temp=temp.getBefore();
}
}
/*for(int i=0;i<index;i++) {
temp=temp.getNext();

}*/
temp.setValue(value);

} 
/**
* 清空数据
*/
public void clear() {
size=0;
head=null;

}
/**
* 删除指定位置值
* @param index
*/
public void removeAt(int index) {
if (index==0) {
head.getNext().setBefore(head.getBefore());
head=head.getNext();
}
Node temp=head;
int len=size/2; // 当len=index前后都一样
if (index<len) {   // 从前面遍历
for(int i=0;i<index-1;i++) {
temp=temp.getNext();
}
temp.setNext(temp.getNext().getNext());
temp.getNext().getNext().setBefore(temp);

}else {
// 从后面遍历

for(int i=size-1;i>=index+1;i--) {
temp=temp.getBefore();
}
temp.setBefore(temp.getBefore().getBefore());
temp.getBefore().getBefore().setNext(temp);
}

size--;
}
public void toStrings() {
for(int i=0;i<size;i++) {
System.out.print(get(i));
}
}


}

3.单链条实现与双向链条实现LinkList性能比较：

a)添加/删除：单链条添加元素，需要遍历整个链条。双向链条直接获取最后一个元素添加，性能高的多。

b)get/set 获取元素：但链条获取元素，遍历整个列表；双向链表可以从两端循环遍历，性能高于单链条。

综合比较双向循环链表更高效。