线性表—双链表

1.基础知识

a.双链表结点的结构：其由前序元素地址，数据域，后继元素地址组成。

b.双链表结点的连接
方法：先声明该结点，可以在内部也可以利用其特性来表明前序结点和后继结点是什么，之后同时还需要说明“其前序结点的后继地址为该结点”和”其后继结点的前序地址为该结点。
（本质：双向）

 

2.循环双链表的实现

线性表接口LList

package com.clarck.datastructure.dlinked;

/**
* 线性表接口LList，描述线性表抽象数据类型，泛型参数T表示数据元素的数据类型
* 
* @author clarck
*
*/
public interface LList<T> {
/**
* 判断线性表是否空
* @return
*/
boolean isEmpty();

/**
* 返回线性表长度
* @return
*/
int length();

/**
* 返回第i（i≥0）个元素
* @param i
* @return
*/
T get(int i);

/**
* 设置第i个元素值为x
* @param i
* @param x
*/
void set(int i, T x);

/**
* 插入x作为第i个元素
* @param i
* @param x
*/
void insert(int i, T x);

/**
* 在线性表最后插入x元素
* @param x
*/
void append(T x);

/**
* 删除第i个元素并返回被删除对象
* @param i
* @return
*/
T remove(int i);

/**
* 删除线性表所有元素
*/
void removeAll();

/**
* 查找，返回首次出现的关键字为key元素
* @param key
* @return
*/
T search(T key);
}

---

双链表结点类：

package com.clarck.datastructure.dlinked;

/**
* 双链表结点类
* 
* @author clarck
* 
*/
public class DLinkNode<T> {
/**
* 数据元素
*/
public T data;

/**
* pred指向前驱结点，next指向后继结点
*/
public DLinkNode<T> pred, next;

/**
* 构造节点，data指定元素，pred指向前驱节点，next指向后继节点
*/
public DLinkNode(T data, DLinkNode<T> pred, DLinkNode<T> next) {
this.data = data;
this.pred = pred;
this.next = next;
}

/**
* 默认构造器
*/
public DLinkNode() {
this(null, null, null);
}

}

---

循环双链表：

package com.clarck.datastructure.dlinked;

/**
* 循环双链表
* 
* @author clarck
* 
* @param <T>
*/
public class CirDoublyLinkedList<T> implements LList<T> {
/**
* 头节点
*/
public DLinkNode<T> head;

/**
* 默认构造方法，构造空循环双链表
* 
* 创建头结点，3个域值均为null
*/
public CirDoublyLinkedList() {
this.head = new DLinkNode<T>();
this.head.pred = this.head;
this.head.next = this.head;
}

/**
* 由指定数组中的多个对象构造循环双链表，采用尾插入构造循环双链表
* 
* @param element
*/
public CirDoublyLinkedList(T[] element) {
// 创建空循环双链表，只有头结点
this();
DLinkNode<T> rear = this.head;
for (int i = 0; i < element.length; i++) {
rear.next = new DLinkNode<T>(element[i], rear, this.head); // 尾插入
rear = rear.next;
}
this.head.pred = rear;
}

/**
* 深拷贝构造方法，复制循环双链表
* 
* @param list
*/
public CirDoublyLinkedList(CirDoublyLinkedList<T> list) {
// 创建空循环双链表，只有头结点
this();
DLinkNode<T> rear = this.head;
for (DLinkNode<T> p = list.head.next; p != list.head; p = p.next) {
rear.next = new DLinkNode<T>(p.data, rear, this.head);
rear = rear.next;
}
this.head.pred = rear;
}

/**
* 判断循环双链表是否空
*/
@Override
public boolean isEmpty() {
return this.head.next == this.head;
}

/**
* 插入第i（≥0）个元素值为x。若x==null，不插入。 若i<0，插入x作为第0个元素；若i大于表长，插入x作为最后一个元素。O(n)
*/
@Override
public int length() {
int i = 0;
for (DLinkNode<T> p = this.head.next; p != this.head; p = p.next) {
i++;
}
return i;
}

/**
* 返回第i（≥0）个元素，若i<0或大于表长则返回null，
*/
@Override
public T get(int i) {
if (i >= 0) {
DLinkNode<T> p = this.head.next;
for (int j = 0; p != this.head && j < i; j++) {
p = p.next;
}

// p指向第i个结点
if (p != null) {
return p.data;
}
}
return null;
}

/**
* 设置第i（≥0）个元素值为x。若i<0或大于表长则抛出序号越界异常；若x==null，不操作。O(n)
*/
@Override
public void set(int i, T x) {
if (x == null)
return;

DLinkNode<T> p = this.head.next;
for (int j = 0; p != this.head && j < i; j++) {
p = p.next;
}

// p指向第i个结点
if (i >= 0 && p != null) {
p.data = x;
} else {
throw new IndexOutOfBoundsException(i + "");
}
}

/**
* 插入第i（≥0）个元素值为x。若x==null，不插入。 若i<0，插入x作为第0个元素；若i大于表长，插入x作为最后一个元素。O(n)
*/
@Override
public void insert(int i, T x) {
if (x == null)
return;
DLinkNode<T> p = this.head;
// 寻找插入位置 循环停止时，p指向第i-1个结点
for (int j = 0; p.next != this.head && j < i; j++) {
p = p.next;
}
// 插入在p结点之后，包括头插入、中间插入
DLinkNode<T> q = new DLinkNode<T>(x, p, p.next);
p.next.pred = q;
p.next = q;
}

/**
* 在循环双链表最后添加结点，O(1)
*/
@Override
public void append(T x) {
if (x == null)
return;
// 插入在头结点之前，相当于尾插入
DLinkNode<T> q = new DLinkNode<T>(x, head.pred, head);
head.pred.next = q;
head.pred = q;
}

/**
* 删除第i（≥0）个元素，返回被删除对象。若i<0或i大于表长，不删除，返回null。O(n)
*/
@Override
public T remove(int i) {
if (i >= 0) {
DLinkNode<T> p = this.head.next;
// 定位到待删除结点
for (int j = 0; p != this.head && j < i; j++) {
p = p.next;
}

if (p != head) {
// 获得原对象
T old = p.data;
// 删除p结点自己
p.pred.next = p.next;
p.next.pred = p.pred;
return old;
}
}
return null;
}

/**
* 删除循环双链表所有元素
*/
@Override
public void removeAll() {
this.head.pred = this.head;
this.head.next = this.head;
}

/**
* 顺序查找关键字为key元素，返回首次出现的元素，若查找不成功返回null
* key可以只包含关键字数据项，由T类的equals()方法提供比较对象相等的依据
*/
@Override
public T search(T key) {
if (key == null)
return null;
for (DLinkNode<T> p = this.head.next; p != this.head; p = p.next)
if (key.equals(p.data))
return p.data;
return null;
}

/**
* 返回循环双链表所有元素的描述字符串，循环双链表遍历算法，O(n)
*/
@Override
public String toString() {
String str = "(";
for (DLinkNode<T> p = this.head.next; p != this.head; p = p.next) {
str += p.data.toString();
if (p.next != this.head)
str += ",";
}
return str + ")"; // 空表返回()
}

/**
* 比较两条循环双链表是否相等，覆盖Object类的equals(obj)方法
*/
@SuppressWarnings("unchecked")
public boolean equals(Object obj) {
if (obj == this)
return true;
if (!(obj instanceof CirDoublyLinkedList))
return false;
DLinkNode<T> p = this.head.next;
CirDoublyLinkedList<T> list = (CirDoublyLinkedList<T>) obj;
DLinkNode<T> q = list.head.next;
while (p != head && q != list.head && p.data.equals(q.data)) {
p = p.next;
q = q.next;
}
return p == head && q == list.head;
}
}

---

循环双链表 测试类：

package com.clarck.datastructure.dlinked;

/**
* 循环双链表 测试类
* 
* @author clarck
* 
*/
public class CirDoublyLinkedList_test {
/**
* 返回产生n个随机数的数组
* 
* @param n
* @return
*/
public static Integer[] random(int n) {
Integer[] elements = new Integer[n];
for (int i = 0; i < n; i++)
elements[i] = (int) (Math.random() * 100); // 产生随机数
return elements;
}

public static void main(String args[]) {
CirDoublyLinkedList<Integer> list1 = new CirDoublyLinkedList<Integer>(
random(5));
System.out.print("list1: " + list1.toString() + "，");
list1.insert(-1, -1); // 插入位置容错
list1.insert(0, 0);
list1.insert(6, 6);
list1.insert(100, 100); // 插入位置容错
list1.set(3, new Integer((int) (list1.get(3).intValue() + 100)));
System.out.println("插入后: " + list1.toString());
list1.remove(0);
list1.remove(3);
list1.remove(100); // 序号越界，没删除
System.out.println("删除后: " + list1.toString());
CirDoublyLinkedList<Integer> list2 = new CirDoublyLinkedList<Integer>(
list1);// 深拷贝
System.out.println("list2: " + list2.toString());
}
}

---

运行结果：

list1: (53,75,30,97,56)，插入后: (0,1,53,175,30,97,6,56,100)
删除后: (-1,53,175,97,6,56,100)
list2: (-1,53,175,97,6,56,100)

 

提醒：实现源码下载链接：

http://www.cnblogs.com/tanlon/p/4028622.html

 

3.排序循环双链表
概念：该表就是插入一个值为x结点，首先要查找插入位置，从双链表的第一个结点开始，将元素x依次与当前结点的data值比较大小，一旦找到一个比
x值大或者等值结点p，则将x插入在p结点之前。
注意：其先查找插入位置，其时间复杂度为O（n），之后再插入，其时间复杂度为O（1）。

代码实例：
public class SortedDoublyLinkedList<T extends Comparable<T>> extends CirDoublyLinkedList<T>
{ 
//默认构造方法，构造空循环双链表。调用父类默认构造方法，构造空循环双链表
public SortedDoublyLinkedList(){super();}
public SortedDoublyLinkedList(T[] element) //将数组中所有对象插入构造排序单链表
{ super();
for(int i=0;i<element.length;i++){
this.insert(element[i]); //插入，根据值的大小决定插入位置
}
//深拷贝构造方法，调用父类同参数的构造方法
public SortedDoublyLinkedList(SortedDoublyLinkedList<T> list){ super(list); }
public void insert(T x) //根据指定对象的大小插入在合适位置
{
if（x==null)
return; //不能插入空对象 
if(this.head.prev!=head&&this.head.prev.data.compareTo(x)<0)
{ //先判断其是否为最大值，如果是，最大值插入在头结点之前，即插入在链尾，时间复杂度O（1）（这也是根本目的，因为如果是最大，那就没必要再遍历一遍了，浪费时间，效率底下，算法就是追求效率)
DLinkNode<T> q=new DLinkNode<T>(x,head.prev,head);
head.prev.next=q;
head.prev=q;
}
//下面这个就是先寻找位置，然后再插入的步骤
DLinkNode<T> p=this.head.next;
while(p!=head&&p.data.compareTo(x)<0{ //compareTo(x）意思就是p的数据和x比较如果比x小，返回小于0的数，否则，大于或等于0。目的就是为了排序而寻找插入位置
p=p.next;}
DLinkNode<T> q=new DLinkNode<T>(x.p.prev,p);//插在p结点之前
p.prev.next=q; 
p.prev=q;
}
public void remove(T x) //删除首次出现的值为x结点，若未找到则不删除。时间复杂度为Q(n)
{
if(x==null){ return;}
DLinkNode<T> p=this.head.next;
while(p!=head&&p.data.compareTo(x)<0){ //将p定位到待删除的结点
p=p.next;}
if(p!=head&&p.data.compare(x)==0){
p.prev.next=p.next; //删除p结点自己
p.next.prev=p.prev;
}
}
}
}