【数据结构和算法分析】双链表的增，删操作

双链表的增，删操作

双链表：单链表的结点中只有一个指向直接后继结点的指针，所以，从某个结点出发只能顺着指针往后查询其他的结点靠，那如果我想访问某个结点的前一个结点，岂不只能重新从表头结点开始了？效率真低啊！换句话说，在单链表中，getNext()的时间复杂度为O(1)，而getPrior()的时间复杂度则为O(N)。为克服单链表这种单向性的缺点，我们可以利用双链表。

public class MyDulList {

/*
* 双向链表的基本实现
* 包括插入结点，删除结点，查询某一位置结点的值，修改结点的值，反回结点的位置等基本功能
*/
Node headNode;
Node tailNode;
int length;

/*
* 由结点初始化，该结点既是头结点，也是尾结点
*/
public MyDulList(Node node){
this.headNode = node;
this.tailNode = node;
length = 1;
}
/*
* 双向链表的增加结点
* @param Node node 增加的结点
*/
public void insert(Node node){
insert(node,length);
}
/*
* 双向链表的增加结点
* @param Node node 增加的结点  int index 增加的位置
*/
public void insert(Node node,int index){
if (index < 0 || index > length) {
throw new IndexOutOfBoundsException();
}
if(index == 0){
node.next = this.headNode;
this.headNode.prior = node;
headNode = node;
}else if (index == length) {
this.tailNode.next = node;
node.prior = this.tailNode;
tailNode = node;
}else{
Node otherNode = headNode;
while (index > 1) {
otherNode = otherNode.next;
index--;
}
node.next = otherNode.next;
otherNode.next.prior = node;
otherNode.next = node;
node.prior = otherNode;
}
length++;
}
/*
* 双向链表删除结点
* @param int index 删除结点的位置
*/
public void delete(int index){
if (index < 0 || index >= length) {
throw new IndexOutOfBoundsException();
}
if (index == 0 && length == 1) {
this.headNode = this.tailNode = null;
}else if (index == 0 && length != 1) {
this.headNode.next.prior = null;
headNode = this.headNode.next;
}else {
Node otherNode = this.headNode;
while (index > 1) {
otherNode = otherNode.next;
index--;
}
if(otherNode.next.next != null){
otherNode.next = otherNode.next.next;
otherNode.next.prior = otherNode;
}else {
otherNode.next = null;
this.tailNode = otherNode;
}
}
length--;
}
public void show(){
Node otherNode = this.headNode;
while (otherNode.next != null) {
System.out.print(otherNode.data+" ");
otherNode = otherNode.next;
}
System.out.println(otherNode.data);
}

/*
* 利用 prior 反向输出链表
*/
public void show_re(){
Node otherNode = this.tailNode;
while (otherNode.prior != null) {
System.out.print(otherNode.data+" ");
otherNode = otherNode.prior;
}
System.out.println(otherNode.data);
}
}

class Node{
/*
* 节点类，包括结点的值 data ,指向下一结点的指针 next,指向前一结点的指针 prior
*/
Object data;
Node prior;
Node next;

public Node(){
this.data = null;
this.prior = null;
this.next = null;
}
public Node(Object data){
this.data = data;
this.prior = null;
this.next = null;
}
public Node(Object data,Node prior,Node next){
this.data = data;
this.prior = prior;
this.next = next;
}
public boolean hasprior(){
return this.prior != null;
}
public boolean hasnext(){
return this.next != null;
}
public Node getNext(){
return this.next;
}
public Node getPrior(){
return this.prior;
}

}