【数据结构系列】链表

欢迎来到我的博客,很高兴能够在这里和您见面!希望您在这里可以感受到一份轻松愉快的氛围,不仅可以获得有趣的内容和知识,也可以畅所欲言、分享您的想法和见解。

  • 推荐:kuan 的首页,持续学习,不断总结,共同进步,活到老学到老
  • 导航
    • 檀越剑指大厂系列:全面总结 java 核心技术点,如集合,jvm,并发编程 redis,kafka,Spring,微服务,Netty 等
    • 常用开发工具系列:罗列常用的开发工具,如 IDEA,Mac,Alfred,electerm,Git,typora,apifox 等
    • 数据库系列:详细总结了常用数据库 mysql 技术点,以及工作中遇到的 mysql 问题等
    • 懒人运维系列:总结好用的命令,解放双手不香吗?能用一个命令完成绝不用两个操作
    • 数据结构与算法系列:总结数据结构和算法,不同类型针对性训练,提升编程思维,剑指大厂

非常期待和您一起在这个小小的网络世界里共同探索、学习和成长。 ✨✨ 欢迎订阅本专栏 ✨✨

博客目录

    • 一.认识链表
      • 1.链表定义与分类
      • 2.哨兵节点
      • 3.查询性能
      • 4.插入和删除性能
    • 二.单向链表
      • 1.定义
      • 2.头部添加
      • 3.while 遍历
      • 4.for 遍历
      • 5.迭代器遍历
      • 6.递归遍历
      • 7.尾部添加
      • 8.尾部添加多个
      • 9.根据索引获取
      • 10.插入
      • 11.删除
    • 三.单向链表(带哨兵)
      • 1.带哨兵单向链表
      • 2.获取索引节点
      • 3.插入删除节点
    • 四.双向链表(带哨兵)
    • 五.环形链表(带哨兵)
    • 六.解题模版
      • 1.反转链表再正向遍历
      • 2.递归遍历
    • 七.链表题目
      • 1.两数相加
      • 2.两数相加 II
      • 3.合并两个有序链表
      • 4.删除排序链表中的重复元素
      • 5.环形链表
      • 6.相交链表
      • 7.移除链表元素
      • 8.反转链表
      • 9.回文链表
      • 10.链表的中间结点

一.认识链表

1.链表定义与分类

在计算机科学中,链表是数据元素的线性集合,其每个元素都指向下一个元素,元素存储上并不连续

可以分类为.

  • 单向链表,每个元素只知道其下一个元素是谁

image-20221110083407176

  • 双向链表,每个元素知道其上一个元素和下一个元素

image-20221110083427372

  • 循环链表,通常的链表尾节点 tail 指向的都是 null,而循环链表的 tail 指向的是头节点 head

image-20221110083538273

2.哨兵节点

链表内还有一种特殊的节点称为哨兵(Sentinel)节点,也叫做哑元( Dummy)节点,它不存储数据,通常用作头尾,用来简化边界判断,如下图所示

image-20221110084611550

3.查询性能

随机访问性能

根据 index 查找,时间复杂度 O(n)

4.插入和删除性能

插入或删除性能

  • 起始位置:O(1)
  • 结束位置:如果已知 tail 尾节点是 O(1),不知道 tail 尾节点是 O(n)
  • 中间位置:根据 index 查找时间 + O(1)

二.单向链表

1.定义

根据单向链表的定义,首先定义一个存储 value 和 next 指针的类 Node,和一个描述头部节点的引用

public class SinglyLinkedList {

    private Node head; // 头部节点

    private static class Node { // 节点类
        int value;
        Node next;

        public Node(int value, Node next) {
            this.value = value;
            this.next = next;
        }
    }
}
  • Node 定义为内部类,是为了对外隐藏实现细节,没必要让类的使用者关心 Node 结构
  • 定义为 static 内部类,是因为 Node 不需要与 SinglyLinkedList 实例相关,多个 SinglyLinkedList 实例能共用 Node 类定义

2.头部添加

public class SinglyLinkedList {
    // ...
    public void addFirst(int value) {
				this.head = new Node(value, this.head);
    }
}
  • 如果 this.head == null,新增节点指向 null,并作为新的 this.head
  • 如果 this.head != null,新增节点指向原来的 this.head,并作为新的 this.head
    • 注意赋值操作执行顺序是从右到左

3.while 遍历

public class SinglyLinkedList {
    // ...
    public void loop() {
        Node curr = this.head;
        while (curr != null) {
            // 做一些事
            curr = curr.next;
        }
    }
}

4.for 遍历

public class SinglyLinkedList {
    // ...
    public void loop() {
        for (Node curr = this.head; curr != null; curr = curr.next) {
            // 做一些事
        }
    }
}
  • 以上两种遍历都可以把要做的事以 Consumer 函数的方式传递进来
    • Consumer 的规则是一个参数无返回值,因此像 System.out::println 方法等都是 Consumer
    • 调用 Consumer 时,将当前节点 curr.value 作为参数传递给它
//使用Consumer传参
public void loop4(Consumer<Integer> consumer) {
    Node p = head;
    while (p != null) {
        consumer.accept(p.value);
        p = p.next;
    }
}
//测试
@Test
@DisplayName("测试 consumer while遍历 loop4")
public void test5() {
    SinglyLinkedList list = new SinglyLinkedList();
    list.addFirst(1);
    list.addFirst(2);
    list.addFirst(3);
    list.addFirst(4);
    Consumer<Integer> consumer = integer -> System.out.println(integer);
    list.loop4(consumer);
}

5.迭代器遍历

public class SinglyLinkedList implements Iterable<Integer> {
    // ...
    private class NodeIterator implements Iterator<Integer> {
        Node curr = head;

        public boolean hasNext() {
            return curr != null;
        }

        public Integer next() {
            int value = curr.value;
            curr = curr.next;
            return value;
        }
    }

    public Iterator<Integer> iterator() {
        return new NodeIterator();
    }
}
  • hasNext 用来判断是否还有必要调用 next
  • next 做两件事
    • 返回当前节点的 value
    • 指向下一个节点
  • NodeIterator 要定义为非 static 内部类,是因为它与 SinglyLinkedList 实例相关,是对某个 SinglyLinkedList 实例的迭代

6.递归遍历

public class SinglyLinkedList implements Iterable<Integer> {
    // ...
    public void loop() {
        recursion(this.head);
    }

    private void recursion(Node curr) {
        if (curr == null) {
            return;
        }
        //前面做些事
        recursion(curr.next);
        //后面做些事
    }
}

7.尾部添加

public class SinglyLinkedList {
    // ...
    private Node findLast() {
        if (this.head == null) {
            return null;
        }
        Node curr;
        for (curr = this.head; curr.next != null; ) {
            curr = curr.next;
        }
        return curr;
    }

    public void addLast(int value) {
        Node last = findLast();
        if (last == null) {
            addFirst(value);
            return;
        }
        last.next = new Node(value, null);
    }
}
  • 注意,找最后一个节点,终止条件是 curr.next == null
  • 分成两个方法是为了代码清晰,而且 findLast() 之后还能复用

8.尾部添加多个

public class SinglyLinkedList {
    // ...
	public void addLast(int first, int... rest) {

        Node sublist = new Node(first, null);
        Node curr = sublist;
        for (int value : rest) {
            curr.next = new Node(value, null);
            curr = curr.next;
        }

        Node last = findLast();
        if (last == null) {
            this.head = sublist;
            return;
        }
        last.next = sublist;
    }
}
  • 先串成一串 sublist
  • 再作为一个整体添加

9.根据索引获取

public class SinglyLinkedList {
    // ...
	private Node findNode(int index) {
        int i = 0;
        for (Node curr = this.head; curr != null; curr = curr.next, i++) {
            if (index == i) {
                return curr;
            }
        }
        return null;
    }

    private IllegalArgumentException illegalIndex(int index) {
        return new IllegalArgumentException(String.format("index [%d] 不合法%n", index));
    }

    public int get(int index) {
        Node node = findNode(index);
        if (node != null) {
            return node.value;
        }
        throw illegalIndex(index);
    }
}
  • 同样,分方法可以实现复用

10.插入

public class SinglyLinkedList {
    // ...
	public void insert(int index, int value) {
        if (index == 0) {
            addFirst(value);
            return;
        }
        Node prev = findNode(index - 1); // 找到上一个节点
        if (prev == null) { // 找不到
            throw illegalIndex(index);
        }
        prev.next = new Node(value, prev.next);
    }
}
  • 插入包括下面的删除,都必须找到上一个节点

11.删除

public class SinglyLinkedList {
    // ...
	public void remove(int index) {
        if (index == 0) {
            if (this.head != null) {
                this.head = this.head.next;
                return;
            } else {
                throw illegalIndex(index);
            }
        }
        Node prev = findNode(index - 1);
        Node curr;
        if (prev != null && (curr = prev.next) != null) {
            prev.next = curr.next;
        } else {
            throw illegalIndex(index);
        }
    }
}
  • 第一个 if 块对应着 removeFirst 情况
  • 最后一个 if 块对应着至少得两个节点的情况
    • 不仅仅判断上一个节点非空,还要保证当前节点非空

三.单向链表(带哨兵)

1.带哨兵单向链表

观察之前单向链表的实现,发现每个方法内几乎都有判断是不是 head 这样的代码,能不能简化呢?

用一个不参与数据存储的特殊 Node 作为哨兵,它一般被称为哨兵或哑元,拥有哨兵节点的链表称为带头链表

public class SinglyLinkedListSentinel {
    // ...
    private Node head = new Node(Integer.MIN_VALUE, null);
}
  • 具体存什么值无所谓,因为不会用到它的值

2.获取索引节点

加入哨兵节点后,代码会变得比较简单,先看几个工具方法

public class SinglyLinkedListSentinel {
    // ...

    // 根据索引获取节点
    private Node findNode(int index) {
        int i = -1;
        for (Node curr = this.head; curr != null; curr = curr.next, i++) {
            if (i == index) {
                return curr;
            }
        }
        return null;
    }

    // 获取最后一个节点
    private Node findLast() {
        Node curr;
        for (curr = this.head; curr.next != null; ) {
            curr = curr.next;
        }
        return curr;
    }
}
  • findNode 与之前类似,只是 i 初始值设置为 -1 对应哨兵,实际传入的 index 也是 [-1, \infty)
  • findLast 绝不会返回 null 了,就算没有其它节点,也会返回哨兵作为最后一个节点

3.插入删除节点

这样,代码简化为

public class SinglyLinkedListSentinel {
    // ...

    public void addLast(int value) {
        Node last = findLast();
        /*
        改动前
        if (last == null) {
            this.head = new Node(value, null);
            return;
        }
        */
        last.next = new Node(value, null);
    }

    public void insert(int index, int value) {
        /*
        改动前
        if (index == 0) {
            this.head = new Node(value, this.head);
            return;
        }
        */
        // index 传入 0 时,返回的是哨兵
        Node prev = findNode(index - 1);
        if (prev != null) {
            prev.next = new Node(value, prev.next);
        } else {
            throw illegalIndex(index);
        }
    }

    public void remove(int index) {
        /*
        改动前
        if (index == 0) {
            if (this.head != null) {
                this.head = this.head.next;
                return;
            } else {
                throw illegalIndex(index);
            }
        }
        */
        // index 传入 0 时,返回的是哨兵
        Node prev = findNode(index - 1);
        Node curr;
        if (prev != null && (curr = prev.next) != null) {
            prev.next = curr.next;
        } else {
            throw illegalIndex(index);
        }
    }

    public void addFirst(int value) {
        /*
        改动前
        this.head = new Node(value, this.head);
        */
		this.head.next = new Node(value, this.head.next);
        // 也可以视为 insert 的特例, 即 insert(0, value);
    }
}
  • 对于删除,前面说了【最后一个 if 块对应着至少得两个节点的情况】,现在有了哨兵,就凑足了两个节点

四.双向链表(带哨兵)

public class DoublyLinkedListSentinel implements Iterable<Integer> {

    private final Node head;
    private final Node tail;

    public DoublyLinkedListSentinel() {
        head = new Node(null, 666, null);
        tail = new Node(null, 888, null);
        head.next = tail;
        tail.prev = head;
    }

    private Node findNode(int index) {
        int i = -1;
        for (Node p = head; p != tail; p = p.next, i++) {
            if (i == index) {
                return p;
            }
        }
        return null;
    }

    public void addFirst(int value) {
        insert(0, value);
    }

    public void removeFirst() {
        remove(0);
    }

    public void addLast(int value) {
        Node prev = tail.prev;
        Node added = new Node(prev, value, tail);
        prev.next = added;
        tail.prev = added;
    }

    public void removeLast() {
        Node removed = tail.prev;
        if (removed == head) {
            throw illegalIndex(0);
        }
        Node prev = removed.prev;
        prev.next = tail;
        tail.prev = prev;
    }

    public void insert(int index, int value) {
        Node prev = findNode(index - 1);
        if (prev == null) {
            throw illegalIndex(index);
        }
        Node next = prev.next;
        Node inserted = new Node(prev, value, next);
        prev.next = inserted;
        next.prev = inserted;
    }

    public void remove(int index) {
        Node prev = findNode(index - 1);
        if (prev == null) {
            throw illegalIndex(index);
        }
        Node removed = prev.next;
        if (removed == tail) {
            throw illegalIndex(index);
        }
        Node next = removed.next;
        prev.next = next;
        next.prev = prev;
    }

    private IllegalArgumentException illegalIndex(int index) {
        return new IllegalArgumentException(
                String.format("index [%d] 不合法%n", index));
    }

    @Override
    public Iterator<Integer> iterator() {
        return new Iterator<Integer>() {
            Node p = head.next;

            @Override
            public boolean hasNext() {
                return p != tail;
            }

            @Override
            public Integer next() {
                int value = p.value;
                p = p.next;
                return value;
            }
        };
    }

    static class Node {
        Node prev;
        int value;
        Node next;

        public Node(Node prev, int value, Node next) {
            this.prev = prev;
            this.value = value;
            this.next = next;
        }
    }
}

五.环形链表(带哨兵)

双向环形链表带哨兵,这时哨兵既作为头,也作为尾

【数据结构系列】链表_第1张图片

【数据结构系列】链表_第2张图片

【数据结构系列】链表_第3张图片

【数据结构系列】链表_第4张图片

参考实现

public class DoublyLinkedListSentinel implements Iterable<Integer> {

    @Override
    public Iterator<Integer> iterator() {
        return new Iterator<>() {
            Node p = sentinel.next;

            @Override
            public boolean hasNext() {
                return p != sentinel;
            }

            @Override
            public Integer next() {
                int value = p.value;
                p = p.next;
                return value;
            }
        };
    }

    static class Node {
        Node prev;
        int value;
        Node next;

        public Node(Node prev, int value, Node next) {
            this.prev = prev;
            this.value = value;
            this.next = next;
        }
    }

    private final Node sentinel = new Node(null, -1, null); // 哨兵

    public DoublyLinkedListSentinel() {
        sentinel.next = sentinel;
        sentinel.prev = sentinel;
    }

    /**
     * 添加到第一个
     * @param value 待添加值
     */
    public void addFirst(int value) {
        Node next = sentinel.next;
        Node prev = sentinel;
        Node added = new Node(prev, value, next);
        prev.next = added;
        next.prev = added;
    }

    /**
     * 添加到最后一个
     * @param value 待添加值
     */
    public void addLast(int value) {
        Node prev = sentinel.prev;
        Node next = sentinel;
        Node added = new Node(prev, value, next);
        prev.next = added;
        next.prev = added;
    }

    /**
     * 删除第一个
     */
    public void removeFirst() {
        Node removed = sentinel.next;
        if (removed == sentinel) {
            throw new IllegalArgumentException("非法");
        }
        Node a = sentinel;
        Node b = removed.next;
        a.next = b;
        b.prev = a;
    }

    /**
     * 删除最后一个
     */
    public void removeLast() {
        Node removed = sentinel.prev;
        if (removed == sentinel) {
            throw new IllegalArgumentException("非法");
        }
        Node a = removed.prev;
        Node b = sentinel;
        a.next = b;
        b.prev = a;
    }

    /**
     * 根据值删除节点
     * 

假定 value 在链表中作为 key, 有唯一性

* @param value 待删除值 */
public void removeByValue(int value) { Node removed = findNodeByValue(value); if (removed != null) { Node prev = removed.prev; Node next = removed.next; prev.next = next; next.prev = prev; } } private Node findNodeByValue(int value) { Node p = sentinel.next; while (p != sentinel) { if (p.value == value) { return p; } p = p.next; } return null; } }

六.解题模版

1.反转链表再正向遍历

可以先将链表反转,然后正向遍历即可实现从后往前遍历。这种方法的时间复杂度为 O(N),其中 N 为链表的长度。

CLASS LISTNODE:
    DEF __INIT__(SELF, VAL=0, NEXT=NONE):
        SELF.VAL = VAL
        SELF.NEXT = NEXT
DEF REVERSELIST(HEAD):
    PREV, CURR = NONE, HEAD
    WHILE CURR:
        NEXT_NODE = CURR.NEXT
        CURR.NEXT = PREV
        PREV = CURR
        CURR = NEXT_NODE
    RETURN PREV

DEF TRAVERSELIST(HEAD):
    NEW_HEAD = REVERSELIST(HEAD)
    WHILE NEW_HEAD:
        PRINT(NEW_HEAD.VAL)
        NEW_HEAD = NEW_HEAD.NEXT

2.递归遍历

可以使用递归的方式遍历链表,每次遍历到链表末尾时再开始输出节点的值。这种方法的时间复杂度也为 O(N),其中 N 为链表的长度。

CLASS LISTNODE:
    DEF __INIT__(SELF, VAL=0, NEXT=NONE):
        SELF.VAL = VAL
        SELF.NEXT = NEXT

DEF TRAVERSELIST(HEAD):
    IF NOT HEAD:
        RETURN
    TRAVERSELIST(HEAD.NEXT)
    PRINT(HEAD.VAL)

需要注意的是,递归遍历链表时,如果链表过长,可能会导致递归层数过深,从而出现栈溢出的情况。因此,如果链表长度较大,建议使用反转链表再正向遍历的方法。

七.链表题目

1.两数相加

给你两个 非空 的链表,表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的,并且每个节点只能存储 一位 数字。

请你将两个数相加,并以相同形式返回一个表示和的链表。

你可以假设除了数字 0 之外,这两个数都不会以 0 开头。

示例 1:

【数据结构系列】链表_第5张图片

输入:l1 = [2,4,3], l2 = [5,6,4]
输出:[7,0,8]
解释:342 + 465 = 807.

示例 2:

输入:l1 = [0], l2 = [0]
输出:[0]

示例 3:

输入:l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出:[8,9,9,9,0,0,0,1]

题解:

具体实现步骤如下:

  1. 首先,我们需要创建一个新的链表,用来存储两个链表相加的结果。同时,我们需要定义一个指针,用来遍历链表。
  2. 接着,我们可以从两个链表的头节点开始,依次遍历它们的每一个节点,将它们对应位置的数字相加,并记录进位。
  3. 如果其中一个链表已经遍历结束,我们就可以直接将另一个链表剩余的部分接到结果链表的后面(注意,这里还需要考虑进位)。
  4. 最后,如果遍历完成后还有进位,我们就需要在结果链表的末尾添加一个新节点,存储进位。
class Solution:
    def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
        """
        链表遍历
        :param l1:
        :param l2:
        :return:
        """
        res = ListNode(0)
        cur = res
        carry = 0
        while l1 or l2:
            x = l1.val if l1 else 0
            y = l2.val if l2 else 0
            s = x + y + carry
            carry = s // 10
            cur.next = ListNode(s % 10)
            cur = cur.next
            if l1:
                l1 = l1.next
            if l2:
                l2 = l2.next
        if carry:
            cur.next = ListNode(carry)
        return res.next

时间复杂度:O(max(m, n)),其中 m 和 n 分别是 l1 和 l2 的长度。

空间复杂度:O(max(m, n)),我们需要使用一个链表来存储结果。

2.两数相加 II

给你两个 非空 链表来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储一位数字。将这两数相加会返回一个新的链表。

你可以假设除了数字 0 之外,这两个数字都不会以零开头。

示例 1:

【数据结构系列】链表_第6张图片

输入:l1 = [7,2,4,3], l2 = [5,6,4]
输出:[7,8,0,7]

示例 2:

输入:l1 = [2,4,3], l2 = [5,6,4]
输出:[8,0,7]

示例 3:

输入:l1 = [0], l2 = [0]
输出:[0]

题解:

解题思路:

  1. 先把两个链表逆序,使得最低位在链表头部,这样就可以从头部开始相加了。
  2. 定义一个 carry 变量,表示进位,初始值为 0。
  3. 定义一个新的链表 dummyHead,表示相加的结果。
  4. 从链表 1 和链表 2 的头部开始遍历,对于每一位进行相加,同时加上进位 carry。
  5. 如果当前的和大于等于 10,就需要进位,将 carry 变为 1,同时将和减去 10。
  6. 将当前的和插入到新的链表 dummyHead 的末尾。
  7. 遍历完链表 1 和链表 2 后,如果进位 carry 为 1,还需要将 carry 插入到 dummyHead 的末尾。
  8. 最后将 dummyHead 逆序,得到正常的结果链表。
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next


# 翻转链表
def reverseList(head: ListNode) -> ListNode:
    pre = None
    curr = head
    while curr:
        next = curr.next
        curr.next = pre
        pre = curr
        curr = next
    return pre


class Solution:
    def addTwoNumbers(self, l11: Optional[ListNode], l22: Optional[ListNode]) -> Optional[ListNode]:
        l1 = reverseList(l11)
        l2 = reverseList(l22)
        res = ListNode(0)
        cur = res
        carry = 0
        while l1 or l2:
            x = l1.val if l1 else 0
            y = l2.val if l2 else 0
            s = x + y + carry
            carry = s // 10
            cur.next = ListNode(s % 10)
            cur = cur.next
            if l1:
                l1 = l1.next
            if l2:
                l2 = l2.next
        if carry:
            cur.next = ListNode(carry)
        return reverseList(res.next)

3.合并两个有序链表

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

【数据结构系列】链表_第7张图片

输入:l1 = [1,2,4], l2 = [1,3,4]
输出:[1,1,2,3,4,4]

示例 2:

输入:l1 = [], l2 = []
输出:[]

示例 3:

输入:l1 = [], l2 = [0]
输出:[0]

题解:

要合并两个有序链表,可以使用递归或迭代的方法。下面是使用迭代的方法实现合并两个有序链表的 Python 代码示例:

pythonCopy code
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

def mergeTwoLists(l1, l2):
    # 创建一个哑节点(dummy node)作为合并后链表的头节点
    dummy = ListNode(0)
    # 创建一个指针指向合并后链表的当前节点
    current = dummy

    # 循环比较l1和l2的节点值,并将较小的节点添加到合并后链表中
    while l1 and l2:
        if l1.val < l2.val:
            current.next = l1
            l1 = l1.next
        else:
            current.next = l2
            l2 = l2.next
        current = current.next

    # 处理剩余的节点
    current.next = l1 if l1 else l2

    # 返回合并后链表的头节点的下一个节点,即去除哑节点
    return dummy.next

这段代码中,我们创建了一个哑节点(dummy node)作为合并后链表的头节点。然后使用一个指针current指向合并后链表的当前节点。在循环中,我们比较l1l2的节点值,并将较小的节点添加到合并后链表中,同时移动相应的指针。最后,我们处理剩余的节点,将其添加到合并后链表的尾部。最后返回合并后链表的头节点的下一个节点,即去除哑节点。

你可以调用mergeTwoLists函数,传入两个有序链表的头节点,然后它将返回合并后的有序链表的头节点。

4.删除排序链表中的重复元素

给定一个已排序的链表的头 head删除所有重复的元素,使每个元素只出现一次 。返回 已排序的链表

示例 1:

【数据结构系列】链表_第8张图片

输入:head = [1,1,2]
输出:[1,2]

示例 2:

【数据结构系列】链表_第9张图片

输入:head = [1,1,2,3,3]
输出:[1,2,3]

题解:

class Solution:
    def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:
        dummy = head
        while dummy and dummy.next:
            # 如果当前节点和下一个节点的值相同,删除下一个节点
            if dummy.val == dummy.next.val:
                dummy.next = dummy.next.next
            else:
                dummy = dummy.next
        return head

5.环形链表

给你一个链表的头节点 head ,判断链表中是否有环。

如果链表中有某个节点,可以通过连续跟踪 next 指针再次到达,则链表中存在环。 为了表示给定链表中的环,评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置(索引从 0 开始)。注意:pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。

如果链表中存在环 ,则返回 true 。 否则,返回 false

输入:head = [3,2,0,-4], pos = 1
输出:true
解释:链表中有一个环,其尾部连接到第二个节点。

【数据结构系列】链表_第10张图片

题解:

class Solution:
    def hasCycle(self, head: Optional[ListNode]) -> bool:
        """
        双指针,一个快指针,一个慢指针,如果有环 一定会相聚
        :param head:
        :return:
        """
        if head is None or head.next is None:
            return False
        slow = head
        fast = head.next
        while slow != fast:
            if fast is None or fast.next is None:
                return False
            slow = slow.next
            fast = fast.next.next
        return True

6.相交链表

给你两个单链表的头节点 headAheadB ,请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点,返回 null

图示两个链表在节点 c1 开始相交**:**

【数据结构系列】链表_第11张图片

题目数据 保证 整个链式结构中不存在环。

注意,函数返回结果后,链表必须 保持其原始结构

自定义评测:

评测系统 的输入如下(你设计的程序 不适用 此输入):

  • intersectVal - 相交的起始节点的值。如果不存在相交节点,这一值为 0
  • listA - 第一个链表
  • listB - 第二个链表
  • skipA - 在 listA 中(从头节点开始)跳到交叉节点的节点数
  • skipB - 在 listB 中(从头节点开始)跳到交叉节点的节点数

评测系统将根据这些输入创建链式数据结构,并将两个头节点 headAheadB 传递给你的程序。如果程序能够正确返回相交节点,那么你的解决方案将被 视作正确答案

示例 1:

【数据结构系列】链表_第12张图片

输入:intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3
输出:Intersected at '8'
解释:相交节点的值为 8 (注意,如果两个链表相交则不能为 0)。
从各自的表头开始算起,链表 A 为 [4,1,8,4,5],链表 B 为 [5,6,1,8,4,5]。
在 A 中,相交节点前有 2 个节点;在 B 中,相交节点前有 3 个节点。
— 请注意相交节点的值不为 1,因为在链表 A 和链表 B 之中值为 1 的节点 (A 中第二个节点和 B 中第三个节点) 是不同的节点。换句话说,它们在内存中指向两个不同的位置,而链表 A 和链表 B 中值为 8 的节点 (A 中第三个节点,B 中第四个节点) 在内存中指向相同的位置。

题解:

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:
        """
        思路:如果存在交点,则肯定在两个链表分别遍历对方时相交
        :param headA:
        :param headB:
        :return:
        """
        if not headA or not headB:
            return None
        nodeA, nodeB = headA, headB
        while nodeA != nodeB:
            nodeA = nodeA.next if nodeA else headB
            nodeB = nodeB.next if nodeB else headA
        return nodeA

7.移除链表元素

给你一个链表的头节点 head 和一个整数 val ,请你删除链表中所有满足 Node.val == val 的节点,并返回 新的头节点

【数据结构系列】链表_第13张图片

示例 1:

输入:head = [1,2,6,3,4,5,6], val = 6
输出:[1,2,3,4,5]

示例 2:

输入:head = [], val = 1
输出:[]

示例 3:

输入:head = [7,7,7,7], val = 7
输出:[]

题解:

class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
        """
        链表的合适是操作2个节点,前驱和后继
        :param head:
        :param val:
        :return:
        """
        # 处理头部节点
        while head and head.val == val:
            head = head.next
        # 处理非头部
        cur = head
        while cur and cur.next:
            if cur.next.val == val:
                cur.next = cur.next.next
            else:
                cur = cur.next
        return head

8.反转链表

给你单链表的头节点 head ,请你反转链表,并返回反转后的链表。

示例 1:

【数据结构系列】链表_第14张图片

输入:head = [1,2,3,4,5]
输出:[5,4,3,2,1]

示例 2:

【数据结构系列】链表_第15张图片

输入:head = [1,2]
输出:[2,1]

示例 3:

输入:head = []
输出:[]

题解:

class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        """
        反转链表:定义前节点和当前节点
        :param head:
        :return:
        """
        pre, curr = None, head
        while curr is not None:
            next = curr.next
            curr.next = pre
            pre = curr
            curr = next
        return pre

9.回文链表

给你一个单链表的头节点 head ,请你判断该链表是否为回文链表。如果是,返回 true ;否则,返回 false

image-20230721165615618

输入:head = [1,2,2,1]
输出:true

题解:

class Solution:
    def isPalindrome(self, head: Optional[ListNode]) -> bool:
        """
        回文链表
        :param head:
        :return:
        """
        contain = []
        curr = head
        while curr is not None:
            contain.append(curr.val)
            curr = curr.next
        curr2 = head
        while curr2 is not None:
            if contain.pop() != curr2.val:
                return False
            curr2 = curr2.next
        return True

10.链表的中间结点

给你单链表的头结点 head ,请你找出并返回链表的中间结点。

如果有两个中间结点,则返回第二个中间结点。

image-20230721172833959

输入:head = [1,2,3,4,5]
输出:[3,4,5]
解释:链表只有一个中间结点,值为 3 。

题解:

class Solution:
    def middleNode(self, head: Optional[ListNode]) -> Optional[ListNode]:
        """
        链表的中间结点,如果有2个 返回第二个  快慢指针
        :param head:
        :return:
        """
        fast, slow = head, head
        while fast is not None and fast.next is not None:
            slow = slow.next
            fast = fast.next.next
        return slow

觉得有用的话点个赞 呗。
❤️❤️❤️本人水平有限,如有纰漏,欢迎各位大佬评论批评指正!

如果觉得这篇文对你有帮助的话,也请给个点赞、收藏下吧,非常感谢!

Stay Hungry Stay Foolish 道阻且长,行则将至,让我们一起加油吧!

【数据结构系列】链表_第16张图片

你可能感兴趣的:(s6,算法与数据结构,数据结构,链表)