摩登3娱乐怎么样?_23张图!万字详解“链表”,从小白到大佬

链表和数组是数据类型中两个重要又常用的基础数据类型。

数组是连续存储在内存中的数据结构,因此它的优势是可以通过下标迅速的找到元素的位置,而它的缺点则是在插入和删除元素时会导致大量元素的被迫移动,为了解决和平衡此问题于是就有了链表这种数据类型。

链表和数组可以形成有效的互补,这样我们就可以根据不同的业务场景选择对应的数据类型了。
那么,本文我们就来重点介绍学习一下链表,一是因为它非常重要,二是因为面试必考,先来看本文大纲:

看过某些抗日神剧我们都知道,某些秘密组织为了防止组织的成员被“一窝端”,通常会采用上下级单线联系的方式来保护其他成员,而这种“行为”则是链表的主要特征。

简介

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

链表是由数据域和指针域两部分组成的,它的组成结构如下:

复杂度分析

由于链表无需按顺序存储,因此链表在插入的时可以达到 O(1) 的复杂度,比顺序表快得多,但是查找一个节点或者访问特定编号的节点则需要 O(n) 的时间,而顺序表插入和查询的时间复杂度分别是 O(log n) 和 O(1)。

优缺点分析

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

分类

链表通常会分为以下三类:

  • 单向链表
  • 双向链表
  • 循环链表
    • 单循链表
    • 双循环链表

1.单向链表

链表中最简单的一种是单向链表,或叫单链表,它包含两个域,一个数据域和一个指针域,指针域用于指向下一个节点,而最后一个节点则指向一个空值,如下图所示:

单链表的遍历方向单一,只能从链头一直遍历到链尾。它的缺点是当要查询某一个节点的前一个节点时,只能再次从头进行遍历查询,因此效率比较低,而双向链表的出现恰好解决了这个问题。

接下来,我们用代码来实现一下单向链表的节点:

private static class Node<E{
    E item;
    Node  next;

    Node(E element, Node  next) {
         this.item = element;
         this.next = next;
    }
}

2.双向链表

双向链表也叫双面链表,它的每个节点由三部分组成:prev 指针指向前置节点,此节点的数据和 next 指针指向后置节点,如下图所示:

接下来,我们用代码来实现一下双向链表的节点:

private static class Node<E{
    E item;
    Node  next;
    Node  prev;

    Node(Node  prev, E element, Node  next) {
         this.item = element;
         this.next = next;
         this.prev = prev;
    }
}

3.循环链表

循环链表又分为单循环链表和双循环链表,也就是将单向链表或双向链表的首尾节点进行连接,这样就实现了单循环链表或双循环链表了,如下图所示:

Java中的链表

学习了链表的基础知识之后,我们来思考一个问题:Java 中的链表 LinkedList 是属于哪种类型的链表呢?单向链表还是双向链表?

要回答这个问题,首先我们要来看 JDK 中的源码,如下所示:

package java.util;

import java.util.function.Consumer;

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneablejava.io.Serializable
{
 // 链表大小
    transient int size = 0;

    // 链表头部
    transient Node  first;

     // 链表尾部
     transient Node  last;

     public LinkedList() {
    }

     public LinkedList(Collection  c) {
         this();
        addAll(c);
    }
 
     // 获取头部元素
     public E getFirst() {
         final Node  f = first;
         if (f ==  null)
             throw  new NoSuchElementException();
         return f.item;
    }

     // 获取尾部元素
     public E getLast() {
         final Node  l = last;
         if (l ==  null)
             throw  new NoSuchElementException();
         return l.item;
    }

     // 删除头部元素
     public E removeFirst() {
         final Node  f = first;
         if (f ==  null)
             throw  new NoSuchElementException();
         return unlinkFirst(f);
    }

     // 删除尾部元素
     public E removeLast() {
         final Node  l = last;
         if (l ==  null)
             throw  new NoSuchElementException();
         return unlinkLast(l);
    }

     // 添加头部元素
     public void addFirst(E e) {
        linkFirst(e);
    }
    
     // 添加头部元素的具体执行方法
     private void linkFirst(E e) {
         final Node  f = first;
         final Node  newNode =  new Node<>( null, e, f);
        first = newNode;
         if (f ==  null)
            last = newNode;
         else
            f.prev = newNode;
        size++;
        modCount++;
    }

     // 添加尾部元素
     public void addLast(E e) {
        linkLast(e);
    }
    
     // 添加尾部元素的具体方法
     void linkLast(E e) {
         final Node  l = last;
         final Node  newNode =  new Node<>(l, e,  null);
        last = newNode;
         if (l ==  null)
            first = newNode;
         else
            l.next = newNode;
        size++;
        modCount++;
    }

     // 查询链表个数
     public int size() {
         return size;
    }

     // 清空链表
     public void clear() {
         for (Node  x = first; x !=  null; ) {
            Node  next = x.next;
            x.item =  null;
            x.next =  null;
            x.prev =  null;
            x = next;
        }
        first = last =  null;
        size =  0;
        modCount++;
    }
  
     // 根据下标获取元素
     public E get(int index) {
        checkElementIndex(index);
         return node(index).item;
    }

     private  static  class Node<E{
        E item;
        Node  next;
        Node  prev;

        Node(Node  prev, E element, Node  next) {
             this.item = element;
             this.next = next;
             this.prev = prev;
        }
    }
     // 忽略其他方法......
}

从上述节点 Node  的定义可以看出:,因为它定义了两个指针 next 和 prev 分别用来指向自己的下一个和上一个节点。

链表常用方法

LinkedList 的设计还是很巧妙的,了解了它的实现代码之后,下面我们来看看它是如何使用的?或者说它的常用方法有哪些。

1.增加

接下来我们来演示一下增加方法的使用:

public class LinkedListTest {
    public static void main(String[] a) {
        LinkedList list = new LinkedList();
        list.add("Java");
        list.add("中文");
        list.add("社群");
        list.addFirst("头部添加"); // 添加元素到头部
        list.addLast("尾部添加");  // 添加元素到最后
        System.out.println(list);
    }
}

以上代码的执行结果为:

[头部添加, Java, 中文, 社群, 尾部添加]

出来以上的 3 个增加方法之外,LinkedList 还包含了其他的添加方法,如下所示:

  • add(int index, E element):向指定位置插入元素;
  • offer(E e):向链表末尾添加元素,返回是否成功;
  • offerFirst(E e):头部插入元素,返回是否成功;
  • offerLast(E e):尾部插入元素,返回是否成功。

add 和 offer 的区别

它们的区别主要体现在以下两点:

  • offer 方法属于 Deque 接口,add 方法属于 Collection 的接口;
  • 当队列添加失败时,如果使用 add 方法会报错,而 offer 方法会返回 false。

2.删除

删除功能的演示代码如下:

import java.util.LinkedList;

public class LinkedListTest {
    public static void main(String[] a) {
        LinkedList list = new LinkedList();
        list.offer("头部");
        list.offer("中间");
        list.offer("尾部");

        list.removeFirst(); // 删除头部元素
        list.removeLast();  // 删除尾部元素

        System.out.println(list);
    }
}

以上代码的执行结果为:

[中间]

除了以上删除方法之外,更多的删除方法如下所示:

  • clear():清空链表;
  • removeFirst():删除并返回第一个元素;
  • removeLast():删除并返回最后一个元素;
  • remove(Object o):删除某一元素,返回是否成功;
  • remove(int index):删除指定位置的元素;
  • poll():删除并返回第一个元素;
  • remove():删除并返回第一个元素。

3.修改

修改方法的演示代码如下:

import java.util.LinkedList;

public class LinkedListTest {
    public static void main(String[] a) {
        LinkedList list = new LinkedList();
        list.offer("Java");
        list.offer("MySQL");
        list.offer("DB");
        
        // 修改
        list.set(2"Oracle");

        System.out.println(list);
    }
}

以上代码的执行结果为:

[Java, MySQL, Oracle]

4.查询

查询方法的演示代码如下:

import java.util.LinkedList;

public class LinkedListTest {
    public static void main(String[] a) {
        LinkedList list = new LinkedList();
        list.offer("Java");
        list.offer("MySQL");
        list.offer("DB");

        // --- getXXX() 获取 ---
        // 获取最后一个
        System.out.println(list.getLast());
        // 获取首个
        System.out.println(list.getFirst());
        // 根据下标获取
        System.out.println(list.get(1));

        // peekXXX() 获取
        System.out.println("--- peek() ---");
        // 获取最后一个
        System.out.println(list.peekLast());
        // 获取首个
        System.out.println(list.peekFirst());
        // 根据首个
        System.out.println(list.peek());
    }
}

以上代码的执行结果为:

DB

Java

MySQL

— peek() —

DB

Java

Java

5.遍历

LinkedList 的遍历方法包含以下三种。

遍历方法一:

for (int size = linkedList.size(), i = 0; i < size; i++) {
    System.out.println(linkedList.get(i));
}

遍历方法二:

for (String str: linkedList) {
    System.out.println(str);
}

遍历方法三:

Iterator iter = linkedList.iterator();
while (iter.hasNext()) {
    System.out.println(iter.next());
}

链表应用:队列 & 栈

1.用链表实现栈

接下来我们用链表来实现一个先进先出的“队列”,实现代码如下:

LinkedList list = new LinkedList();
// 元素入列
list.add("Java");
list.add("中文");
list.add("社群");

while (!list.isEmpty()) {
    // 打印并移除队头元素
    System.out.println(list.poll());
}

以上程序的执行结果如下:

Java

中文

社群


2.用链表实现队列

然后我们用链表来实现一个后进先出的“栈”,实现代码如下:

LinkedList list = new LinkedList();
// 元素入栈
list.add("Java");
list.add("中文");
list.add("社群");

while (!list.isEmpty()) {
    // 打印并移除栈顶元素
    System.out.println(list.pollLast());
}

以上程序的执行结果如下:

社群

中文

Java


链表使用场景

链表作为一种基本的物理结构,常被用来构建许多其它的逻辑结构,如堆栈、队列都可以基于链表实现。

所谓的物理结构是指可以将数据存储在物理空间中,比如数组和链表都属于物理数据结构;而逻辑结构则是用于描述数据间的逻辑关系的,它可以由多种不同的物理结构来实现,比如队列和栈都属于逻辑结构。

链表常见笔试题

链表最常见的笔试题就是链表的反转了,之前的文章《链表反转的两种实现方法,后一种击败了100%的用户!》我们提供了 2 种链表反转的方法,而本文我们再来扩充一下,提供 3 种链表反转的方法。

实现方法 1:Stack

我们先用图解的方式来演示一下,使用栈实现链表反转的具体过程,如下图所示。


全部入栈:因为栈是先进后出的数据结构,因此它的执行过程如下图所示:最终的执行结果如下图所示:实现代码如下所示:

public ListNode reverseList(ListNode head) {
    if (head == nullreturn null;
    Stack  stack =  new Stack<>();
    stack.push(head);  // 存入第一个节点
     while (head.next !=  null) {
        stack.push(head.next);  // 存入其他节点
        head = head.next;  // 指针移动的下一位
    }
     // 反转链表
    ListNode listNode = stack.pop();  // 反转第一个元素
    ListNode lastNode = listNode;  // 临时节点,在下面的 while 中记录上一个节点
     while (!stack.isEmpty()) {
        ListNode item = stack.pop();  // 当前节点
        lastNode.next = item;
        lastNode = item;
    }
    lastNode.next =  null// 最后一个节点赋为null(不然会造成死循环)
     return listNode;
}
LeetCode 验证结果如下图所示:


可以看出使用栈的方式来实现链表的反转执行的效率比较低。

实现方法 2:递归

同样的,我们先用图解的方式来演示一下,此方法实现的具体过程,如下图所示。

实现代码如下所示:

public static ListNode reverseList(ListNode head) {
    if (head == null || head.next == nullreturn head;
    // 从下一个节点开始递归
    ListNode reverse = reverseList(head.next);
    head.next.next = head; // 设置下一个节点的 next 为当前节点
    head.next = null// 把当前节点的 next 赋值为 null,避免循环引用
    return reverse;
}

LeetCode 验证结果如下图所示:

可以看出这种实现方法在执行效率方面已经满足我们的需求了,性能还是很高的。

实现方法 3:循环

我们也可以通过循环的方式来实现链表反转,只是这种方法无需重复调用自身方法,只需要一个循环就搞定了,实现代码如下:

class Solution {
    public ListNode reverseList(ListNode head) {
        if (head == nullreturn null;
        // 最终排序的倒序链表
        ListNode prev = null;
        while (head != null) {
            // 循环的下个节点
            ListNode next = head.next;
            // 反转节点操作
            head.next = prev;
            
            prev = head;
            
            head = next;
        }
         prev;
    }
}

LeetCode 验证结果如下图所示:

从上述图片可以看出,使用此方法在时间复杂度和空间复杂度上都是目前的最优解,比之前的两种方法更加理想。

本文我们讲了链表的定义,它是由数据域和指针域两部分组成的。链表可分为:单向链表、双向链表和循环链表,其中循环链表又可以分为单循链表和双循环链表。通过 JDK 的源码可知,Java 中的 LinkedList 其实是双向链表,我们可以使用它来实现队列或者栈,最后我们讲了反转链表的 3 种实现方法,希望本文的内容对你有帮助。

长按订阅更多精彩▼

免责声明:本文内容由21ic获得授权后发布,版权归原作者所有,本平台仅提供信息存储服务。文章仅代表作者个人观点,不代表本平台立场,如有问题,请联系我们,谢谢!