【UCB CS 61B SP24】Lecture 5 - Lists 3: DLLists and Arrays学习笔记

柃歌2025-02-22 10:31

本文内容为构建双向循环链表、使用 Java 的泛型将其优化为通用类型的链表以及数组的基本语法介绍。

1. 双向链表

回顾上一节课写的代码，当执行 addLast() 与 getLast() 方法时需要遍历链表，效率不高，因此可以添加一个指向链表末尾的索引，这样 addLast() 与 getLast() 方法的时间复杂度就为 O ( 1 ) O(1) O(1)。

但是我们再考虑一下 removeLast() 方法，如下图所示：

即使我们有了指向链表末尾的指针 last，但是当我们要移除最后一个节点时，需要的不是最后一个节点"50"的信息，而是倒数第二个节点"9"，我们需要将"9"的 next 置为 null，并将 last 指向"9"：

那么我们想要定位到这个节点"9"的唯一方法还是需要从头遍历一遍链表，同理如果你想将 last 指向链表的倒数第二个节点，认为这样就能快速定位，那么就会有新的问题：当节点"50"被删除后，如何更新 last 指向节点"3"？显然又需要从头遍历链表。

有什么办法能快速定位到这个节点呢？我们可以让每个节点不仅指向后一个节点，还能指向前一个节点，这就是双向链表（Doubly Linked List）：

但是此时又会出现棘手的问题，那就是 last 指针在链表为空时会指向哨兵节点，在链表不为空时又会指向最后一个实值节点：

有什么办法能统一起来呢？能想到的第一个方案就是同样给尾部设定一个哨兵节点，就和之前的表头哨兵节点类似：

此外还有更完美的解决方案，那就是构建循环链表，这样只需要一个哨兵节点，无需指向链表末尾的指针，当链表为空时，哨兵的前一个节点和后一个节点都是指向自己，当链表不为空时哨兵的前一个结点为末尾节点，末尾节点的后一个节点为哨兵：

实现代码如下：

java 复制代码 
package CS61B.Lecture5;

public class DLList {
    private static class IntNode {
        public int val;
        public IntNode next;
        public IntNode prev;

        public IntNode(int val, IntNode next, IntNode prev) {
            this.val = val;
            this.next = next;
            this.prev = prev;
        }
    }

    private IntNode sentinel = new IntNode(0, null, null);
    private int size;

    public DLList() {
        this.sentinel.next = this.sentinel.prev = sentinel;
        this.size = 0;
    }

    public DLList(int val) {
        IntNode p = new IntNode(val, this.sentinel, this.sentinel);
        this.sentinel.next = this.sentinel.prev = p;
        this.size = 1;
    }

    public int size() {
        return this.size;
    }

    public int getFirst() {
        return this.sentinel.next.val;
    }

    public void addFirst(int val) {
        IntNode p = new IntNode(val, this.sentinel.next, this.sentinel);
        this.sentinel.next.prev = p;
        this.sentinel.next = p;
        this.size++;
    }

    public void removeFirst() {
        if (this.size == 0) return;
        this.sentinel.next.next.prev = this.sentinel;
        this.sentinel.next = this.sentinel.next.next;
        this.size--;
    }

    public int getLast() {
        return this.sentinel.prev.val;
    }

    public void addLast(int val) {
        IntNode p = new IntNode(val, this.sentinel, this.sentinel.prev);
        this.sentinel.prev.next = p;
        this.sentinel.prev = p;
        this.size++;
    }

    public void removeLast() {
        if (this.size == 0) return;
        this.sentinel.prev.prev.next = this.sentinel;
        this.sentinel.prev = this.sentinel.prev.prev;
        this.size--;
    }

    @Override
    public String toString() {
        StringBuilder res = new StringBuilder("DLList: [");

        IntNode p = this.sentinel;
        while (p.next != this.sentinel) {
            res.append(p.next.val);
            p = p.next;
            if (p.next != this.sentinel) res.append(", ");
        }

        res.append("]");
        return res.toString();
    }

    public static void main(String[] args) {
        DLList L = new DLList();
        L.addFirst(5);
        L.addFirst(10);
        System.out.println(L.getFirst());  // 10
        System.out.println(L);  // DLList: [10, 5]

        L.removeFirst();
        System.out.println(L);  // DLList: [5]
        System.out.println(L.size());  // 1

        L.addLast(20);
        System.out.println(L.getLast());  // 20
        System.out.println(L);  // DLList: [5, 20]
        L.removeFirst();
        L.removeLast();
        System.out.println(L);  // DLList: []
    }
}

2. 通用类型双向链表

现在我们的链表只能存放整数，如果想存放其他数据类型例如字符串，那么需要拷贝一份代码将其中的 int 修改为 String，显然这样很冗余。

如果想实现一个通用类型的数据结构，就需要引入 Java 的泛型 概念，我们可以将 DLList 定义为泛型类，这样能够编写出类型安全的、可重用的代码，同时避免类型转换的繁琐操作和潜在的运行时错误。

通过在 <> 中添加类型参数用来表示泛型，类型参数通常使用单个大写字母表示，常见的命名约定如下：

  • T：Type（类型）
  • E：Element（元素）
  • K：Key（键）
  • V：Value（值）
  • N：Number（数字）

需要注意：

  • 泛型类型参数必须是引用类型 ，不能是基本数据类型（如 int、double 等）。如果需要使用基本数据类型，可以使用其对应的包装类（如 Integer、Double）。
  • 泛型类型参数不能是 final 修饰的类，因为它们不能被继承。
java 复制代码 
package CS61B.Lecture5;

public class DLList<T> {
    private class IntNode {
        public T val;
        public IntNode next;
        public IntNode prev;

        public IntNode(T val, IntNode next, IntNode prev) {
            this.val = val;
            this.next = next;
            this.prev = prev;
        }
    }

    private IntNode sentinel = new IntNode(null, null, null);
    private int size;

    public DLList() {
        this.sentinel.next = this.sentinel.prev = sentinel;
        this.size = 0;
    }

    public DLList(T val) {
        IntNode p = new IntNode(val, this.sentinel, this.sentinel);
        this.sentinel.next = this.sentinel.prev = p;
        this.size = 1;
    }

    public int size() {
        return this.size;
    }

    public T getFirst() {
        return this.sentinel.next.val;
    }

    public void addFirst(T val) {
        IntNode p = new IntNode(val, this.sentinel.next, this.sentinel);
        this.sentinel.next.prev = p;
        this.sentinel.next = p;
        this.size++;
    }

    public void removeFirst() {
        if (this.size == 0) return;
        this.sentinel.next.next.prev = this.sentinel;
        this.sentinel.next = this.sentinel.next.next;
        this.size--;
    }

    public T getLast() {
        return this.sentinel.prev.val;
    }

    public void addLast(T val) {
        IntNode p = new IntNode(val, this.sentinel, this.sentinel.prev);
        this.sentinel.prev.next = p;
        this.sentinel.prev = p;
        this.size++;
    }

    public void removeLast() {
        if (this.size == 0) return;
        this.sentinel.prev.prev.next = this.sentinel;
        this.sentinel.prev = this.sentinel.prev.prev;
        this.size--;
    }

    @Override
    public String toString() {
        StringBuilder res = new StringBuilder("DLList: [");

        IntNode p = this.sentinel;
        while (p.next != this.sentinel) {
            res.append(p.next.val);
            p = p.next;
            if (p.next != this.sentinel) res.append(", ");
        }

        res.append("]");
        return res.toString();
    }

    public static void main(String[] args) {
        DLList<String> L = new DLList<>();  // new DLList<String>()中的String可以省略，Java会自动判断
        L.addFirst("World");
        L.addFirst("Hello");
        System.out.println(L.getFirst());  // Hello
        System.out.println(L);  // DLList: [Hello, World]

        L.removeFirst();
        System.out.println(L);  // DLList: [World]
        System.out.println(L.size());  // 1

        L.addLast("Algorithm");
        System.out.println(L.getLast());  // Algorithm
        System.out.println(L);  // DLList: [World, Algorithm]
        L.removeFirst();
        L.removeLast();
        System.out.println(L);  // DLList: []
    }
}

注意 IntNode 类需要改为非静态的，泛型类型变量不能直接在静态方法或静态上下文中使用，因为泛型类型变量是与类的实例相关联的，而静态上下文与类的实例无关。

3. 数组

数组的大小在创建时必须指定，并且一旦创建，其大小不能改变。如果需要更大的数组，必须创建一个新的数组并复制数据。但数组通过索引直接访问元素，时间复杂度为 O ( 1 ) O(1) O(1)，适合频繁读取的场景。

3.1 数组基本语法

建议每次创建数组时都使用关键字 new，因为数组也是一个 Object，在声明了数组中的变量后也可以省略 new 关键字：

java 复制代码 
package CS61B.Lecture5;

import java.util.Arrays;

public class ArraySyntax {
    public static void main(String[] args) {
        int[] a = new int[3];
        int[] b = new int[]{1, 2, 3};
        int[] c = {1, 2, 3};

        Arrays.stream(a).forEach(x -> System.out.print(x + " "));  // 0 0 0
        System.out.println();
        Arrays.stream(b).forEach(x -> System.out.print(x + " "));  // 1 2 3
        System.out.println();
        Arrays.stream(c).forEach(x -> System.out.print(x + " "));  // 1 2 3
    }
}

现在再来看下面这段代码：

java 复制代码 
package CS61B.Lecture5;

public class ArrayBasics {
    public static void main(String[] args) {
        int[] a = null;
        int[] b, c;

        b = new int[]{1, 2, 3, 4, 5};
        c = b;
        b = new int[]{-1, 2, 5, 4, 99};
        c = new int[3];
        a = new int[0];
        int b_length = b.length;

        String[] s = new String[6];
        s[4] = "ketchup";
        s[b[3] - b[1]] = "muffins";

        int[] x = {9, 10, 11};
        System.arraycopy(x, 0, b, 3, 2);
    }
}

首先声明了一个名为 a 的数组引用，但是并没有调用 new 关键字，此时 Java 并没有创建空间，只是创建了用于存放数组引用的整数空间。同样 b 和 c 只是声明了一个整数数组的引用，未存放实际的数组。

之后通过初始化了一个长度为5的数组，new 关键字使得 Java 在内存中挖掘5个连续的位置用来存放这个数组的内容，并将其地址返回给变量 b。当执行 c = b 时是将数组的引用赋值给 c，因此实际上这时候 b 和 c 指向了同一个数组，如下图所示：

接下来执行的 b = new int[]{-1, 2, 5, 4, 99}; 语句使用 new 关键字重新创建了一个数组，这时候新数组返回了一个新的内存地址，此时 b 和 c 便指向了不同数组：

再看下一步的 c = new int[3]; 改变了 c 使其指向一个新的长度为3的数组：

此时最早创建的数组 {1, 2, 3, 4, 5} 消失了，因为已经没有任何引用能找到这个数组的地址了，垃圾收集器会将其清理掉永远无法再访问这个数组。

再看下一行创建了一个长度为0的数组，虽然这样几乎没什么意义，但是只是想说明一下可以这么做：

b.length 能够获取 b 所指向的数组的长度，但是从之前的图上我们没看到任何其他变量能够记录数组的长度，因此事实证明数组有一个隐秘的实例变量记录长度，通过 Java Visualizer 无法查看这个值在哪。

String 是引用数据类型，因此如果创建了数组并不能将字符串的值直接存放在数组的那个位置上，而是在其他某个位置创建一个字符串对象后再将其引用存放在数组的某个位置上。

最后一行的 System.arraycopy() 方法是将 x 数组从0开始索引取2个值（也就是 [9, 10]）复制到 b 数组从3开始索引的对应位置上：

3.2 二维数组

我们创建一个4行的二维数组：

java 复制代码 
package CS61B.Lecture5;

public class Array2D {
    public static void main(String[] args) {
        int[][] a = new int[4][];
        a[0] = new int[]{1};
        a[1] = new int[]{1, 1};
        a[2] = new int[]{1, 2, 1};
        a[3] = new int[]{1, 3, 3, 1};
    }
}

此时我们实际上是在内存中创建了5个数组，a 指向了一个长度为4的数组，这个数组中的每个位置又存放了一个指向某个一维数组的引用，如下图所示：

相关推荐
不会Hello World的小苗4 分钟前
Java——链表（LinkedList）
java·开发语言·链表
陈无左耳、15 分钟前
HarmonyOS学习第3天: 环境搭建开启鸿蒙开发新世界
学习·华为·harmonyos
curemoon32 分钟前
理解都远正态分布中指数项的精度矩阵（协方差逆矩阵）
人工智能·算法·矩阵
Allen Bright37 分钟前
【Java基础-46.3】Java泛型通配符详解：解锁类型安全的灵活编程
java·开发语言
柃歌41 分钟前
【UCB CS 61B SP24】Lecture 7 - Lists 4: Arrays and Lists学习笔记
java·数据结构·笔记·学习·算法
JANGHIGH44 分钟前
c++ std::list使用笔记
c++·笔记·list
柃歌1 小时前
【UCB CS 61B SP24】Lecture 4 - Lists 2: SLLists学习笔记
java·数据结构·笔记·学习·算法
干炒 牛河1 小时前
数据结构：双链表list
数据结构·list
是姜姜啊！1 小时前
redis的应用,缓存,分布式锁
java·redis·spring
梨落秋溪、1 小时前
输入框元素覆盖冲突
java·服务器·前端
热门推荐
01太炸裂了！清华大学deepseek从入门到精通使用手册又出第三版了，《普通人如何抓住DeepSeek红利》（无套路，直接下载）02如何在WPS和Word/Excel中直接使用DeepSeek功能03DeepSeek本地部署详细指南04DeepSeek各版本说明与优缺点分析05本地部署DeepSeek教程（Mac版本）06DeepSeek r1本地安装全指南07本地化部署AI知识库：基于Ollama+DeepSeek+AnythingLLM保姆级教程08DeepSeek R1本地化部署 Ollama + Chatbox 打造最强 AI 工具09在Windows下安装Ollama并体验DeepSeek r1大模型10Page Assist - 本地Deepseek模型 Web UI 的安装和使用