研磨数据结构与算法-05双端链表与双向链表

Node节点：
/*
* 链结点，相当于是车厢
*/
public class Node {
//数据域
public long data;
//指针域
public Node next;
public Node previous;

public Node(long value) {
this.data = value;
}

/**
* 显示方法
*/
public void display() {
System.out.print(data + " ");
}
}
双端链表：
/*
* 双端链表
*/
public class FirstLastLinkList {
//头结点
private Node first;
//尾结点
private Node last;

public FirstLastLinkList() {
first = null;
last = null;
}

/**
* 插入一个结点，在头结点后进行插入
*/
public void insertFirst(long value) {
Node node = new Node(value);
if(isEmpty()) {
last = node;
}
node.next = first;
first = node;
}

/**
* 插入一个结点，从尾结点进行插入
*/
public void insertLast(long value) {
Node node = new Node(value);
if(isEmpty()) {
first = node;
} else {
last.next = node;
}
last = node;
}

/**
* 删除一个结点，在头结点后进行删除
*/
public Node deleteFirst() {
Node tmp = first;
if(first.next == null) {
last = null;
}
first = tmp.next;
return tmp;
}

/**
* 显示方法
*/
public void display() {
Node current = first;
while(current != null) {
current.display();
current = current.next;
}
System.out.println();
}

/**
* 查找方法
*/
public Node find(long value) {
Node current = first;
while(current.data != value) {
if(current.next == null) {
return null;
}
current = current.next;
}
return current;
}

/**
* 删除方法，根据数据域来进行删除
*/
public Node delete(long value) {
Node current = first;
Node previous = first;
while(current.data != value) {
if(current.next == null) {
return null;
}
previous = current;
current = current.next;
}

if(current == first) {
first = first.next;
} else {
previous.next = current.next;
}
return current;

}

/**
* 判断是否为空
*/
public boolean isEmpty() {
return (first == null);
}
}
测试：
public class TestFirstLastLinkList {
public static void main(String[] args) {

FirstLastLinkList fl = new FirstLastLinkList();
//fl.insertFirst(34);
//fl.insertFirst(56);
//fl.insertFirst(67);
//fl.display();
//
//fl.deleteFirst();
//fl.deleteFirst();
//fl.display();

fl.insertLast(56);
fl.insertLast(90);
fl.insertLast(12);

fl.display();

fl.deleteFirst();
fl.display();
}
}
双向链表：
/*
* 双向链表
*/
public class DoubleLinkList {
//头结点
private Node first;
//尾结点
private Node last;

public DoubleLinkList() {
first = null;
last = null;
}

/**
* 插入一个结点，在头结点后进行插入
*/
public void insertFirst(long value) {
Node node = new Node(value);
if(isEmpty()) {
last = node;
} else {
first.previous = node;
}
node.next = first;
first = node;
}

/**
* 插入一个结点，从尾结点进行插入
*/
public void insertLast(long value) {
Node node = new Node(value);
if(isEmpty()) {
first = node;
} else {
last.next = node;
node.previous = last;
}
last = node;
}

/**
* 删除一个结点，在头结点后进行删除
*/
public Node deleteFirst() {
Node tmp = first;
if(first.next == null) {
last = null;
} else {
first.next.previous = null;
}
first = tmp.next;
return tmp;
}

/**
* 删除结点，从尾部进行删除
*/
public Node deleteLast() {
Node tmp = last;
if(first.next == null) {
first = null;
} else {
last.previous.next = null;
}
last = last.previous;
return last;
}

/**
* 显示方法
*/
public void display() {
Node current = first;
while(current != null) {
current.display();
current = current.next;
}
System.out.println();
}

/**
* 查找方法
*/
public Node find(long value) {
Node current = first;
while(current.data != value) {
if(current.next == null) {
return null;
}
current = current.next;
}
return current;
}

/**
* 删除方法，根据数据域来进行删除
*/
public Node delete(long value) {
Node current = first;
while(current.data != value) {
if(current.next == null) {
return null;
}
current = current.next;
}

if(current == first) {
first = first.next;
} else {
current.previous.next = current.next;
}
return current;

}

/**
* 判断是否为空
*/
public boolean isEmpty() {
return (first == null);
}
}
测试：
public class TestDoubleLinkList {
public static void main(String[] args) {
DoubleLinkList dl = new DoubleLinkList();
dl.insertLast(45);
dl.insertLast(56);
dl.insertLast(90);
dl.display();

while(!dl.isEmpty()) {
dl.deleteFirst();
dl.display();
}
}
}