数据结构 —— java 单链表、双端链表、双向链表、无序链表、有序链表

桃扇骨 2023-06-27 06:15 142阅读 0赞

0、节点

结点 是数据结构中的基础，是 构成复杂数据结构的基本组成单位。

  1. public class Node {
  2.     public long data;
  3.     public Node next;        
  5.     public Node(long value) {
  6.         this.data = value;
  7.     }    
  8. }

1、链表

链表：

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

在这里插入图片描述

上面是一个单链表的存储原理图，head为头节点，它不存放任何的数据，只是充当一个指向链表中真正存放数据的第一个节点的作用，而每个节点中都有一个 next 引用，指向下一个节点，就这样一节一节往下面记录，直到最后一个节点，其中的 next 指向 null 。

2、链表的种类和特点

普通链表（单链表）：
节点类保留下一节点的引用。链表类只保留头节点的引用，只能从头节点插入删除；

双端链表：
节点类保留下一节点的引用。链表类保留头节点、尾节点的引用，可以从尾节点插入，但只能从头节点删除；

双向链表：
节点类保留上一节点、下一节点的引用。链表类保留头节点、尾节点的引用，可以从尾节点插入删除；

如图所示：

在这里插入图片描述

以上统称为 无序链表。

无序链表 最大特点就是 在头部或尾部增加 新节点。

有序链表：

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

3、普通链表、单链表（单端链表）

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

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

查找图：

在这里插入图片描述

在表头增加节点：

在这里插入图片描述

删除节点：

在这里插入图片描述

  1. package test.node1;
  3. public class Node {
  5.     public long data;
  6.     public Node next;        
  8.     public Node(long value) {
  9.         this.data = value;
  10.     }
  12.     //显示方法
  13.     public void display() {
  14.         System.out.print(data + " ");
  15.     }
  17. }
  19. package test.node1;
  22. /**
  23.  * 单链表
  24.  */
  25. public class SingleEndLinkList {
  27.     /**头点节*/
  28.     private Node first;
  30.     public SingleEndLinkList() {
  31.         first = null;
  32.     }
  34.     /**
  35.      * 插入节点
  36.      * <pre>
  37.      * 在头结点之后插入
  38.      * </pre>
  39.      */
  40.     public void insertFirst(long value) {
  41.         Node aNode = new Node(value);
  42.         aNode.next = first;
  43.         first = aNode;
  44.     }
  46.     //删除头节点
  47.     public Node deleteFirst() {
  48.         Node tmp = first.next;
  49.         first = tmp;
  50.         return tmp;
  51.     }
  54.     //显示方法
  55.     public void display() {
  56.         Node now = first;
  57.         while(now != null) {
  58.             now.display();
  59.             now = now.next;
  60.         }
  61.         System.out.println();
  62.     }
  64.     //查找方法
  65.     public Node find(long value) {
  66.         Node now = first;
  67.         while(now.data != value) {
  68.             if(now.next == null) {
  69.                 return null;
  70.             }
  71.             now = now.next;
  72.         }
  73.         return now;
  74.     }
  76.     //根据数值删除
  77.     public Node delete(long value) {
  78.         Node now = first;
  79.         Node before = first;
  80.         while(now.data != value) {
  81.             if(now.next == null) {
  82.                 return null;
  83.             }
  84.             before = now;
  85.             now = now.next;
  86.         }
  88.         if(now == first) {
  89.             first = first.next;
  90.         }else {
  91.             before.next = now.next;
  92.         }
  93.         return now;
  94.     }
  95. }

4、双端链表

节点类保留下一节点的引用。链表类保留头节点、尾节点的引用，可以从尾节点插入，但只能从头节点删除。

  1. package test.node2;
  3. public class Node {
  4.     public long data;
  5.     public Node next;
  7.     public Node(long data) {
  8.         this.data = data;
  9.     }
  11.     // 显示方法
  12.     public void display() {
  13.         System.out.print(data + " ");
  14.     }
  15. }
  17. package test.node2;
  19. /**
  20.  * 双端链表
  21.  */
  22. public class DoubleEndLinkedList {
  23.     // 头节点
  24.     private Node first;
  25.     //尾节点
  26.     private Node last;
  28.     public DoubleEndLinkedList() {
  29.         first = null;
  30.         last = null;
  31.     }
  33.     //插入节点，在头结点之后插入
  34.     public void insertFirst(long value) {
  35.         Node aNode = new Node(value);
  36.         if (isEmpty()) {
  37.             last = aNode;
  38.         }
  39.         aNode.next = first;
  40.         first = aNode;
  41.     }
  43.     //尾节点插入
  44.     public void insertLast(long value) {
  45.         Node aNode = new Node(value);
  46.         if (isEmpty()) {
  47.             first = aNode;
  48.         }
  49.         else {
  50.             last.next = aNode;
  51.         }
  52.         last = aNode;
  53.     }
  55.     //删除头节点
  56.     public Node deleteFirst() {
  57.         Node tmp = first;
  58.         if (first.next == null) {
  59.             last = null;
  60.         }
  61.         first = tmp.next;
  62.         return tmp;
  63.     }
  65.     //显示方法
  66.     public void display() {
  67.         Node now = first;
  68.         while(now != null) {
  69.             now.display();
  70.             now = now.next;
  71.         }
  72.         System.out.println();
  73.     }
  75.     //查找方法
  76.     public Node find(long value) {
  77.         Node now = first;
  78.         while(now.data != value) {
  79.             if(now.next == null) {
  80.                 return null;
  81.             }
  82.             now = now.next;
  83.         }
  84.         return now;
  85.     }
  87.     //根据数值删除
  88.     public Node delete(long value) {
  89.         Node now = first;
  90.         Node before = first;
  91.         while(now.data != value) {
  92.             if(now.next == null) {
  93.                 return null;
  94.             }
  95.             before = now;
  96.             now = now.next;
  97.         }
  99.         if(now == first) {
  100.             first = first.next;
  101.         }
  102.         else {
  103.             before.next = now.next;
  104.         }
  105.         return now;
  106.     }
  108.     //判断是否为空
  109.     public boolean isEmpty() {
  110.         return first == null;
  111.     }
  112. }

为什么不能删除尾节点？ 删除尾节点时必须知道尾节点的上个节点，但是 双端链表 只能知道下个节点，不知道上个节点，故无法删除。

5、双向链表

节点类保留上一节点、下一节点的引用。链表类保留头节点、尾节点的引用，可以从尾节点插入删除。

在这里插入图片描述

  1. package test.node3;
  3. public class Node {
  4.     // 数据域
  5.     public long data;
  6.     //指针域（保存下一个节点的引用）
  7.     public Node next;
  8.     //指针域（保存前一个节点的引用）
  9.     public Node previous;
  11.     public Node(long value) {
  12.         this.data = value;
  13.     }
  15.     /**
  16.      * 显示方法
  17.      */
  18.     public void display() {
  19.         System.out.print(data + " ");
  20.     }
  21. }
  23. package test.node3;
  26. /**
  27.  * 双向链表
  28.  */
  29. public class DoubleByLinkedList {
  30.     // 头结点
  31.     private Node first;
  32.     //尾结点
  33.     private Node last;
  35.     public DoubleByLinkedList() {
  36.         first = null;
  37.         last = null;
  38.     }
  40.     /**
  41.      * 插入一个节点，在头结点后进行插入
  42.      *
  43.      * @param value
  44.      */
  45.     public void insertFirst(long value) {
  46.         Node node = new Node(value);
  47.         if (isEmpty()) {
  48.             last = node;
  49.         } else {
  50.             first.previous = node;
  51.         }
  52.         node.next = first;
  53.         first = node;
  54.     }
  56.     public void insertLast(long value) {
  57.         Node node = new Node(value);
  58.         if (isEmpty()) {
  59.             first = node;
  60.         } else {
  61.             last.next = node;
  62.             node.previous = last;
  63.         }
  64.         last = node;
  65.     }
  67.     /**
  68.      * 删除一个结点,在头结点后进行删除
  69.      *
  70.      * @return
  71.      */
  72.     public Node deleteFirst() {
  73.         Node tmp = first;
  74.         if (first.next == null) {
  75.             last = null;
  76.         } else {
  77.             first.next.previous = null;
  78.         }
  79.         first = tmp.next;
  80.         return tmp;
  81.     }
  83.     /**
  84.      * 删除一个结点,从尾部进行删除
  85.      *
  86.      * @return
  87.      */
  88.     public Node deleteLast() {
  89.         if (first.next == null) {
  90.             first = null;
  91.         } else {
  92.             last.previous.next = null;
  93.         }
  94.         last = last.previous;
  95.         return last;
  96.     }
  98.     /**
  99.      * 显示方法
  100.      */
  101.     public void display() {
  102.         Node current = first;
  103.         while (current != null) {
  104.             current.display();
  105.             current = current.next;
  106.         }
  107.     }
  109.     /**
  110.      * 查找方法
  111.      *
  112.      * @param value
  113.      * @return
  114.      */
  115.     public Node find(long value) {
  116.         Node current = first;
  117.         while (current.data != value) {
  118.             if (current.next == null) {
  119.                 return null;
  120.             }
  121.             current = current.next;
  122.         }
  123.         return current;
  124.     }
  126.     public Node delete(long value) {
  127.         Node current = first;
  128.         while (current.data != value) {
  129.             if (current.next == null) {
  130.                 return null;
  131.             }
  132.             current = current.next;
  133.         }
  134.         if (current == first) {
  135.             first = first.next;
  136.         } else {
  137.             current.previous.next = current.next;
  138.         }
  139.         return current;
  140.     }
  142.     /**
  143.      * 判断是否为空
  144.      *
  145.      * @return
  146.      */
  147.     public boolean isEmpty() {
  148.         return first == null;
  149.     }
  150. }

6、有序列表

前面的链表实现插入数据都是无序的，在有些应用中需要链表中的数据有序，这称为有序链表。

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

有序列表算法题：

将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例：

  1. 输入：1->2->4, 1->3->4
  2. 输出：1->1->2->3->4->4

https://leetcode-cn.com/problems/merge-two-sorted-lists/

想法:递归

我们可以如下递归地定义在两个链表里的 merge 操作（忽略边界情况，比如空链表等）：

  1.                                                      ![20200104170853154.png][]

也就是说，两个链表头部较小的一个与剩下元素的 merge 操作结果合并。

算法
我们直接将以上递归过程建模，首先考虑边界情况。
特殊的，如果 l1 或者 l2 一开始就是 null ，那么没有任何操作需要合并，所以我们只需要返回非空链表。否则，我们要判断 l1 和 l2 哪一个的头元素更小，然后递归地决定下一个添加到结果里的值。如果两个链表都是空的，那么过程终止，所以递归过程最终一定会终止。

​ 

  1. class Solution {
  2.     public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
  3.         if (l1 == null) {
  4.             return l2;
  5.         }
  6.         else if (l2 == null) {
  7.             return l1;
  8.         }
  9.         else if (l1.val < l2.val) {
  10.             l1.next = mergeTwoLists(l1.next, l2);
  11.             return l1;
  12.         }
  13.         else {
  14.             l2.next = mergeTwoLists(l1, l2.next);
  15.             return l2;
  16.         }
  18.     }
  19. }

复杂度分析

  • 时间复杂度：O(n + m) 因为每次调用递归都会去掉 l1 或者 l2 的头元素（直到至少有一个链表为空），函数 mergeTwoList 中只会遍历每个元素一次。所以，时间复杂度与合并后的链表长度为线性关系。
  • 空间复杂度：O(n + m)。调用 mergeTwoLists 退出时 l1 和 l2 中每个元素都一定已经被遍历过了，所以 n + m个栈帧会消耗 O(n + m) 的空间。

发表评论

表情：
评论列表 （有 0 条评论，142人围观）

还没有评论，来说两句吧...

相关阅读