循环双链表的插入和删除的一些基本操作java版

package doublelinkedlistwithcycleandsentry;


/*
 *双向循环链表的结构 
 *author  yy
 * */
public class DNode<T extends Comparable<T>> implements Comparable<DNode<T>> {


private T data;
private DNode<T> pre;
private DNode<T> next;

public DNode(){

}

   public DNode(T data){
this.data=data;
this.pre=null;
this.next=null;
}

public DNode(T data, DNode<T> pre, DNode<T> next) {
this.data = data;
this.pre = pre;
this.next = next;
}




public T getData() {
return data;
}




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




public DNode<T> getPre() {
return pre;
}




public void setPre(DNode<T> pre) {
this.pre = pre;
}




public DNode<T> getNext() {
return next;
}




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





@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((data == null) ? 0 : data.hashCode());
return result;
}


@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
DNode other = (DNode) obj;
if (data == null) {
if (other.data != null)
return false;
} else if (!data.equals(other.data))
return false;
return true;
}


@Override
public int compareTo(DNode<T> o) {
return this.data.compareTo(o.getData());
}

}

package doublelinkedlistwithcycleandsentry;


public class DoubleLinkedListWithSentry<T extends Comparable<T>> {


//哨兵
private final DNode<T> sentry=new DNode<T>();
private DNode<T> head;
public DNode<T> getHead() {
return head;
}
public DoubleLinkedListWithSentry(DNode<T> head) {
this.head = head;
}
public DoubleLinkedListWithSentry() {
this.head=sentry;
this.head.setNext(head);
this.head.setPre(head);
}

//插入节点
public void insertData(T data){
DNode<T> element=new DNode<T>(data);
element.setNext(this.head.getNext());
this.head.getNext().setPre(element);
this.head.setNext(element);
element.setPre(head);
} 
//插入的位置是从1开始的
public void insertData(T data,int pos){
if(pos<1) return ;
int len=this.size(this.head);
if(pos>len)pos=len;
DNode<T> node=this.head;
DNode<T> element=new DNode<T>(data);
for(int i=1;i<pos;i++){
node=node.getNext();
}
element.setNext(node.getNext());
node.getNext().setPre(element);
node.setNext(element);
element.setPre(node);
}

//删除元素
public boolean deleteData(T data){
DNode<T> node=this.head;
DNode<T> element=new DNode<T>(data);
DNode<T> prenode=null;
while(!node.getNext().equals(this.head)){
prenode=node;
node=node.getNext();
if(node.equals(element)){
prenode.setNext(node.getNext());
node.getNext().setPre(prenode);
node.setNext(null);
node.setPre(null);
node=null;
return true;
}
}
return false;
}

//删除指定位置的元素 第一个元素是从1开始的
public void deleteDataByPos(int pos){
if(pos<1)return ;
int len=this.size(this.head);
if(pos>len)pos=len;
DNode<T> node=this.head;
for(int i=1;i<pos;i++){
node=node.getNext();
}
node.setNext(node.getNext().getNext());
node.getNext().getNext().setPre(node);
}

//循环链表的长度
public int size(){
return this.size(this.head);
}
private int size(DNode<T> head){
DNode<T> node=head.getNext();
int count=0;
while(node!=this.head){
count++;
node=node.getNext();
}
return count;
}

//遍历链表
public void traverse(){
this.traverse(this.head);
}
private void traverse(DNode<T> head){
DNode<T> node=head.getNext();
while(node!=head){
System.out.print(node.getData()+" ");
node=node.getNext();
}
System.out.println();
}




}