文章目录
- 模拟实现LinkedList
- LinkedList的简单使用
- LinkedList的一些方法
- LinkedList的遍历
- 简单对比一下LinkedList和ArrayList
模拟实现LinkedList
在上一篇的博客中，我们讲解了链表的基础知识，并且模拟实现了一个无头单向不循环链表，链表的基础知识讲解，大家有兴趣可以去看一下。Java给我们提供的链表其实是一个双向的链表，那今天我们就完善一下我们的LinkedList的模拟实现。
双向链表的每个节点需要有一个前驱：用来访问前一个结点，和一个后继：用来访问后一个结点，还需要记录第一个结点head，和最后一一个结点last。
public class MyLinkedList2 {
static class LinkNode {
public int val;//用于储存数据
public LinkNode next;//用于找到下一个结点
public LinkNode prev;//找到前一个节点
public LinkNode(int val) {
this.val = val;
}
}
public LinkNode head;//记录第一个节点
public LinkNode last;//记录最后一个节点
}
有一些方法是不需要进行更改的我就不在进行讲解了，想了解可以看上一篇文章。这里我们只讲解一些需要用到prev的方法，例如头插法：
public void addFirst(int data){
LinkNode newNode = new LinkNode(data);
if(head == null) {
head = newNode;
last = newNode;
}else {
newNode.next = head;
head.prev = newNode;
head = newNode;
}
}
这样就完成了我们的头插法。
尾插法
public void addLast(int data){
LinkNode newNode = new LinkNode(data);
if(head == null) {
head = newNode;
last = newNode;
}else {
last.next = newNode;
newNode.prev = last;
last = newNode;
}
}
在双向链表中尾插法的时间复杂度变为了O(1)，不需要在遍历链表找到最后一个元素进行尾插，我们直接找到记录最后一个节点的last节点就可以进行尾插了。
任意位置插入,第一个数据节点为0号下标
public void addIndex(int index,int data){
try {
checkIndex(index);
} catch (ListIndexException ex) {
ex.printStackTrace();
}
if(index == 0) {
addFirst(data);
return ;
}
if(index == size()) {
addLast(data);
return ;
}
LinkNode tmp = FindIndexNode(index);//直接找到该位置的元素就可以不需要找到前一个元素
LinkNode newNode = new LinkNode(data);
newNode.next = tmp;
newNode.prev = tmp.prev;
tmp.prev.next = newNode;
tmp.prev = newNode;
}
private LinkNode FindIndexNode(int index) {//找到index位置的结点
LinkNode cur = head;
while (index != 0) {
cur = cur.next;
index--;
}
return cur;
}
private void checkIndex(int index) throws ListIndexException{
if(index < 0 || index > size()) {
throw new ListIndexException("插入下标错误");
}
}
在任意位置插入元素，也不需要向单向链表一样找到要插入位置的前一个节点，我们直接找到要插入位置的节点通过prev就可以访问前一个结点。
删除第一次出现关键字为key的节点
public void remove(int key){
LinkNode cur = head;
while(cur != null) {
if(cur.val == key) {
//如果要删除的为头节点
if(cur == head) {
head = head.next;
//是否只有一个节点
if(head != null) {
head.prev = null;
}
}else {
cur.prev.next = cur.next;
//判断是否为尾节点
if(cur.next != null) {
cur.next.prev = cur.prev;
}else {
last = last.prev;
}
}
return ;
}
cur = cur.next;
}
}
删除所有值为key的节点
public void removeAllKey(int key){
LinkNode cur = head;
while(cur != null) {
if(cur.val == key) {
//如果要删除的为头节点
if(cur == head) {
head = head.next;
//是否只有一个节点
if(head != null) {
head.prev = null;
}
}else {
cur.prev.next = cur.next;
//判断是否为尾节点
if(cur.next != null) {
cur.next.prev = cur.prev;
}else {
last = last.prev;
}
}
//return ; - 去掉return就实现了
}
cur = cur.next;
}
}
这两个方法在双向链表中逻辑是一样的，我们不需要像单向链表一样找到需要删除结点的前一个结点，因为我们有prev可以访问到前一个结点，我们只需要对删除结点是否是头尾进行判断就可以了。
上面图画的是最复杂的情况，如果为头节点和尾结点，将head或者last进行一些改变就可以了，这里就不在画图讲解了。
清空链表
public void clear() {
LinkNode cur = head;
while (cur != null) {
LinkNode curNext = cur.next;
cur.next = null;
cur.prev = null;
cur = curNext;
}
head = null;
last = null;
}
与单向链表相比我们就不能那么暴力了，当然我们也可以将head和last都置为空，但还是太过暴力，我们还是遍历链表将所有结点的next和prev都置为null，这样我们就完善了LinkedList的实现。
LinkedList的简单使用
LinkedList的一些方法
| 方法 | 功能 |
|---|---|
boolean add(E e) | 尾插 e |
void add(int index, E element) | 将 e 插入到 index 位置 |
boolean addAll(Collection<? extends E> 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<E> subList(int fromIndex, int toIndex) | 截取部分 list |
public static void main(String[] args) {
LinkedList<Integer> list = new LinkedList<>();
list.add(1);
list.add(2);
list.add(3);
for(Integer num : list) {
System.out.print(num + " ");
}
}
我们创建一个LinkedList的对象调用他的add方法添加一些结点，并且通过foreach的形式遍历链表，这样我们就打印出了链表中的内容，当然我们还可以使用其他的方法对链表进行一些操作，大家可以自己尝试一下。
LinkedList的遍历
1、foreach遍历
public static void main(String[] args) {
LinkedList<Integer> list = new LinkedList<>();
list.add(1);
list.add(2);
list.add(3);
for(Integer num : list) {
System.out.print(num + " ");
}
System.out.println();
}
2、迭代器正向遍历
public static void main(String[] args) {
LinkedList<Integer> list = new LinkedList<>();
list.add(1);
list.add(2);
list.add(3);
ListIterator<Integer> it = list.listIterator();
while(it.hasNext()) {
System.out.print(it.next() + " ");
}
System.out.println();
}
3、迭代器反向遍历
public static void main(String[] args) {
LinkedList<Integer> list = new LinkedList<>();
list.add(1);
list.add(2);
list.add(3);
ListIterator<Integer> it2 = list.listIterator(list.size());
while(it2.hasPrevious()) {
System.out.print(it2.previous() + " ");
}
System.out.println();
}
通过这三种方法我们就可以对LinkedList进行遍历。
简单对比一下LinkedList和ArrayList
学完了这两种数据结构之后，这两种数据结构的使用场景是怎样的呢？二者有什么区别呢？我们来简单总结一下。
| LinkedList | ArrayList |
|---|---|
| 逻辑上是连续的但是物理上不一定连续 | 物理上一定连续 |
| 随机访问的时间复杂度为O(N) | 随机访问时时间复杂度为O(1) |
| 头插时时间复杂度为O(1) | 头插时时间复杂度为O(N) |
| 没有容量的概念 | 有容量的概念，需要扩容 |
所以当我们的业务需求为：需要频繁访问数据时，我们可以用ArrayList顺序表来处理数据，当需求为：频繁的插入删除数据时，我们可以使用LinkedList链表来处理数据。
![[Java]异常处理](https://img-blog.csdnimg.cn/4cdfd58c2e6340a9a375d8560769d4eb.png)
