大话数据结构（八）Java程序——双向链表的实现 线性链表——双向链表

小企鹅ITgo

大话数据结构（八）Java程序——双向链表的实现

线性链表——双向链表

双向链表定义：

双向链表（double linked list): 是在单表单的每个结点中，再设置一个指向前驱结点的指针域。因此，在双向链表中的结点都有两个指针域，一个指向前驱，一个指向后继。

双向链表的存储结构

typedef struts DulNode{
Element data;
Struct DulNode *prior;前驱指针
Struct DulNode *next;后继指针
}DulDouble, *DulLinkList;

双向链表的插入与删除

双向链表的插入：

假设结点为s,要将结点插入到结点p和p->next中，我们需要下面几步：
s.prev = p;
s.next = p.next;
p.next.prev = s;
p.next = s;
总结起来就是：先搞定s的前驱后继，再搞定后结点的前驱，最后解决前驱结点的后继

双向链表的删除：

要删除p结点，只需要两个步骤：
p.next.prev = p.prev;
p.prev.next = p.next;
free(p);

总结：

相对于单链表，双向链表多了一个指针域，空间上要占用略多一点，但它有很好的对称性，使得对某个结点的前后结点操作更容易，可以提高算法的时间性能，这是牺牲空间换取的。
Java程序实现双链表：

package com.aclie.dataStructe4.sqeList;

public class MyDoubleLinkList {
private int length =0;//当前长度
private Node head;//头结点
private Node tail;//当前结点结点

public MyDoubleLinkList(){
initLink();
}
public void initLink(){
head  = new Node(null);
tail = new Node(null);
this.head = tail;
length++;
}

//获取链表长度
public int getSize(){
return length;
}
//判断链表是否为空
public boolean getEmpty(){
return getSize()==0;
}
//根据索引查找元素  从第一个有效值开始
public Node getNode(int index){
Node p;
if(index < 0 || index > length ){
System.out.println("参数错误");
}
if(index < this.length/2){
p = this.head;
for(int i=0; i<index; i++){
p = p.next;
}
}else{
p = this.tail;
for(int i= length; i>index;i--){
p = p.prev;
}
}
return p;
}

public Object getData(int index){
return getNode(index).data;
}

//在头结点处插入
public boolean addHead(Object e){
//前驱引用为null，后继为node
Node node = new Node(e, null, this.head);
//改变头结点的前驱后继
this.head.prev = node;
this.head = node;
if(tail == null){
tail =  this.head;
}
length++;
return true;
}
//在尾结点插入
public boolean addTail(Object e){
if(this.head == null){
this.head = new Node(e,null,null);
this.tail = this.head;
}else{
Node node = new Node(e,this.tail,null);
this.tail.next = node;
this.tail = node;

}
length++;
return true;

}
//在指定位置插入元素
public boolean addData(int index,Object ele){
if(index <0 || index > this.length){
System.out.println("参数错误");
}
if(this.head == null){
this.addTail(ele);//用尾插法
}else{
if(index == 0){
addHead(ele);//用头插法
}else{
Node p = this.getNode(index);//要插入处的结点
Node n = p.next;
Node node = new Node(ele,p,n);//要插入的结点
n.prev = node;
p.next = node;
length ++;

}
}

return true;
}

public void removeData(int index){
if(index < 0 || index > length){
System.out.println("参数错误");
}else{
Node del = null;
if(index == 0){
del = this.head;
this.head = this.head.next;
this.head.prev = null;
length--;
}else if(index == (length-1)){
Node p = this.getNode(index-1);//得到要删除结点的前驱结点
del = p.next;//要删除的结点
p.next = del.next;
if(del.next != null){
del.next.prev = p;
}
del.next = null;
del.prev = null;
length --;

this.tail.next = null;
this.tail.prev = p;
this.tail = p;
}
else{
Node p = this.getNode(index-1);//要删除结点的前驱结点
del = p.next;//要删除的结点
p.next = del.next;
if(del.next != null){
del.next.prev = p;
}
del.prev = null;
del.next = null;
length--;
}

}
}
//打印所有链表中的元素
public void print(){
Node current = this.head;
while(current != null){
System.out.println(current.data);
current = current.next;
}
}
//反向打印链表
public void reversePrint(){
Node current = this.tail;
while(current != null){
System.out.println(current.data);
current = current.prev;
}
}
public static void main(String args[]){
MyDoubleLinkList linkList = new MyDoubleLinkList();
linkList.addHead("aaaa");
//        System.out.println(linkList.getData(1));
linkList.addTail("bbbb");
//        System.out.println(linkList.getData(3));
linkList.addData(2, "eeee");
//        linkList.print();
linkList.removeData(2);
linkList.print();
System.out.println(".....");
linkList.reversePrint();
}

}
class Node{
Node prev;//指针域中前驱
Node next;//指针域中后继
Object data;//数据域
public Node(Node current){
prev = current;
next = current;
}
//双链表前驱后继及数字域
public Node(Object d, Node p,Node n){
this.data = d;
this.prev = p;
this.next = n;
}
public Node getPrev() {
return prev;
}
public void setPrev(Node prev) {
this.prev = prev;
}
public Node getNext() {
return next;
}
public void setNext(Node next) {
this.next = next;
}

}