双链表的操作java版本

package doublelinkedlist;


/*
 *双向链表的结构 
 *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 doublelinkedlist;


/*
 * 不带哨兵的双向链表的操作
 * yy
 * */
public class DLinkedList<T extends Comparable<T>> {

private DNode<T> head;


public DNode<T> getHead() {
return head;
}


public DLinkedList(){
this.head=null;
}

public DLinkedList(DNode<T> head) {
this.head = head;
}

//插入节点从头开始插入
public void insertData(T data){
DNode<T> node=new DNode<T>(data);
if(this.head==null){
this.head=node;
}else{
node.setNext(this.head);
this.head.setPre(node);
this.head=node;
}
}
//删除指定的元素
public void deleteData(T data){
DNode<T> node=this.head;
DNode<T> prenode=null;
DNode<T> delnode=new DNode<T>(data);
while(node!=null){
if(node.equals(delnode)){
if(node.equals(this.head)){
this.head=node.getNext();
node.getNext().setPre(null);
node.setNext(null);
node.setPre(null);
node=null;
break;
}else{
prenode.setNext(node.getNext());
if(node.getNext()!=null){
node.getNext().setPre(prenode);
}
node.setNext(null);
node.setPre(null);
node=null;
break;
}
}
prenode=node;
node=node.getNext();
}
}
//查找某个元素，返回在链表中的位置
public int getPos(T data){
return this.getpos(this.head, data);
}
private int getpos(DNode<T> head,T data){
DNode<T> node=head;
int pos=0;
while(node!=null){
pos++;
if(node.equals(new DNode(data))){
break;
}
node=node.getNext();
}
if(node==null)return 0;
return pos;
}

//计算链表的长度
public int size(){
return this.size(this.head);
}
private int size(DNode<T> head){
DNode<T> node=head;
int count=0;
while(node!=null){
count++;
node=node.getNext();
}
return count;
}
//删除链表在任意的位置处
//链表的第一个位置是从1开始的
public boolean deleteByPos(int pos){
return this.deleteByPos(this.head, pos);
}
private boolean deleteByPos(DNode<T> head,int pos){
if(pos<1)return false;
int len=this.size(this.head);
if(pos>len)return false;
DNode<T> node=head;
DNode<T> prenode=null;
if(pos==1){
this.head=node.getNext();
node.getNext().setPre(null);
node.setNext(null);
node.setPre(null);
node=null;
return true;
}
for(int i=1;i<pos;i++){
prenode=node;
node=node.getNext();
}
prenode.setNext(node.getNext());
if(node.getNext()!=null){
node.getNext().setPre(prenode);
}
node.setNext(null);
node.setPre(null);
node=null;
return true;
}

//在链表的任意位置插入一个值
public void insertDataByPos(T data,int pos){
this.insertDataByPos(this.head, new DNode(data), pos);
}

private void insertDataByPos(DNode<T> head,DNode<T> element,int pos){
if(pos<1)return ;
int len=this.size(head);
if(pos>len)pos=len;
DNode<T> node=head;
DNode<T> prenode=null;
if(pos==1){
element.setNext(this.head);
element.setPre(null);
this.head=element;
return ;
}
for(int i=1;i<pos;i++){
prenode=node;
node=node.getNext();
}
element.setNext(node);
node.setPre(element);
prenode.setNext(element);
element.setPre(prenode);
}
//遍历双向链表
public void travense(){
this.travense(this.head);
}
private void travense(DNode<T> head){
DNode<T> node=head;
while(node!=null){
System.out.print(node.getData()+" ");
node=node.getNext();
}
System.out.println();
}








}