双向链表
双向链表也叫双向表,是链表的一种,它由多个结点组成,每个结点都由一个数据域和两个指针域组成,数据域用来存储数据,其中一个指针域用来指向其后继结点,另一个指针域用来指向前驱结点。链表的头结点的数据域不存储数据,指向前驱结点的指针域值为null,指向后继结点的指针域指向第一个真正存储数据的结点。
双向链表API设计
方法名 | 方法功能 |
---|---|
public void clear() | 空置线性表 |
publicboolean isEmpty() | 判断线性表是否为空,是返回true,否返回false |
public int length() | 获取线性表中元素的个数 |
public T get(int i) | 读取并返回线性表中的第i个元素的值 |
public void insert(T t) | 往线性表中添加一个元素 |
public void insert(int i,T t) | 在线性表的第i个元素之前插入一个值为t的数据元素 |
public T remove(int i) | 删除并返回线性表中第i个数据元素 |
public int indexOf(T t) | 返回线性表中首次出现的指定的数据元素的位序号,若不存在,则返回-1 |
public T getFirst() | 获取第一个元素 |
public T getLast() | 获取最后一个元素 |
双向链表代码实现
/**
* 双向链表
*/
public class TowWayLinkList<T> implements Iterable<T> {
private Node head;
private Node last;
private int N;
public TowWayLinkList() {
this.head = new Node(null, null, null);
this.last = null;
this.N = 0;
}
// 清空链表
public void clear() {
this.head.next = null;
this.last = null;
this.N = 0;
}
// 获取链表长度
public int length() {
return N;
}
// 判断链表是否为空
public boolean isEmpty() {
return N == 0;
}
// 插入元素t
public void insert(T t) {
// 如果链表为空
if (isEmpty()) {
// 创建新的结点
Node newNode = new Node(t, head, null);
// 让新结点成为尾结点
last = newNode;
// 让头结点指向尾结点
head.next = last;
} else { // 链表不为空
// 创建新的结点(同时pre指向前的尾结点)
Node newNode = new Node(t, last, null);
// 让当前的尾结点指向新结点
last.next = newNode;
// 让新结点成为尾结点
last = newNode;
}
// 元素个数+1
N++;
}
//向指定位置i处插入元素t
public void insert(int i, T t) {
// 找到i位置的前一个结点
Node pre = head;
for (int index = 0; index <= i - 1; index++) {
pre = pre.next;
}
// 找到i位置的结点
Node curr = pre.next;
// 创建新结点,保存数据(令其pre指向i位置的前一个结点,next指向i位置的结点)
Node newNode = new Node(t, pre, curr);
// 令i位置的前一个结点的next指向新结点
pre.next = newNode;
// 令i位置的结点的pre指向新结点
curr.pre = newNode;
// 元素个数+1
N++;
}
// 获取指定位置i处的元素
public T get(int i) {
Node n = head;
for (int index = 0; index <= i; index++) {
n = n.next;
}
return n.item;
}
// 找到元素t在链表中第一次出现的位置
public int indexOf(T t) {
Node n = head;
for (int index = 0; n.next != null; index++) {
n = n.next;
if (n.item.equals(t))
return index;
}
return -1;
}
// 删除位置i处的元素,并返回该元素
public T remove(int i) {
// 找到i位置的前一个结点
Node pre = head;
for (int index = 0; index <= i - 1; index++) {
pre = pre.next;
}
// 找到i位置的结点
Node curr = pre.next;
// 找到i位置的下一个结点
Node next = curr.next;
// 令i位置的前一个结点的next指向i位置的下一个结点
pre.next = next;
// 令i位置的下一个结点的pre指向i位置的前一个结点
next.pre = pre;
// 元素个数-1
N--;
return curr.item;
}
// 获取第一个元素
public T getFirst() {
if (isEmpty()) {
return null;
}
return head.next.item;
}
// 获取最后一个元素
public T getLast() {
if (isEmpty()) {
return null;
}
return last.item;
}
// 结点类
private class Node {
T item;
Node pre;
Node next;
public Node(T item, Node pre, Node next) {
this.pre = pre;
this.item = item;
this.next = next;
}
}
@Override
public Iterator<T> iterator() {
return new TIterator();
}
private class TIterator implements Iterator {
private Node n;
public TIterator() {
this.n = head;
}
@Override
public boolean hasNext() {
return n.next != null;
}
@Override
public Object next() {
n = n.next;
return n.item;
}
}
}
java中LinkedList实现
java中LinkedList集合也是使用双向链表实现,并提供了增删改查等相关方法
1.底层是用双向链表实现;
2.结点类是有三个域
链表的复杂度分析
- get(int i):每一次查询,都需要从链表的头部开始,依次向后查找,随着数据元素N的增多,比较的元素越多,时间复杂度为O(n)
- insert(int i,T t):每一次插入,需要先找到i位置的前一个元素,然后完成插入操作,随着数据元素N的增多,查找的元素越多,时间复杂度为O(n);
- remove(int i):每一次移除,需要先找到i位置的前一个元素,然后完成插入操作,随着数据元素N的增多,查找的元素越多,时间复杂度为O(n)
- 相比较顺序表,链表插入和删除的时间复杂度虽然一样,但仍然有很大的优势,因为链表的物理地址是不连续的,它不需要预先指定存储空间大小,或者在存储过程中涉及到扩容等操作,同时它并没有涉及的元素的交换。
- 相比较顺序表,链表的查询操作性能会比较低。因此,如果我们的程序中查询操作比较多,建议使用顺序表,增删操作比较多,建议使用链表。