【数据结构Java版】LinkedList与链表
目录
一、什么是LinkedList
二、LinkedList的模拟实现
（1）合法LinkedList的要求
（2）LinkedList实现的内容
1.结点个数
2.链表尾插元素
3.链表头插元素
4.指定下标插入元素
5.删除指定下标结点
6.删除指定元素
7.获取指定下标元素
8.设置指定下标元素
9.从前往后获取指定元素下标
10.从后往前获取指定元素下标
11.判断是否包含指定元素
12.清空链表
13.判断链表是否为空
三、LinkedList的使用
（1）LinkedList的构造
（2）LinkedList的其他常用方法介绍
（3）LinkedList的遍历
四、ArrayList与LinkedList的比较
一、什么是LinkedList
LinkedList 的官方文档： LinkedList (Java Platform SE 8 )
单链表从前往后遍历支持较好，从后往前遍历支持较差。 因此LinkedList的底层是双向链表结构，由于链表没有将元素存储在连续的空间中，元素存储在单独的结点中，然后通过引用将结点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。
不太清楚单链表知识的小朋友建议先看这：http://t.csdn.cn/c8WZ2
LinkedList示意图：
模拟实现LinkedList的属性 ：
public class MyLinkedList implements MyList {
// 维护着 3 个属性
// 1. 链表的头结点
private MyNode head;
// 2. 链表的尾结点
private MyNode last;
// 3. 维护着链表中的元素个数
private int size; // 不维护也可以通过遍历数出来，但维护好这个属性，可以让 size 的时间复杂度 O(n) -> O(1)
// 构造方法
// 构造一个空的链表
public MyLinkedList() {
this.head = this.last = null;
this.size = 0;
}在集合框架中，LinkedList也实现了List接口，具体如下：
1. LinkedList实现了List接口
2. LinkedList的底层使用了双向链表
3. LinkedList没有实现RandomAccess接口，因此LinkedList不支持随机访问
比特就业课
4. LinkedList的任意位置插入和删除元素时效率比较高，时间复杂度为O(1)
5. LinkedList比较适合任意位置插入的场景
二、LinkedList的模拟实现
（1）合法LinkedList的要求
一个正确的 MyLinkedList 应该做到什么 ？要始终在模拟实现的过程关注以下几点内容，判断模拟的链表是否是合法的。
为了在实现LinkedList模拟过程时刻判断链表是否合法，我们可以设置一套检查装置，这套检查代码不用掌握。我们自己编写代码是要注意时刻检查调试代码是否正确，不要一股脑儿的写代码，最后bug满天飞，无法入手。
1. 得是一个合法的线性表
2. 当 head != null 则 last != null 反之亦然 当 head == null 则 last == null
3. 当 head != null 的时候，则 size > 0 同理，当 head == null 的时候，则 size == 0
4. size 的值应该 == 通过遍历数出来的结点个数 (从 head 到 last 或者 从 last 到 head）
5. 除了 head 和 last 之外，所有的其他结点(node), node.prev != null && node.next != null
6. head != null 时，则 head.prev == null，但 head.next 不确定（可以不为 null | size > 1）；也可 以为 null | size == 1) last != null 时，则 last.next == null，但 last.prev 不确定（可以不为 null | size > 1）；也可以为 null | size == 1)
7. 除了 head 和 last 之外的所有结点(node)，node.prev.next == node && node.next.prev == node 8. 当 head.next != null 时，head.next.prev == head 当 last.prev != null 时，last.prev.next == last 9. 当 size == 1 时，head == last && head != null
private static void 断言为真(boolean condition, String message) {
if (!condition) {
throw new RuntimeException(message);
}
}
private static void 检查2(MyLinkedList list) {
if (list.head == null) {
断言为真(list.last == null, "head 为 null 时，last 必须是 null");
} else {
断言为真(list.last != null, "head 不为 null 时，last 必须不为 null");
}
}
private static void 检查3(MyLinkedList list) {
断言为真(list.size >= 0, "size 必须 >= 0");
if (list.head == null) {
断言为真(list.size == 0, "head 为 null 时，size 必须是 0");
} else {
断言为真(list.size > 0, "head 不为 null 时，size 必须大于 0");
}
}
private static int 从前往后遍历确定结点个数(MyLinkedList list) {
int size = 0;
for (MyNode cur = list.head; cur != null; cur = cur.next) {
size++;
}
return size;
}
private static void 检查4(MyLinkedList list) {
断言为真(list.size == 从前往后遍历确定结点个数(list), "记录的 size 应该和遍历出的 size 相等");
}
private static void 检查5(MyLinkedList list) {
if (list.size > 1) {
MyNode cur = list.head.next;
while (cur != list.last) {
断言为真(cur.prev != null, "非头尾结点的 prev 不能是 null");
断言为真(cur.next != null, "非头尾结点的 next 不能是 null");
cur = cur.next;
}
}
}
private static void 检查6(MyLinkedList list) {
// head != null 等价于 size > 0
if (list.head != null) {
断言为真(list.head.prev == null, "头结点的 prev 一定是 null");
断言为真(list.last.next == null, "尾结点的 next 一定是 null");
if (list.size == 1) {
断言为真(list.head.next == null, "size 为 1 时，头节点的 next 一定是 null");
断言为真(list.last.prev == null, "size 为 1 时，为节点的 prev 一定是 null");
} else {
断言为真(list.head.next != null, "size > 1 时，头节点的 next 一定不是 null");
断言为真(list.last.prev != null, "size > 1 时，尾节点的 prev 一定不是 null");
}
}
}
private static void 检查7(MyLinkedList list) {
if (list.size > 1) {
MyNode cur = list.head.next; // 跳过头节点
while (cur != list.last) { // 跳过尾结点
断言为真(cur.prev.next == cur, "非头尾结点的 前驱的 后继是自己");
断言为真(cur.next.prev == cur, "非头尾结点的 后继的 前驱是自己");
cur = cur.next;
}
}
}
private static void 检查8(MyLinkedList list) {
// head.next != null 等价于 last.prev != null 等价于 size > 1
if (list.size > 1) {
断言为真(list.head.next.prev == list.head, "当 head.next != null 时，head.next.prev == head");
断言为真(list.last.prev.next == list.last, "当 last.prev != null 时，last.prev.next == last");
}
}
private static void 断言是一个合法的链表(MyLinkedList list) {
检查2(list);
检查3(list);
检查4(list);
检查5(list);
检查6(list);
检查7(list);
检查8(list);
}（2）LinkedList实现的内容
//结点个数
public int size() {
return 0;
}//链表尾插元素
public boolean add(Long e) {
return false;
}//链表头插元素
public boolean addFirst(Long e) {
return false;
}
//指定下标插入元素
public void add(int index, Long e) {}
//删除指定下标结点
public Long remove(int index) {
return null;
}//删除指定元素
public boolean remove(Long e) {
return false;
}//获取指定下标元素
public Long get(int index) {
return null;
}//设置指定下标元素
public Long set(int index, Long e) {
return null;
}//从前往后获取指定元素下标
public int indexOf(Long e) {
return 0;
}//从后往前获取指定元素下标
public int lastIndexOf(Long e) {
return 0;
}//判断是否包含指定元素
public boolean contains(Long e) {
return false;
}//清空链表
public void clear() {}
//判断链表是否为空
public boolean isEmpty() {
return false;
}
1.结点个数
在检查机制中已经写过一遍，就是从前往后遍历所有元素。这里主要要返回size即可
public int size() {
return size
}2.链表尾插元素
时间复杂度是O(1)
考虑两种情况：size==0的情况和链表size>0的情况。
注意要点 ：
a.需要分情况讨论。两种情况无法合并
b.既要关注head，也要关注last
c.需要正确处理结点的next和prev。涉及新加入的结点和之前的尾结点（如果存在的话）
d.size不能忘记
public boolean add(Long e){
//1.将元素装入新结点
MyNode node=new MyNode(e);
node.next=null;//这一步可以省略
//2.找尾结点，分情况讨论
//2.1链表中有尾结点：last != null 等价于 head != null 等价于 size > 0
if(size>0){
this.last.next=node;
node.prev=this.last;
this.last=node;
}else{
//2.2链表中没有有尾结点
node.prev=null;
this.head=this.last=node;
}
//3.size个数增加
this.size++;
return true;
}3.链表头插元素
时间复杂度是O(1)
与尾插思路基本一致。
public boolean addFisrst(Long e){
MyNode node=new MyNode(e);
node.prev=null;
if(size>0){
this.head.prev=node;
node.next=this.head;
this.head=node;
}else{
node.next=null;
this.head=this.last=node;
}
this.size++;
return true;
} 4.指定下标插入元素
时间复杂度是O(n)
根据下标的特征可以分为以下几种情况。根据以下表格写代码，才可以保证所有情况都考虑到不出错。
public void add(int index,int e){
if(index<0||index>size){
throw new ArrayIndexOfBoundsException("下标不合法");
}
//情况1 size==0
if(size==0){
add(e);//尾插，或者addFirst(e)用头插也可以
return;
}
//情况2 size==1
if(size==1){
//2.1 index==0
if(index==0){
addFirst(e);
//2.2 index==1
}else{
add(e);
}
return;
}
//情况3 size>1
//3.1 index==0
if(index==0){
addFirst(e);
return;
//3.2 index=size
}else if(index==size){
add(e);
return;
}
//3.3 0关于异常操作，指路☞ http://t.csdn.cn/QaTL8
5.删除指定下标结点
时间复杂度是O(n)
注意size==0的情况是下标不合法。
public Long remove(int index){
//下标不合法
if(index<0||index>=size){
throw new ArrayIndexOutOfBoundsException("下标不合法");
}
//下标合法
//情况1:size==1
if(size==1){
//现将要删除的结点元素保存下来
Long e=this.head.val;
this.head=this.last=null;
//size减少
this.size==0;
return e;
}
//情况2:size>1
//2.1 index==0 头删
if(index==0){
Long e=this.head.val;
//改变头结点的位置，现头结点为原来头结点的后一个
this.head=this.head.next;
//现头结点的前驱指向为null
this.head.prev=null;
//size减少
this.size--;
return e;
}
//2.2 index==size-1 尾删
if(index==size-1){
Long e=this.last.val;
//改变尾结点的位置，现尾结点为原来尾结点的前一个
this.last=this.last.prev;
//现尾结点的前驱指向为null
this.last.next=null;
//size减少
this.size--;
return e;
}
//size>1 && 0关于异常操作，指路☞ http://t.csdn.cn/QaTL8
6.删除指定元素
时间复杂度是O(n)
删除指定元素，如果找到该元素，返回true；如果没有找到该元素，返回false。
public boolean remove(Long e){
MyNode cur=this.head;
for(int i=0;i=1，分情况讨论
this.head=this.head.next;
// size > 1 则 此时 this.head != null
if(this.head!=null){
this.head.prev==null;
//size == 1 则 此时 this.head == null
}else{
this.head=this.last=null;
}
this.size--;
return true;
}
if(i==size-1){
//size>1
this.last=this.last.prev;
this.last.next=null;
this.size--;
return true;
}
//既不是头删，也不是尾删
MyNode prevNode =curNode.prev;
MyNode nextNode =curNode.next;
prevNode.next=nextNode;
nextNode.next=prevNode;
this.size--;
return true;
}
cur=cur.next;//循环，写到最后别忘了
}
return false;
} 7.获取指定下标元素
时间复杂度是0(n)
首先要判断下标是非合法，然后遍历获取。
public Long get(int index){
if(index<0||index>=size){
throw new ArrayIndexOutOfBoundsException("下标不合法");
}
MyNode curNode=this.head;
for(int i=0;i8.设置指定下标元素
时间复杂度是0(n)
首先要判断下标是非合法，然后遍历获取。存储旧的结点信息。
public Long set(int index,Long e){
if(index<0||index>=size){
throw new ArrayIndexOutOfBoundsException("下标不合法");
}
MyNode curNode = this.head;
for(int i=0;i9.从前往后获取指定元素下标
时间复杂度是O(n)
public int indexOf(Long e){
int i=0;
MyNode curNode =this.head;
while(curNode!=null){
if(curNode.val.equals(e)){
return i;
}
i++;
curNode=curNode.next;
}
return -1;
}10.从后往前获取指定元素下标
时间复杂度是O(n)
public int lastIndexOf(Long e){
int i=size-1;
MyNode curNode =this.last;
while(curNode!=null){
if(curNode.val.equals(e)){
return i;
}
i--;
curNode=curNode.prev;
}
return -1;
}11.判断是否包含指定元素
时间复杂度是O(n)
public boolean contains(Long e){
return indexOf(e)!=-1;
}12.清空链表
时间复杂度是O(1)
public void clear() {
this.head = this.last = null;
this.size = 0;
}13.判断链表是否为空
时间复杂度是O(1)
public boolean isEmpty() {
return size == 0;
}三、LinkedList的使用
（1）LinkedList的构造
| 方法 | 解释 |
| LinkedList() | 无参构造 |
| public LinkedList(Collection c) | 使用其他集合容器中元素构造List |
public static void main(String[] args) {
// 构造一个空的LinkedList
List list1 = new LinkedList<>();
List list2 = new java.util.ArrayList<>();
list2.add("A");
list2.add("B");
list2.add("C");
// 使用ArrayList构造LinkedList
List list3 = new LinkedList<>(list2);
} （2）LinkedList的其他常用方法介绍
| 方法 | 解释 |
| boolean add(E e) | 尾插 e |
| void add(int index, E element) | 将 e 插入到 index 位置 |
| boolean addAll(Collection c) | 尾插 c 中的元素 |
| E remove(int index) | 删除 index 位置元素 |
| boolean remove(Object o) | 删除遇到的第一个 o |
| E get(int index) | 获取下标 index 位置元素 |
| E set(int index, E element) | 将下标 index 位置元素设置为 element |
| void clear() | 清空 |
| boolean contains(Object o) | 判断 o 是否在线性表中 |
| int indexOf(Object o) | 返回第一个 o 所在下标 |
| int lastIndexOf(Object o) | 返回最后一个 o 的下标 |
| List |
截取部分 list |
public static void main(String[] args) {
LinkedList list = new LinkedList<>();
list.add(1); // add(elem): 表示尾插
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(6);
list.add(7);
System.out.println(list.size());
System.out.println(list);
// 在起始位置插入0
list.add(0, 0); // add(index, elem): 在index位置插入元素elem
System.out.println(list);
list.remove(); // remove(): 删除第一个元素，内部调用的是removeFirst()
list.removeFirst(); // removeFirst(): 删除第一个元素
list.removeLast(); // removeLast(): 删除最后元素
list.remove(1); // remove(index): 删除index位置的元素
System.out.println(list);
// contains(elem): 检测elem元素是否存在，如果存在返回true，否则返回false
if(!list.contains(1)){
list.add(0, 1);
}
list.add(1);
System.out.println(list);
System.out.println(list.indexOf(1)); // indexOf(elem): 从前往后找到第一个elem的位置
System.out.println(list.lastIndexOf(1)); // lastIndexOf(elem): 从后往前找第一个1的位置
int elem = list.get(0); // get(index): 获取指定位置元素
list.set(0, 100); // set(index, elem): 将index位置的元素设置为elem
System.out.println(list);
// subList(from, to): 用list中[from, to)之间的元素构造一个新的LinkedList返回
List copy = list.subList(0, 3);
System.out.println(list);
System.out.println(copy);
list.clear(); // 将list中元素清空
System.out.println(list.size());
} （3）LinkedList的遍历
a.foreach遍历
b.迭代器正向遍历
c.迭代器负向遍历
public static void main(String[] args) {
LinkedList list = new LinkedList<>();
list.add(1); // add(elem): 表示尾插
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(6);
list.add(7);
System.out.println(list.size());
// foreach遍历
for (int e:list) {
System.out.print(e + " ");
}
System.out.println();
// 使用迭代器遍历---正向遍历
ListIterator it = list.listIterator();
while(it.hasNext()){
System.out.print(it.next()+ " ");
}
System.out.println();
// 使用反向迭代器---反向遍历
ListIterator rit = list.listIterator(list.size());
while (rit.hasPrevious()){
System.out.print(rit.previous() +" ");
}
System.out.println();
} 四、ArrayList与LinkedList的比较
| 不同点 | ArrayList | LinkedList |
| 存储空间上 | 物理上一定连续 | 逻辑上连续，但物理上不一定连续 |
| 随机访问 | 支持O(1) | 不支持：O(N) |
| 头插 | 需要搬移元素，效率低O(N) | 只需修改引用的指向，时间复杂度为O(1) |
| 插入 | 空间不够时需要扩容 | 没有容量的概念 |
| 应用场景 | 元素高效存储+频繁访问 | 任意位置插入和删除频繁 |
