devbox
你好赵伟
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

链表——LinkedList类的概述和实现_linkedlist实现

作者：你好赵伟 | 2024-06-16 10:28:13

赞

踩

linkedlist实现

LinkedList类

1.1LinkedList类概述

  • LinkedList类底层是基于双向链表结构实现的，不同于ArrayList类和Vector类是基于数组实现的；
  • LinkedList类是非线程安全的；
  • LinkedList类元素允许为null，允许重复元素；
  • LinkedList类插入、删除效率高，查询效率低；
  • LinkedList类基于链表实现的，因此不存在容量不足的问题，不用动态扩容；
  • 双向链表有三个区域，前指针域、数据域、后指针域。
  • LinkedList 是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。
  • LinkedList 实现 List 接口，能对它进行队列操作。
  • LinkedList 实现 Deque 接口，即能将LinkedList当作双端队列使用。
  • LinkedList 实现了Cloneable接口，即覆盖了函数clone()，能克隆。
  • LinkedList 实现java.io.Serializable接口，这意味着LinkedList支持序列化，能通过序列化去传输。
  • LinkedList 是非同步的。

1.2LinkedList类的方法

与ArrayList类相似，LinkedList类常见方法也有add()、get()、remove()、set()、size()等，用法也类似。

  • Object getFirst（）        返回链表的第一个元素。
  • Object getLast（）        返回链接列表的最后一个元素。
  • boolean contains（Object element）如果元素存在于列表中，则返回true。
  • void clear（）                删除列表中的所有元素。 

1.3LinkedList类的特点

  • LinkedList的底层结构为双向链表，将零散的内存单元通过附加的引用关联起来体现出其顺序性，相比数组的连续空间存储，链表对内存的利用率更高；
  • 有序：插入元素的顺序和取出顺序一致；
  • 可重复：可以插入相同的元素（元素值也允许为null）；
  • 插入、删除操作效率高，和ArrayList恰恰相反，按索引查找效率较低；
  • 线程不安全：没有线程锁，多个线程同步进行写操作的时候可能导致数据错误；
  • 使用场景：不会随机访问数据，更多的插入删除操作，更少的查询读取操作。 

链表

链表通常由一连串节点组成，每个节点包含任意的实例数据（data fields）和一或两个用来指向上一个/或下一个节点的位置的链接（links）

链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)。

使用链表结构可以克服数组链表需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。但是链表失去了数组随机读取的优点，同时链表由于增加了结点的指针域，空间开销比较大。

单向链表

普通链表，也叫单链表或者单向链表（Single-Linked List）。单链表是链表中结构最简单的。

一个单链表的节点(Node)分为两个部分，第一个部分(data)保存或者显示关于节点的信息，另一个部分存储下一个节点的地址。最后一个节点存储地址的部分指向空值。

  • 查找：单向链表只可向一个方向遍历，一般查找一个节点的时候需要从第一个节点开始每次访问下一个节点，一直访问到需要的位置。
  • 插入：而插入一个节点，对于单向链表，我们只提供在链表头插入，只需要将当前插入的节点设置为头节点，next指向原头节点即可。
  • 删除：删除一个节点，我们将该节点的上一个节点的next指向该节点的下一个节点。

查找图：

在表头增加节点：

删除节点：

2.1 单向链表的具体实现

  1. public class SingleLinkedList {
  2.     private int size;//链表节点的个数
  3.     private Node head;//头节点
  4.  
  5.     public SingleLinkedList() {
  6.         size = 0;
  7.         head = null;
  8.     }
  9.  
  10.     //链表的每个节点类
  11.     private class Node {
  12.         private Object data;//每个节点的数据
  13.         private Node next;//每个节点指向下一个节点的连接
  14.  
  15.         public Node(Object data) {
  16.             this.data = data;
  17.         }
  18.     }
  19.  
  20.     //在链表头添加元素
  21.     public Object addHead(Object obj) {
  22.         Node newHead = new Node(obj);
  23.         if (size == 0) {
  24.             head = newHead;
  25.         } else {
  26.             newHead.next = head;
  27.             head = newHead;
  28.         }
  29.         size++;
  30.         return obj;
  31.     }
  32.  
  33.     //在链表头删除元素
  34.     public Object deleteHead() {
  35.         Object obj = head.data;
  36.         head = head.next;
  37.         size--;
  38.         return obj;
  39.     }
  40.  
  41.     //查找指定元素，找到了返回节点Node，找不到返回null
  42.     public Node find(Object obj) {
  43.         Node current = head;
  44.         int tempSize = size;
  45.         while (tempSize > 0) {
  46.             if (obj.equals(current.data)) {
  47.                 return current;
  48.             } else {
  49.                 current = current.next;
  50.             }
  51.             tempSize--;
  52.         }
  53.         return null;
  54.     }
  55.  
  56.     //删除指定的元素，删除成功返回true
  57.     public boolean delete(Object value) {
  58.         if (size == 0) {
  59.             return false;
  60.         }
  61.         Node current = head;
  62.         Node previous = head;
  63.         while (current.data != value) {
  64.             if (current.next == null) {
  65.                 return false;
  66.             } else {
  67.                 previous = current;
  68.                 current = current.next;
  69.             }
  70.         }
  71.         //如果删除的节点是第一个节点
  72.         if (current == head) {
  73.             head = current.next;
  74.             size--;
  75.         } else {//删除的节点不是第一个节点
  76.             previous.next = current.next;
  77.             size--;
  78.         }
  79.         return true;
  80.     }
  81.  
  82.     //判断链表是否为空
  83.     public boolean isEmpty() {
  84.         return (size == 0);
  85.     }
  86.  
  87.     //显示节点信息
  88.     public void display() {
  89.         if (size > 0) {
  90.             Node node = head;
  91.             int tempSize = size;
  92.             if (tempSize == 1) {//当前链表只有一个节点
  93.                 System.out.println("[" + node.data + "]");
  94.                 return;
  95.             }
  96.             while (tempSize > 0) {
  97.                 if (node.equals(head)) {
  98.                     System.out.print("[" + node.data + "->");
  99.                 } else if (node.next == null) {
  100.                     System.out.print(node.data + "]");
  101.                 } else {
  102.                     System.out.print(node.data + "->");
  103.                 }
  104.                 node = node.next;
  105.                 tempSize--;
  106.             }
  107.             System.out.println();
  108.         } else {//如果链表一个节点都没有，直接打印[]
  109.             System.out.println("[]");
  110.         }
  111.     }
  112. }

测试：

  1. public void testSingleLinkedList(){
  2.     SingleLinkedList singleList = new SingleLinkedList();
  3.     singleList.addHead("A");
  4.     singleList.addHead("B");
  5.     singleList.addHead("C");
  6.     singleList.addHead("D");
  7.     //打印当前链表信息
  8.     singleList.display();
  9.     //删除C
  10.     singleList.delete("C");
  11.     singleList.display();
  12.     //查找B
  13.     System.out.println(singleList.find("B").data);
  14. }

打印结果：

  1. [D->C->B->A]
  2. [D->B->A]
  3. B

2.2 用单向链表实现栈

栈的pop()方法和push()方法，对应于链表的在头部删除元素deleteHead()以及在头部增加元素addHead()。

  1. public class StackSingleLink {
  2.     private SingleLinkedList link;
  3.     
  4.     public StackSingleLink() {
  5.         link = new SingleLinkedList();
  6.     }
  7.     
  8.     //添加元素
  9.     public void push(Object obj) {
  10.         link.addHead(obj);
  11.     }
  12.     
  13.     //移除栈顶元素
  14.     public Object pop() {
  15.         Object obj = link.deleteHead();
  16.         return obj;
  17.     }
  18.     
  19.     //判断是否为空
  20.     public boolean isEmpty() {
  21.         return link.isEmpty();
  22.     }
  23.     
  24.     //打印栈内元素信息
  25.     public void display() {
  26.         link.display();
  27.     }
  28. }

双端链表（单向引用）

对于单向链表，我们如果想在尾部添加一个节点，那么必须从头部一直遍历到尾部，找到尾节点，然后在尾节点后面插入一个节点。这样操作很麻烦，如果我们在设计链表的时候多个对尾节点的引用，那么会简单很多。

链表的节点类保留下一节点的引用（单向引用）。这就是双端链表。

双端链表：保留对头节点、尾节点的引用，可以从尾节点插入，但只能从头节点删除，只能从一个方向遍历，相当于单向链表多了一个对尾节点的引用。

双端链表的特点：双端链表的含有对第一个节点和最后一个节点的引用。

双端链表的操作读取（引用）插入删除
头部√√√
尾部√√x

注意和后面讲的双向链表的区别！！！

3.1 双端链表的具体实现

  1. public class DoublePointLinkedList {
  2.     private Node head;//头节点
  3.     private Node tail;//尾节点
  4.     private int size;//节点的个数
  5.  
  6.     private class Node {
  7.         private Object data;
  8.         private Node next;
  9.  
  10.         public Node(Object data) {
  11.             this.data = data;
  12.         }
  13.     }
  14.  
  15.     public DoublePointLinkedList() {
  16.         size = 0;
  17.         head = null;
  18.         tail = null;
  19.     }
  20.  
  21.     //链表头新增节点
  22.     public void addHead(Object data) {
  23.         Node node = new Node(data);
  24.         if (size == 0) {//如果链表为空，那么头节点和尾节点都是该新增节点
  25.             head = node;
  26.             tail = node;
  27.             size++;
  28.         } else {
  29.             node.next = head;
  30.             head = node;
  31.             size++;
  32.         }
  33.     }
  34.  
  35.     //链表尾新增节点
  36.     public void addTail(Object data) {
  37.         Node node = new Node(data);
  38.         if (size == 0) {//如果链表为空，那么头节点和尾节点都是该新增节点
  39.             head = node;
  40.             tail = node;
  41.             size++;
  42.         } else {
  43.             tail.next = node;
  44.             tail = node;
  45.             size++;
  46.         }
  47.     }
  48.  
  49.     //删除头部节点，成功返回true，失败返回false
  50.     public boolean deleteHead() {
  51.         if (size == 0) {//当前链表节点数为0
  52.             return false;
  53.         }
  54.         if (head.next == null) {//当前链表节点数为1
  55.             head = null;
  56.             tail = null;
  57.         } else {
  58.             head = head.next;
  59.         }
  60.         size--;
  61.         return true;
  62.     }
  63.  
  64.     //判断是否为空
  65.     public boolean isEmpty() {
  66.         return (size == 0);
  67.     }
  68.  
  69.     //获得链表的节点个数
  70.     public int getSize() {
  71.         return size;
  72.     }
  73.  
  74.     //显示节点信息
  75.     public void display() {
  76.         if (size > 0) {
  77.             Node node = head;
  78.             int tempSize = size;
  79.             if (tempSize == 1) {//当前链表只有一个节点
  80.                 System.out.println("[" + node.data + "]");
  81.                 return;
  82.             }
  83.             while (tempSize > 0) {
  84.                 if (node.equals(head)) {
  85.                     System.out.print("[" + node.data + "->");
  86.                 } else if (node.next == null) {
  87.                     System.out.print(node.data + "]");
  88.                 } else {
  89.                     System.out.print(node.data + "->");
  90.                 }
  91.                 node = node.next;
  92.                 tempSize--;
  93.             }
  94.             System.out.println();
  95.         } else {//如果链表一个节点都没有，直接打印[]
  96.             System.out.println("[]");
  97.         }
  98.     }
  99. }

3.2 用双端链表实现队列

  1. public class QueueLinkedList {
  2.     
  3.     private DoublePointLinkedList dp;
  4.  
  5.     public QueueLinkedList() {
  6.         dp = new DoublePointLinkedList();
  7.     }
  8.  
  9.     public void insert(Object data) {
  10.         dp.addTail(data);
  11.     }
  12.  
  13.     public void delete() {
  14.         dp.deleteHead();
  15.     }
  16.  
  17.     public boolean isEmpty() {
  18.         return dp.isEmpty();
  19.     }
  20.  
  21.     public int getSize() {
  22.         return dp.getSize();
  23.     }
  24.  
  25.     public void display() {
  26.         dp.display();
  27.     }
  28.     
  29. }

双向链表

我们知道单向链表只能从一个方向遍历，那么双向链表(Double-Linked List)它可以从两个方向遍历。

具体代码实现：

  1. public class TwoWayLinkedList {
  2.     private Node head;//表示链表头
  3.     private Node tail;//表示链表尾
  4.     private int size;//表示链表的节点个数
  5.  
  6.     private class Node {
  7.         private Object data;
  8.         private Node next;
  9.         private Node prev;
  10.  
  11.         public Node(Object data) {
  12.             this.data = data;
  13.         }
  14.     }
  15.  
  16.     public TwoWayLinkedList() {
  17.         size = 0;
  18.         head = null;
  19.         tail = null;
  20.     }
  21.  
  22.     //在链表头增加节点
  23.     public void addHead(Object value) {
  24.         Node newNode = new Node(value);
  25.         if (size == 0) {
  26.             head = newNode;
  27.             tail = newNode;
  28.             size++;
  29.         } else {
  30.             head.prev = newNode;
  31.             newNode.next = head;
  32.             head = newNode;
  33.             size++;
  34.         }
  35.     }
  36.  
  37.     //在链表尾增加节点
  38.     public void addTail(Object value) {
  39.         Node newNode = new Node(value);
  40.         if (size == 0) {
  41.             head = newNode;
  42.             tail = newNode;
  43.             size++;
  44.         } else {
  45.             newNode.prev = tail;
  46.             tail.next = newNode;
  47.             tail = newNode;
  48.             size++;
  49.         }
  50.     }
  51.  
  52.     //删除链表头
  53.     public Node deleteHead() {
  54.         Node temp = head;
  55.         if (size != 0) {
  56.             head = head.next;
  57.             head.prev = null;
  58.             size--;
  59.         }
  60.         return temp;
  61.     }
  62.  
  63.     //删除链表尾
  64.     public Node deleteTail() {
  65.         Node temp = tail;
  66.         if (size != 0) {
  67.             tail = tail.prev;
  68.             tail.next = null;
  69.             size--;
  70.         }
  71.         return temp;
  72.     }
  73.  
  74.     //获得链表的节点个数
  75.     public int getSize() {
  76.         return size;
  77.     }
  78.  
  79.     //判断链表是否为空
  80.     public boolean isEmpty() {
  81.         return (size == 0);
  82.     }
  83.  
  84.     //显示节点信息
  85.     public void display() {
  86.         if (size > 0) {
  87.             Node node = head;
  88.             int tempSize = size;
  89.             if (tempSize == 1) {//当前链表只有一个节点
  90.                 System.out.println("[" + node.data + "]");
  91.                 return;
  92.             }
  93.             while (tempSize > 0) {
  94.                 if (node.equals(head)) {
  95.                     System.out.print("[" + node.data + "->");
  96.                 } else if (node.next == null) {
  97.                     System.out.print(node.data + "]");
  98.                 } else {
  99.                     System.out.print(node.data + "->");
  100.                 }
  101.                 node = node.next;
  102.                 tempSize--;
  103.             }
  104.             System.out.println();
  105.         } else {//如果链表一个节点都没有，直接打印[]
  106.             System.out.println("[]");
  107.         }
  108.  
  109.     }
  110. }

有序链表

前面的链表实现插入数据都是无序的，无序链表最大特点就是在头部或尾部增加新节点。在有些应用中需要链表中的数据有序。

有序链表：递增，递减或者其他满足一定条件的规则，插入数据时，从头结点开始遍历每个节点，在满足规则的地方插入新节点。

在有序链表中，数据是按照关键值有序排列的。一般在大多数需要使用有序数组的场合也可以使用有序链表。有序链表优于有序数组的地方是插入的速度（因为元素不需要移动），另外链表可以扩展到全部有效的使用内存，而数组只能局限于一个固定的大小中。

  1. public class OrderLinkedList {
  2.     private Node head;
  3.  
  4.     private class Node {
  5.         private int data;
  6.         private Node next;
  7.  
  8.         public Node(int data) {
  9.             this.data = data;
  10.         }
  11.     }
  12.  
  13.     public OrderLinkedList() {
  14.         head = null;
  15.     }
  16.  
  17.     //插入节点，并按照从小打到的顺序排列
  18.     public void insert(int value) {
  19.         Node node = new Node(value);
  20.         Node pre = null;
  21.         Node current = head;
  22.         while (current != null && value > current.data) {
  23.             pre = current;
  24.             current = current.next;
  25.         }
  26.         if (pre == null) {
  27.             head = node;
  28.             head.next = current;
  29.         } else {
  30.             pre.next = node;
  31.             node.next = current;
  32.         }
  33.     }
  34.  
  35.     //删除头节点
  36.     public void deleteHead() {
  37.         head = head.next;
  38.     }
  39.  
  40.     public void display() {
  41.         Node current = head;
  42.         while (current != null) {
  43.             System.out.print(current.data + " ");
  44.             current = current.next;
  45.         }
  46.         System.out.println("");
  47.     }
  48. }

在有序链表中插入和删除某一项最多需要O(N)次比较，平均需要O(N/2)次，因为必须沿着链表上一步一步走才能找到正确的插入位置，然而可以最快速度删除最值，因为只需要删除表头即可，如果一个应用需要频繁的存取最小值，且不需要快速的插入，那么有序链表是一个比较好的选择方案。比如优先级队列可以使用有序链表来实现。

5.1 有序链表和无序数组组合排序

比如有一个无序数组需要排序，解冒泡排序、选择排序、插入排序这三种简单的排序时，需要的时间级别都是O(N^2^)。

现在我们讲解了有序链表之后，对于一个无序数组，我们先将数组元素取出，一个一个的插入到有序链表中，然后将他们从有序链表中一个一个删除，重新放入数组，那么数组就会排好序了。

和插入排序一样，如果插入了N个新数据，那么进行大概N^2^/4次比较。但是相对于插入排序，每个元素只进行了两次排序，一次从数组到链表，一次从链表到数组，大概需要2*N次移动，而插入排序则需要N^2^次移动，

效率肯定是比前面讲的简单排序要高，但是缺点就是需要开辟差不多两倍的空间，而且数组和链表必须在内存中同时存在，如果有现成的链表可以用，那么这种方法还是挺好的。

总结

上面我们讲了各种链表，每个链表都包括一个LinkedList对象和许多Node对象，LinkedList对象通常包含头和尾节点的引用，分别指向链表的第一个节点和最后一个节点。

而每个节点对象通常包含数据部分data，以及对上一个节点的引用prev和下一个节点的引用next，只有下一个节点的引用称为单向链表，两个都有的称为双向链表。

next值为null则说明是链表的结尾，如果想找到某个节点，我们必须从第一个节点开始遍历，不断通过next找到下一个节点，直到找到所需要的。

栈和队列都是ADT，可以用数组来实现，也可以用链表实现。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/你好赵伟/article/detail/726263
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号