前言
在前面已经总结了单链表，有了单链表的基础会很好理解双链表的实现，忘记了可以跳转——>http://t.csdnimg.cn/GFPk9
接下来就由我带着各位看官来认识今天的主角吧~
什么是双向链表
在单链表的基础上，它有两个方向的链接，一个链接指向前一个节点，另一个链接指向下一个节点。每个节点通常包含两个部分：数据(val)部分和两个指针部分，即前向指针(prev)和后向指针(next)。这使得在双向链表中，可以双向遍历数据,搭配下面图片更好理解~
因为是双向链表，为了分清头尾，定义头结点head和尾结点last，同时别忘在各自的末尾置null~这样一个完整的双向链表就表示出来了。
双向链表的基本方法
这里就用图来表示
| boolean add(E e) | 尾插 e |
| void add(int index, E element) | 将 e 插入到 index 位置 |
| boolean contains(Object o) | 判断元素o是否在表中 |
| 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() | 清空 |
这里就引用了LinkedList类，观察代码演示就能理解这些方法的使用。
import java.util.LinkedList;
public class Test3 {
public static void main(String[] args) {
LinkedList<Integer> list=new LinkedList<>();
list.add(1);//尾插法
list.add(2);
list.add(3);
list.add(4);
System.out.println(list.size());//获取链表长度
System.out.println(list);//打印链表
System.out.println("插入");
list.add(0,5);//指定位置插入
System.out.println(list);
boolean a= list.contains(4);//判断指定元素是否在list当中
System.out.println(a);
list.set(0,6);//替换指定位置的元素
System.out.println(list);
System.out.println("移除");
list.remove(0);//移除指定位置
list.removeFirst();//头删
list.removeLast();//尾删
System.out.println(list);
list.clear();
System.out.println(list);//清空链表
}
}运行结果如图（搭配代码就能理解通透了）：
双向链表的模拟实现
首先初始化一个双向链表，对于一个单节点，存储的val值，前驱和后继，然后定义头尾节点表示顺序。对比这张图，便好理解了~
1.添加元素
public class MyLinkedList {
static class ListNode {
public int val;
public ListNode prev;//前驱
public ListNode next;//后继
public ListNode(int val) {
this.val = val;
}
}
public ListNode head;// 头结点
public ListNode last;// 尾节点头插法：原理其实和单向链表的头插原理是类似的，不过就是要多考虑一个方向
头插法
//头插法
public void addFirst(int data) {
LinkedList node= new LinkedList(data);
if(head==null){
head=node;
last=node;
}
node.next=head;
head.prev=node;
head=node;
}尾插法
尾插法的原理是一样的，头插反着来就是了
//尾插法
public void addLast(int data){
LinkedList node=new LinkedList(data);
if(head==null){
head=node;
last=head;
}
node.next=last;
last.prev=node;
last=node;
}任意位置插入
修改节点的指向的就可以实现这个效果了，注意改变的指向次序
// 任意位置插入,第一个数据节点为0号下标
public boolean addIndex(int index, int data) {
if (index < 0 || index > size()) {
return false;
}
if (index == 0) {//头插
addFirst(data);
return true;
}
if (index == size()) {//尾插
addLast(data);
return true;
}
ListNode cur = findIndex(index);
ListNode node = new ListNode(data);
node.next = cur;
cur.prev.next=node;//cur.prev.next表示的是cur的前一个节点的next
node.prev = cur.prev;//cur.prev表示的是cur的前一个节点
cur.prev=node;
return true;
}
//找到要删除元素的下标
public ListNode findIndex(int index) {
ListNode cur = head;
while (index != 0) {
cur = cur.next;
index--;
}
return cur;
}2.删除元素
删除该节点就是没有节点指向它了，直接跨过它了
删除第一次出现的指定元素
// 删除第一次出现关键字为key的节点
public void remove(int key) {
ListNode cur = head;
while (cur != null) {
if (cur.val == key) {
if (cur == head) { //头删
head = cur.next;
if (head != null) {
head.prev = null; //如果头节点不为空，将新的头节点的prev设置为null
}
} else {
cur.prev.next = cur.next;//将cur的前一个节点的next指向cur的下一个节点
if (cur.next != null) {
cur.next.prev = cur.prev;//将cur的下一个节点的prev指向cur的前一个节点
}
}
break;//找到就退出循环
}
cur = cur.next;
}
}
删除所有指定元素
两者是很相似的，区别在于有无break跳出循环
// 删除第一次出现关键字为key的节点
public void remove(int key) {
ListNode cur = head;
while (cur != null) {
if (cur.val == key) {
if (cur == head) { //头删
head = cur.next;
if (head != null) {
head.prev = null; //如果头节点不为空，将新的头节点的prev设置为null
}
} else {
cur.prev.next = cur.next;//将cur的前一个节点的next指向cur的下一个节点
if (cur.next != null) {
cur.next.prev = cur.prev;//将cur的下一个节点的prev指向cur的前一个节点
}
}
}
cur = cur.next;
}
}
3.清空链表
清空整张链表也不难，将头尾都置null，将节点间的联系断开即可
//清空整张链表
public void clear() {
ListNode cur=head;
while(cur!=null){
ListNode CurN=cur.next;
cur.next=null;//逐个断开节点之间的连接
cur.prev=null;
cur=CurN;
}
head=last=null;//并将头节点和尾节点都置为null
}4.单双链表相同的方法
下面这三种方法，其实和方向无关了，所以总结在一处，，其实和单向链表是一模一样了
查找指定元素是否在链表中
//查找是否包含关键字key是否在单链表当中
public boolean contains(int key){
LinkedList cur=head;
while(cur!=null){
if(cur.val==key){
return true;}
cur=cur.next;}
return false;
}打印链表
//打印链表
public void display(){
LinkedList cur=head;
while(cur!=null){
System.out.print(cur.val+" ");
cur=cur.next;}
System.out.println();
}获取链表长度
//得到单链表的长度
public int size(){
LinkedList cur=head;
int count=0;
while(cur!=null){
count++;
cur=cur.next;}
return count;
}ArrayList和LinkedList的区别
在实际场景当中，这两种数据结构有着各自的优势，但区别还是要熟悉的，总结在这里了~
| 不同点 | ArrayList | LinkedList |
| 存储空间上 | 物理上一定连续 | 逻辑上连续，但物理上不一定连续 |
| 随机访问 | 支持O(1) | 不支持：O(N) |
| 头插 | 需要搬移元素，效率低O(N) | 只需修改引用的指向，时间复杂度为O(1) |
| 插入 | 空间不够时需要扩容 | 没有容量的概念 |
| 应用场景 | 元素高效存储+频繁访问 | 任意位置插入和删除频繁 |
那文章的内容就总结到这里，如果觉得有帮助不妨点个免费的赞吧，您的支持是我更新的最大动力，下次见~
