Java线性结构中的双向链表实现原理
一. 双向链表简介
1. 概念
在上一篇文章中，我们在介绍链表的种类时，曾经提到过双向链表。双向链表相比较于单链表，除数据域外，还具前和后两个指向指针。
双向链表中的结构术语可以解释为：
- data：链表每个结点中存储的数据域；
- next：链表每个结点中包含的指向下一个结点地址的指针域；
- prev：链表每个结点中包含的前一个结点地址的指针域。
2. 编码定义
根据上述对双向链表结点的定义，我们给出双向链表结点结构的Java定义实现：
class DNode{
Object data;
Node prev;
Node next;
}双向链表是一条真实存在的链表，由多个结点组成。在实际的编程中，通常会标记链表的两个特殊结点，分别为：头结点、尾结点。用另外一个变量size表示链表中元素的个数。
- 头结点：链表中的第一个结点
- 尾结点：链表中的最后一个元素
因此有如下链表类的定义：
public class DoubleLinkList{
private int size;//大小
private DNode head;//头结点
private DNode last;//尾结点
}在本篇文章接下来的内容中，我们将利用该DNode、DoubleLinkList两个定义来实现双向链表的各项操作。
二. 常见操作
因为双向链表是单链表的基础上扩展出来的结构，因此双向链表的很多操作与单链表的操作都是相同的，比如：查找元素、更新元素、插入元素、删除元素。
1. 查找元素
1.1 查找头结点
因为DoubleLinkList中已经记录了头结点head，因此头结点的查找非常简单，如下：
public Object getHead(){
if(head == null){
return null;
}
return head.data;
}时间复杂度为O(1)。
1.2 查找尾结点
与头结点同理，查找尾结点的时间复杂度同样为O(1），编码如下：
public Object getLast(){
if(last == null){
return null;
}
return last.data;
}1.3 查找指定位置结点
当需要查找指定位置的结点元素时，双向链表比单链表的实现方式有所不同，原因是：单链表因为是单向的，因此只能从头结点向后单向查找；但双向链表前后均可查找，因此在进行指定位置查找时，为了提高查找效率，会首先判断要查找的位置处于链表的前半段还是后半段，若前半段则从头结点向后查找，若后半段则从尾结点向前查找，具体编程如下所示：
public Object get(int index){
//排除边界异常
if(index <0 || index>=size){
return null;
}
//要查找的位置位于链表前半段
if(index < (size>>1)){
DNode x = head;
for(int i = 0; i < index; i++){
x = x.next;
}
return x.data;
}else {//要查找的位置位于链表后半段
DNode x = last;
for(int i = size - 1; i >= index; i--){
x = x.prev;
}
return x.data;
}
}在上述代码中，size >> 1 的写法比较少见，“>>”在计算机编程中代表移位操作。常见的移位操作有两种：
>>：向右移位操作，将一个二进制位的操作数按指定移动的位数向右移动，移出位被丢弃，左边移出的空位一律补0，或者补符号位。
<<：向左移位操作，将一个二进制位的操作数按指定移动的位数向左移动，移出位被丢弃，右边移出的空位一律补0。
通过实际的编程验证，我们可以知道：执行右移1位操作，变量数据会缩小为原来的1/2。左移相反。同时，我们可以分析出时间复杂度为O(n)。
2. 更新元素
更新元素操作需要两步：
- 找到要更新的元素
- 执行更新操作
根据位置的不同，可以将更新操作分为三种情况：更新头结点，更新尾结点，更新指定位置结点。
2.1 更新头结点
更新头结点代码与查找头结点类似，如下：
public boolean updateHead(Object obj){
if(head == null){
return false;
}
head.data = obj;
return true;
}更新头结点的时间复杂度为O(1)。
2.2 更新尾结点
public boolean updateLast(Object obj){
if(last == null){
return false;
}
last.data = obj;
}更新尾结点的时间复杂度同样是O(1)。
2.3 更新指定位置结点
public boolean update(int index, Object obj){
if(index < 0 || index >= size){
return false;
}
if(index < (size>>1)){
DNode x = head;
for(int i = 0; i < index; i++){
x = x.next;
}
x.data = obj;
}else {
DNode x = last;
for(int i = size-1; i >= index; i--){
x = last.prev;
}
x.data = obj;
}
return true;
}如上代码所示，修改指定结点元素的值采用的算法也是：先判断要操作的位置在前半段还是后半段，然后再进行精准查找，最后执行修改操作。
指定位置修改操作的时间复杂度为O(n)。
3. 插入元素
分析过了查找元素和更新元素操作的具体情况，我们很清晰的便能分析出插入元素操作的具体情况，其实也分为三种具体情景：头结点位置插入，尾结点位置插入，指定位置插入元素。
3.1 头结点位置插入
public boolean addHead(Object data){
DNode h = head;
DNode newNode = new DNode(null,data,h);
head = newNode;
if(h == null);{
last = newNode;
}else {
h.prev = newNode;
}
size++;
return true;
}根据如上代码，我们可以看到，在头结点位置插入新的元素，只需要将新添加的结点置为head结点，同时处理好新结点和原链表中头结点的指向关系即可。很明显，头结点位置插入的时间复杂度为O(1)。
3.2 尾结点位置插入
尾结点插入与头结点插入原理相同，只需要替换为尾结点以及指针的指向。如下所示：
public boolean addLast(Object data){
DNode l = last;
DNode newNode = new DNode(l,data,null);
last = newNode;
if(last == null){
head = last;
}else {
l.next = newNode;
}
size++;
return true;
}时间复杂度为O(1)。
3.3 指定位置插入
在进行指定位置插入时，编程代码稍多些，原因是需要以下几步完成：
- 判断插入的位置是否超范围
- 若插入的位置在最后，则执行在尾结点的插入逻辑
- 先根据要插入的位置，查找并获取到对应位置的结点元素
- 然后执行插入逻辑
public boolean add(int index,Object data){
if(index < 0 || index > size){
return false;
}
if(index == size){
addLast(data);
return true;
}else {
//先找到要插入的指定位置的结点
DNode x = index(index);
//执行插入操作
DNode prevNode = x.prev;
DNode newNode = new DNode(prevNode,data,x);
x.prev = newNode;
if(prevNode == null){
head = newNode;
}else {
prevNode.next = newNode;
}
size++;
}
}
//查找index位置上的结点并返回
public DNode index(int index){
if( index < 0 || index >= size){
return null;
}
if( index < (size>>1)){
DNode x = head;
for(int i = 0; i < index; i++){
x = x.next;
}
return x;
}else {
DNode x = last;
for(int i = size-1; i >= index; i--){
x = x.prev;
}
return x;
}
}根据上述代码，我们可以发现插入指定位置的代码，需要用到查找指定位置的操作，先查找再插入，因此时间复杂度同样为O(n)。
4. 删除元素
有了前面的分析经验，我们可以非常自然的分析出删除操作同样分三种：删除头结点、删除尾结点、删除指定结点。接下来，一起来看看详细的情况：
4.1 删除头结点
public Object removeHead(){
if(head == null){
return null;
}
DNode h = head;
Object data = h.data;
DNode next = h.next;
//将原来头结点的数据域和指针域均赋值为null置空
h.data = null;
h.next = null;
//将当前结点的next作为新的头结点
head = next;
//如果next为null，则说明当前链表只有一个节点，删除该节点，则链表的first、last都为null
if(next == null){
last = null;
}else {
// next要作为新的头节点，则其prev属性为null
next.prev = null;
}
size--;
return data;
}删除头结点只涉及头结点的逻辑判断和操作，因此删除头结点时间复杂度为O(1)。
4.2 删除尾结点
与删除头结点原理相同，操作尾结点。代码如下：
public Object removeLast(){
DNode l = last;
if(l == null){
return null;
}
Object data = l.data;
DNode prev = l.prev;
//将当前尾节点的属性赋值为null，为了GC清理
l.data = null;
l.prev = null;
// 让当前尾节点的prev作为新的尾节点，赋值给last属性
last = prev;
// 如果prev为null，则说明当前链表只有一个节点，删除该节点，则链表的first、last都为null
if(prev == null){
head = null;
}else {
// prev要作为新的尾节点，则其next属性为null
prev.next = null;
}
size--;
return data;
}很明显，删除尾结点的时间复杂度为O(1)。
4.3 删除指定结点
删除指定结点的编码实现如下：
public Object remove(int index){
if(index < 0 || index >= size){
return null;
}
//首先通过查找方法，查找到
DNode node = index(index;
//执行删除操作
Object data = node.data;
DNode next = node.next;
DNode prev = node.prev;
// 如果prev是null，则说明删除的是当前头节点，则将next作为新的头节点，赋值给head
if(prev == null){
head = prev;
}else {
// 如果删除的不是当前头节点，则将要删除节点的prev与next连接一起，即将prev的next属性赋值成next
prev.next = next;
// 如果prev不是null，则赋值为null
node.prev = null;
}
// 如果next是null，则说明删除的是当前尾节点，则将prev作为新的尾节点，赋值给last
if(next == null){
last = prev;
}else {
// 如果删除的不是当前尾节点，则将要删除节点的prev与next连接一起，即将next的prev赋值成prev
next.prev = prev;
// 如果next不是null，则赋值为null
node.next = null;
}
//将要删除的结点的data数据域设置为null
node.data = null;
//链表的结点个数-1操作
size--;
return data;
}如上代码所示，删除指定位置的结点元素也需要先执行index(index)查找算法，至于index的实现，在前文介绍指定位置插入结点操作时，已经进行了实现，此处直接进行使用。
我们不难分析得到，删除指定位置的结点的时间复杂度是O(n)。
三. 其他操作
作为一种常见的数据结构，除了对自身结点元素的一些操作，还有一些对链表状态的获取，比如链表的长度，链表是否为空等，这里给大家介绍一下双向链表的一些其他操作。
1. 链表的大小(元素结点的个数)
public int size(){
return size;
}2. 判断链表是否为空
public boolean isEmpty(){
return size == 0;
}3. 获取链表元素组成的数组
public Object[] toArray(){
Object[] result = new Object[size];
int i = 0;
for(DNode node = head; node != null; node = node.next){
resunt[i++] = node.data;
}
return result;
}4. 清空链表
public void clear(){
for(DNode node = head; node != null; ){
DNode next = node.next;
node.data = null;
node.next = null;
node.prev = null;
node = next;
}
head = last = null;
size = 0;
}四. 结语
至此，已经连续用两篇文章给大家介绍了链表的相关知识。在上一篇文章中，我们主要介绍了链表的基础知识和单链表的常规操作，同时辅以图示来说明各种操作情况。在本篇文章中，主要是从Java编程角度作为切入点，来进一步讲解双向链表的一些操作。特别是本篇文章中的大量代码实践，需要大家能够理清逻辑关系，希望你可以动手练起来哦。
以上就是Java线性结构中的双向链表实现原理的详细内容，更多关于Java 双向链表实现的资料请关注脚本之家其它相关文章！
相关文章
最近在工作中发现了一个问题，通过查找相关的资料终于解决了，下面这篇文章主要给大家介绍了关于JDBC实现Mysql自动重连机制的相关资料，文中给出多种解决的方法，需要的朋友可以参考借鉴，下面来一起看看吧。2017-07-07
springboot Rabbit MQ topic 配置文件绑定队列和交换机的
本文详细讲解了在SpringBoot中使用RabbitMQ进行队列与交换机的绑定方法,包括创建交换机、队列和绑定它们的步骤,以及如何发送和接收消息,适用于开发高并发系统,如秒杀系统等2024-09-09
这里用到的数据预热,就是在项目启动时将一些数据量较大的数据加载到缓存中（笔者这里用的Redis）,那么在项目启动有哪些方式可以实现数据预热呢,本文就来给大家讲讲几种实现数据预热的方式,需要的朋友可以参考下2023-09-09
Java的String类中的startsWith方法和endsWith方法示例详解
大家应该都知道startsWith()方法用于检测字符串是否以指定的前缀开始,endsWith()方法用于测试字符串是否以指定的后缀结束,本文就Java的String类中的startsWith方法和endsWith方法给大家详细讲解,感兴趣的朋友一起看看吧2023-11-11
这篇文章主要介绍了Java中的TreeSet源码解读,TreeSet 是一个 有序集合,它扩展了 AbstractSet 类并实现了 NavigableSet 接口,对象根据其自然顺序以升序排序和存储,该 TreeSet 中使用 平衡树,更具体的一个 红黑树,需要的朋友可以参考下2023-09-09
这篇文章给大家介绍了代码缩进用空格还是Tab？（IDEA中设置Tab健为4个空格）的相关知识，本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友参考下吧2021-03-03
这篇文章主要介绍了Spring创建bean实例的几种方式分享，文章围绕主题展开详细的内容介绍，具有一定的参考价值，需要的小伙伴可以参考一下2022-07-07
了保证系统数据的一致性,我们需要确保这些服务中的操作要么全部成功,要么全部失败,通过使用RocketMQ实现分布式事务,我们可以协调这些服务的操作,保证数据的一致性,这篇文章主要介绍了基于RocketMQ实现分布式事务,需要的朋友可以参考下2024-03-03
Project Reactor源码解析publishOn使用示例
这篇文章主要为大家介绍了Project Reactor源码解析publishOn使用示例，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪2022-08-08
这是一个使用了java+JSP+Springboot+maven+mysql+ThymeLeaf+FTP开发的在线网盘系统，是一个毕业设计的实战练习，具有网盘该有的所有功能，感兴趣的朋友快来看看吧2022-01-01
最新评论