循环双链表的插入和删除的一些基本操作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();

}

}