java双向链表的长度_双向链表的原理与实现

最新推荐文章于 2021-11-26 11:51:30 发布
最新推荐文章于 2021-11-26 11:51:30 发布
阅读量330 收藏
点赞数
文章标签： java双向链表的长度
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39800990/article/details/114616548
版权

一、双向链表原理

顾名思义，双向链表跟单链表和循环列表最大的差别，就是同时拥有前驱指针和后驱指针，基于这一个特性，查询某结点的前一个结点，时间复杂度可以达到O(1)，非常高效。双向链表的存取时间复杂度是O(n)，增删时间复杂度为O(1)，跟其他链表没啥区别。

双向链表表示意图：

885634059be8

双向链表.jpg

所以双向链表的结点定义如下：

class Node{

Object data; //元素值

Node pre; //前驱指针

Node next; //后驱指针

}

对于双向链表做增删操作，有一定的顺序要求，顺序不对，很可能会造成空指针异常。

双向链表增加结点示意图：

885634059be8

双向链表增加结点示意图.png

双向链表删除结点示意图：

885634059be8

双向链表删除结点示意图.png

二、双向链表的实现-java

public class DoubleLinkedList {

/**

* 单向或者循环链表访问下一个结点的时间复杂度都是O(1)，但是访问上个结点的时间复杂度是O(n)

* 所以设计出了双向链表，相比于单向链表，除了有next指针，还有pre指针，可以实现访问上个结点

* 和下个结点的时间复杂度都是O(1)

*

* LinkedHashMap底层都是HashMap+双向链表实现

*/

/**

* 双向链表一般具有以下功能：

* 1.InitDoubleLinkedList() 初始化操作，建立一个空的双向链表

* 2.DoubleLinkedListEmpty() 判断双向链表是否为空，为空则返回true，非空返回false

* 3.DoubleLinkedListInsert(T elem) 在双向链表末尾插入数据，不需要手动指定位置

* 4.DoubleLinkedListInsertWithIndex(int index,T elem) 在双向链表脚标为index处插入新元素

* 5.DoubleLinkedListDelete() 删除双向链表尾部元素，并返回其值

* 6.DoubleLinkedListDeleteWithIndex(int index) 删除指定位置的元素结点，并返回其值

* 7.DoubleLinkedListDeleteWithElem(Object elem) 删除指定元素结点，并返回其值

* 8.DoubleLinkedListLenth() 返回双向链表的长度

* 9.toString() 打印双向链表的所有元素值，用逗号分隔

*/

int doubleLinkedNodeLength = 0; //假设头结点不占用大小

DoubleLinkedNode head = null;

public DoubleLinkedList(){

head = new DoubleLinkedNode(); // 创建一个双向链表的头结点

head.pre = head.next = head; // 初始化一个空的双向链表，头结点的前驱和后继都指向头结点本身

}

class DoubleLinkedNode{

// 定义一个双向链表的结点

Object nodeData = null;

DoubleLinkedNode pre = null;

DoubleLinkedNode next = null;

}

//实现DoubleLinkedListEmpty功能

public Boolean DoubleLinkedListEmpty(){

return doubleLinkedNodeLength == 0?true:false;

}

//实现DoubleLinkedListInsert功能

public Boolean DoubleLinkedListInsert(Object elem){

DoubleLinkedNode insertLinkedNode = null;

if (head.next == head){

//表示是一个空的双向链表

insertLinkedNode = new DoubleLinkedNode();

insertLinkedNode.nodeData = elem;

insertLinkedNode.pre = head;

insertLinkedNode.next = head;

head.next = insertLinkedNode;

head.pre = insertLinkedNode;

doubleLinkedNodeLength++;

return true;

}

insertLinkedNode = new DoubleLinkedNode();

insertLinkedNode.nodeData = elem;

insertLinkedNode.next = head;

insertLinkedNode.pre = head.pre;

head.pre.next = insertLinkedNode;

head.pre = insertLinkedNode;

doubleLinkedNodeLength++;

return true;

}

//实现DoubleLinkedListInsertWithIndex功能

public Boolean DoubleLinkedListInsertWithIndex(int index,Object elem){

DoubleLinkedNode insertLinkedNode = null;

if (index <= 0 || index > doubleLinkedNodeLength+1){

return false;

}

if (index == 1){

//表示要插入头结点后面的位置

if (doubleLinkedNodeLength == 0){

//表示双向链表为空

insertLinkedNode = new DoubleLinkedNode();

insertLinkedNode.nodeData = elem;

insertLinkedNode.pre = head;

insertLinkedNode.next = head;

head.next = insertLinkedNode;

head.pre = insertLinkedNode;

doubleLinkedNodeLength++;

return true;

}else{

//表示双向链表非空

insertLinkedNode = new DoubleLinkedNode();

insertLinkedNode.nodeData = elem;

insertLinkedNode.next = head.next;

insertLinkedNode.pre = head;

head.next.pre = insertLinkedNode;

head.next = insertLinkedNode;

doubleLinkedNodeLength++;

return true;

}

}

if (index == doubleLinkedNodeLength+1){

// 表示需要插入到双向链表的最后一个位置，需要修改head.pre

insertLinkedNode = new DoubleLinkedNode();

insertLinkedNode.nodeData = elem;

insertLinkedNode.next = head;

insertLinkedNode.pre = head.pre;

head.pre.next = insertLinkedNode;

head.pre = insertLinkedNode;

doubleLinkedNodeLength++;

return true;

}

int currIndex = 1;

DoubleLinkedNode currLinkedNode = head.next;

while (currIndex != index){

currIndex++;

currLinkedNode = currLinkedNode.next;

}

insertLinkedNode = new DoubleLinkedNode();

insertLinkedNode.nodeData = elem;

insertLinkedNode.next = currLinkedNode;

insertLinkedNode.pre = currLinkedNode.pre;

currLinkedNode.pre.next = insertLinkedNode;

currLinkedNode.pre = insertLinkedNode;

doubleLinkedNodeLength++;

return true;

}

//实现DoubleLinkedListDelete功能

public Object DoubleLinkedListDelete(){

DoubleLinkedNode rearLinkedNode = null; //待删除的尾部结点

Object elem = null;

if (doubleLinkedNodeLength == 0){return -1;}

rearLinkedNode = head.pre;

elem = rearLinkedNode.nodeData;

rearLinkedNode.pre.next = rearLinkedNode.next;

rearLinkedNode.next.pre = rearLinkedNode.pre;

rearLinkedNode.pre = rearLinkedNode.next = null;

doubleLinkedNodeLength--;

return elem;

}

//实现DoubleLinkedListDeleteWithIndex功能

public Object DoubleLinkedListDeleteWithIndex(int index){

DoubleLinkedNode LinkedNode = null;

Object elem = null;

if (doubleLinkedNodeLength == 0){return -1;}

if (index <= 0 || index > doubleLinkedNodeLength){return -1;}

int currindex = 1;

DoubleLinkedNode currLinkedNode = head.next;

while (currindex != index){

currindex++;

currLinkedNode = currLinkedNode.next;

}

elem = currLinkedNode.nodeData;

currLinkedNode.pre.next = currLinkedNode.next;

currLinkedNode.next.pre = currLinkedNode.pre;

currLinkedNode.pre = currLinkedNode.next = null;

doubleLinkedNodeLength--;

return elem;

}

//实现DoubleLinkedListDeleteWithElem功能

public Object DoubleLinkedListDeleteWithElem(Object elem){

DoubleLinkedNode LinkedNode = head.next;

Object deleteElem = null;

if (doubleLinkedNodeLength == 0){return -1;}

while (LinkedNode != head){

if (!(LinkedNode.nodeData.equals(elem))){

LinkedNode = LinkedNode.next;

continue;

}else{

break;

}

}

if (LinkedNode == head){return -1;} //表示未找到对应的元素结点

deleteElem = LinkedNode.nodeData;

LinkedNode.pre.next = LinkedNode.next;

LinkedNode.next.pre = LinkedNode.pre;

LinkedNode.pre = LinkedNode.next = null;

doubleLinkedNodeLength--;

return deleteElem;

}

//实现DoubleLinkedListLenth功能

public int DoubleLinkedListLenth(){

return doubleLinkedNodeLength;

}

//实现toString功能

public String toString(){

if (doubleLinkedNodeLength == 0){return "";}

DoubleLinkedNode doubleLinkedNode = head.next;

StringBuffer stringBuffer = new StringBuffer();

for (;doubleLinkedNode != head;doubleLinkedNode = doubleLinkedNode.next){

if (doubleLinkedNode.next != head){

stringBuffer.append(doubleLinkedNode.nodeData);

stringBuffer.append(",");

}else{

stringBuffer.append(doubleLinkedNode.nodeData);

}

}

return stringBuffer.toString();

}

public static void main(String[] args) {

}

}

三、用双向链表来实现LRU算法

3.1LRU(最近最少使用)算法

将不常被访问的数据进行淘汰，来保证有限空间的使用，在计算机cache当中广为应用，因为cache的大小有限，为了尽可能多的命中热数据，就可以将冷数据进行淘汰，充分利用内存空间。

3.2LRU核心思想

-》put进数据时，将其放于链尾，因为链尾的数据最不容易被淘汰，并且插入之前需要判断一下空间是否已满，如果满了，就需要将链头的数据淘汰掉。

-》get数据时，如果未在cache中命中，就返回-1，来模拟cache未命中的现象，如果命中，将该数据从当前位置删除，并移至链尾。

3.3使用双向链表来实现以下LRU算法

public class LeastRecentlyUsed {

/**

* 使用双向链表来实现LRU

* -》put方法

* -》get方法

*/

private DoubleLinkedList doubleLinkedList = null;

private int maxSize; // 内存大小

private int currSize; // 当前双向链表的大小

public LeastRecentlyUsed(int maxSize){

// 初始化LRU算法类的时候，生成一个双向链表

doubleLinkedList = new DoubleLinkedList();

this.maxSize = maxSize;

}

//实现put方法

public Boolean put(Object elem){

// get the doubleLinkedList currently size

currSize = doubleLinkedList.DoubleLinkedListLenth();

if (currSize == maxSize){

// 表示cache目前已处于待溢出状态

//先删除头结点后面的第一个结点数据，在插入数据

doubleLinkedList.DoubleLinkedListDeleteWithIndex(1);

//在双向链表的尾部添加数据

return doubleLinkedList.DoubleLinkedListInsert(elem);

}else{

//在双向链表的尾部添加数据

return doubleLinkedList.DoubleLinkedListInsert(elem);

}

}

//实现get方法

public Boolean get(Object elem){

// 直接删除该元素结点，如果存在返回该元素值，如果不存在返回-1

doubleLinkedList.DoubleLinkedListDeleteWithElem(elem);

// 在链表尾部插入该数据

doubleLinkedList.DoubleLinkedListInsert(elem);

return true;

}

//实现toString功能，方便进行测试使用

public String toString(){

return doubleLinkedList.toString();

}

public static void main(String[] args) {

}

}

3.4使用双向链表实现LRU算法复杂度分析

之前也提到过，双向链表同其他链表一样，存取时间复杂度都是O(n)，因为都是需要遍历链表才行，增删操作的时间复杂度都是O(1)。实现LRU的过程，如果是put操作，那么针对双向链表的操作只有删除第一个结点，然后添加尾结点，时间复杂度为O(1)，如果是get操作，需要先遍历查找到对应的结点，然后在进行增删操作，前者时间复杂度为O(n)，后者时间复杂度为O(1)，所以加起来还是O(n)。

后续为大家介绍一种实现LRU算法，并且时间复杂度为O(1)的实现方式。

LRU算法的原理与实现

weixin_39800990
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构6-双向链表和单向链表的时间复杂度对比分析
weixin_33805557的博客
06-05 1万+
单向链表的时间复杂度 在单向链表原理和实现中已经和动态数组相比对比并分析了单向链表的时间复杂度： 情况分类 添加 删除 最好 头节点 O(1) O(1) 最差 尾节点 O(n) O(n) 平均 O(n) O(n) 双向链表的时间复杂度 查找节点 因为对节点的添加和删除操作需要查找对于index的节点，首先分析以下查找节点的代码： - (JKRLinkedListNode...
Java双向链表时间复杂度_链表是什么？有多少种链表？时间复杂度是？
weixin_33093437的博客
02-26 2757
链表(Linked list)是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而顺序表相应的时间复杂度分别是O(logn)和O(1)。使用链表结构可以克服数组链表需要...
链表详解（双向）
o8699458的博客
08-07 236
链表双链表的介绍双链表的创建双链表的长度双链表的插入双链表的删除 双链表的介绍 看到这里，我相信你们都已经对单向链表有一定的了解，与数组相比较，链表在处理插入和删除的时候非常好用，缺点是消耗的空间较大，而且还不能通过下标进行访问。 链表有单向和双向，单向查询困难，要找到某个元素需要将这个元素之前的位置都遍历一遍。除此之外，单向的链表想要访问上一级特别困难。在此基础上，出现了双链表。 这就是双链表，双链表的头节点prev可以为NULL，也可以与链表末端链接形成双向循环链表。 双链表的创建 首先要创建一个
单链表和双链表的删除和插入的时间复杂度分析
lxr_17的博客
08-11 7802
单链表和双链表的删除和插入的时间复杂度分析 单向链表要删除某一节点时，必须要先通过遍历的方式找到前驱节点（开发中大致分为两种删除方式:1.通过待删除节点序号2.按值查找）。若仅仅知道待删除节点，是不能知道前驱节点的，故单链表的增删操作复杂度为O(n)。 双链表（双向链表）知道要删除某一节点p时，获取其前驱节点q的方式为 q = p->prior，不必再进行遍历。故时间复杂度为O(1)。而若只知道待删除节点的序号，则依然要按序查找，时间复杂度仍为O(n)。 单、双链表的插入操作
单链表，循环链表，双向链表时间复杂度比较
weixin_52634719的博客
09-20 5671
注意看带头结点的双向链表，他的时间效率，不管哪种操作，都是O(1),实际上是利用了空间提高时间
java中使用双向链表实现贪吃蛇程序源码分享
09-03
通过这样的方式，双向链表在贪吃蛇游戏中发挥了关键作用，它允许蛇的快速移动和长度的变化，使得游戏的实现变得简单高效。双向链表的特性使得在链表的任何位置添加或删除节点都具有O(1)的时间复杂度，这在处理动态...
Java中双向链表详解及实例
08-30
下面将详细介绍Java中如何实现双向链表，并通过实例代码进行讲解。 首先，为了实现双向链表，我们需要定义一个内部类`Node`，用于表示链表中的每个节点。`Node`类包含三个字段：`data`存储节点的数据，`prev`引用前...
java数据结构之实现双向链表的示例
09-04
本示例将详细介绍如何在Java中实现一个简单的双向链表，并提供相关的操作方法。 双向链表由一系列节点组成，每个节点包含三个主要部分：数据（存储实际信息）、前驱节点引用（指向前面的节点）和后继节点引用（指向...
java基于双向环形链表解决丢手帕问题的方法示例
08-28
在Java语言中，可以使用两个类来实现双向环形链表：Child类和CycleLink类。Child类代表一个小孩，具有no、nextChild和previousChild三个属性，分别表示小孩的编号、下一个小孩和上一个小孩。CycleLink类代表双向环形...
面向对象实现带头双向链表.zip
11-05
"面向对象实现带头双向链表"的主题旨在利用C语言中的结构体和指针来创建一个双向链表的数据结构，并通过面向对象的方式组织代码。以下是对这个主题的详细讲解： 首先，我们需要理解双向链表的基本概念。双向链表与...
数组和链表（单双链表）的时间复杂度
dl674756321的博客
11-15 5148
数组 优点：构建简单，能在O(1)的时间里根据数组下标来查询某个元素。 缺点：构建时需要分配一段连续的空间，查询某个元素时需要遍历整个数组，耗费O(n)的时间。删除和添加元素同样需要耗费O(n)的时间。 ...
【数据结构】之双向链表的复杂度分析
yang553566463的博客
11-26 8934
双向链表的复杂度分析 我们先看一下它的概念（来自百度百科）： 它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。 和单向链表不同的是，双链表除了有一个指向下一节点的指针外，还有一个指向前一节点的指针，这也就意味着，双向链表能够快速找到前驱节点，也能快速找到后驱节点。 和单向链表相比，对于插入或删除指定节点的操作，因为单向链表需要从头遍历定位到这个节点的前驱节点，所以它的平均复杂度是O(n
数据结构--双向链表
u010995263的专栏
06-22 704
双向链表： 双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。 图示： 代码如下： DoubleList.h #ifndef DOUBLELIST_H_ #define DOUBLELIST_H_ typedef char ElemType; type
取得双向链表长度 -- C语言
六六哥的博客
02-18 1167
代码实现 int getDoubListLen(st_doubNode * head){ int len = 0; st_doubNode * p = NULL; if(NULL == head){ goto out; } p = head; while(NULL != p){ len++; p = p->next; } out: return le...
数据结构—双向链表的基本操作
小虾米编程
06-20 7702
1.双向链表的操作 双向链表的基本操作包括：判断链表是否为空、计算链表的长度、遍历链表，这3中操作的方法和单链表一样，主要和双向链表中的指向后继的指针有关。 双向链表的插入和删除操作和单链表是有区别的：双向链表的插入和删除操作要修改指向前驱和指向后继的指针。 2.双向链表的删除：删除指定位置 i 的元素 1.判断输入的删除的位置是否合法，1<=i<=表长 2.顺着指向后继的指针...
【链表】双向链表的基本操作详解(C语言)
热门推荐
HongKnight的博客
06-10 2万+
本文是单链表的C语言实现方法，包括单链表的创建、插入、删除、修改、查找等基本操作。 双链表是链表中的一种，他和单链表一样都是通过指针将一个个结点连接起来。他和单链表不同的地方在于：单链表的每个结点的指向只有一个，双向链表每个结点有两个指向。 双向链表结点结构体 双向链表每个结点除了存储数据data外，还有两个指针记录上一个结点和下一个结点的地址，分别是前驱指针prev和后继指针next，所以双向链...
JAVA实现双向链表终极解析！！熟练使用接口
一杯咖啡
08-21 6204
双向链表结构和单向链表的区别：最后一个结点的链接地址上，单向链表是null,而双向链表是表头的链接地址。 即双向链表的head和last互相指向 示意图 表头为空        head之前的节点是last=50这个节点 ，head之后的节点是first=10这个节点 last之前是40这个节点，last之后是head这个头节点 双向链表删除节点 删除
数据结构与算法--双向链表
storyfull
11-05 204
阅读目录
java实现双向链表(附完整源码)
最新发布
06-09
下面是Java实现双向链表的完整源码： ```java public class DoublyLinkedList<T> { private Node head; private Node tail; private int size; public DoublyLinkedList() { head = null; tail = null; size = 0; } private class Node { T data; Node prev; Node next; public Node(T data) { this.data = data; prev = null; next = null; } } public int size() { return size; } public boolean isEmpty() { return size == 0; } public void addFirst(T data) { Node newNode = new Node(data); if (isEmpty()) { tail = newNode; } else { head.prev = newNode; newNode.next = head; } head = newNode; size++; } public void addLast(T data) { Node newNode = new Node(data); if (isEmpty()) { head = newNode; } else { tail.next = newNode; newNode.prev = tail; } tail = newNode; size++; } public void add(int index, T data) { if (index < 0 || index > size) { throw new IndexOutOfBoundsException("Invalid index!"); } if (index == 0) { addFirst(data); return; } if (index == size) { addLast(data); return; } Node current = head; for (int i = 0; i < index - 1; i++) { current = current.next; } Node newNode = new Node(data); newNode.prev = current; newNode.next = current.next; current.next.prev = newNode; current.next = newNode; size++; } public T removeFirst() { if (isEmpty()) { throw new RuntimeException("Empty list!"); } T data = head.data; head = head.next; if (head == null) { tail = null; } else { head.prev = null; } size--; return data; } public T removeLast() { if (isEmpty()) { throw new RuntimeException("Empty list!"); } T data = tail.data; tail = tail.prev; if (tail == null) { head = null; } else { tail.next = null; } size--; return data; } public T remove(int index) { if (index < 0 || index >= size) { throw new IndexOutOfBoundsException("Invalid index!"); } if (index == 0) { return removeFirst(); } if (index == size - 1) { return removeLast(); } Node current = head; for (int i = 0; i < index; i++) { current = current.next; } current.prev.next = current.next; current.next.prev = current.prev; size--; return current.data; } public T get(int index) { if (index < 0 || index >= size) { throw new IndexOutOfBoundsException("Invalid index!"); } Node current = head; for (int i = 0; i < index; i++) { current = current.next; } return current.data; } public void set(int index, T data) { if (index < 0 || index >= size) { throw new IndexOutOfBoundsException("Invalid index!"); } Node current = head; for (int i = 0; i < index; i++) { current = current.next; } current.data = data; } public boolean contains(T data) { Node current = head; while (current != null) { if (current.data.equals(data)) { return true; } current = current.next; } return false; } public void clear() { head = null; tail = null; size = 0; } public String toString() { StringBuilder sb = new StringBuilder(); sb.append("["); Node current = head; while (current != null) { sb.append(current.data); if (current.next != null) { sb.append(", "); } current = current.next; } sb.append("]"); return sb.toString(); } } ``` 代码中使用了嵌套类Node表示双向链表中的每个节点，包含一个数据域和两个指针域（prev和next），分别指向前驱节点和后继节点。 程序首先定义了一个DoublyLinkedList类，包含头节点head、尾节点tail和链表长度size三个属性。然后，程序实现了以下方法： - size：返回链表长度 - isEmpty：判断链表是否为空 - addFirst：在链表头部插入一个元素 - addLast：在链表尾部插入一个元素 - add：在指定位置插入一个元素 - removeFirst：删除链表头部元素 - removeLast：删除链表尾部元素 - remove：删除指定位置的元素 - get：获取指定位置的元素 - set：设置指定位置的元素 - contains：判断链表中是否包含指定元素 - clear：清空链表 - toString：将链表转换为字符串形式 以上是Java实现双向链表的完整源码，希望能对你有所帮助。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值