双链表的操作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();

}

}