2024年最全链表基础知识详解(3)，2024年最新你有过迷茫吗

原创 于 2024-05-15 08:39:26 发布 · 396 阅读 · 9 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#go #学习 #面试

img
img

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

删除链表中值为特定值的节点。

  • 删除头部元素

删除链表的第一个元素。

  • 删除尾部元素

删除链表的最后一个元素。

  • 代码示例
public void deleteByKey(int key) {
    Node temp = head, prev = null;
    if (temp != null && temp.data == key) {
        head = temp.next;
        return;
    }
    while (temp != null && temp.data != key) {
        prev = temp;
        temp = temp.next;
    }
    if (temp == null) return;
    prev.next = temp.next;
}

public void deleteAtStart() {
    if (head != null) {
        head = head.next;
    }
}

public void deleteAtEnd() {
    if (head == null || head.next == null) {
        head = null;
        return;
    }
    Node temp = head;
    while (temp.next.next != null) temp = temp.next;
    temp.next = null;
}
查找操作
  • 查找元素是否存在

检查链表中是否存在某个元素。

  • 查找元素的位置

查找特定元素在链表中的位置。

  • 代码示例
public boolean search(int key) {
    Node current = head;
    while (current != null) {
        if (current.data == key) return true;
        current = current.next;
    }
    return false;
}
链表的遍历
  • 顺序遍历

从头到尾遍历链表中的每个元素。

  • 代码示例
public void printList() {
    Node tnode = head;
    while (tnode != null) {
        System.out.print(tnode.data + " ");
        tnode = tnode.next;
    }
}
  • 逆序遍历（如果是双向链表）

如果链表是双向链表，则可以从尾部到头部逆向遍历元素。

链表是基础数据结构之一，掌握其操作对于理解更复杂的数据结构非常重要。

4. 链表的高级操作
链表反转
思路解析

链表反转涉及到改变链表节点的指向。遍历链表，将每个节点的next指针指向它的前一个节点。为此，你需要维护两个指针：当前节点和它的前一个节点。

代码示例
class ListNode {
    int val;
    ListNode next;
    ListNode(int x) { val = x; }
}

public ListNode reverseList(ListNode head) {
    ListNode prev = null;
    ListNode curr = head;
    while (curr != null) {
        ListNode nextTemp = curr.next;
        curr.next = prev;
        prev = curr;
        curr = nextTemp;
    }
    return prev;
}
链表中环的检测
快慢指针法

快慢指针法能够检测链表中是否存在环。快指针每次移动两步，慢指针每次移动一步。如果链表中存在环，快慢指针最终会相遇。

代码示例
public boolean hasCycle(ListNode head) {
    if (head == null || head.next == null) {
        return false;
    }
    ListNode slow = head;
    ListNode fast = head.next;
    while (slow != fast) {
        if (fast == null || fast.next == null) {
            return false;
        }
        slow = slow.next;
        fast = fast.next.next;
    }
    return true;
}
合并两个有序链表
思路解析

创建一个新的链表头节点，然后逐个比较两个链表中的节点值，将较小的节点连接到新链表上，并移动相应的指针，直到某一个链表为空，然后将非空链表的剩余部分连接到新链表的末尾。

代码示例
public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
    ListNode dummy = new ListNode(-1);
    ListNode current = dummy;

    while (l1 != null && l2 != null) {
        if (l1.val < l2.val) {
            current.next = l1;
            l1 = l1.next;
        } else {
            current.next = l2;
            l2 = l2.next;
        }
        current = current.next;
    }

    current.next = (l1 != null) ? l1 : l2;

    return dummy.next;
}
找出链表的中间节点
快慢指针法

快慢指针法同样适用于找出链表的中间节点。快指针一次移动两步，慢指针一次移动一步。当快指针到达链表末尾时，慢指针正好在链表的中间。

代码示例
public ListNode middleNode(ListNode head) {
    ListNode slow = head;
    ListNode fast = head;
    while (fast != null && fast.next != null) {
        slow = slow.next;
        fast = fast.next.next;
    }
    return slow;
}
5. 链表的应用场景

![&nbsp][nbsp 3]

栈的实现

栈是一种后进先出（LIFO）的数据结构，可以使用链表来实现。链表的头部作为栈顶，因为这样可以在O(1)时间复杂度内完成push和pop操作。

代码示例
class Node {
    int value;
    Node next;
    Node(int value) { this.value = value; }
}

class Stack {
    private Node top;
    
    public boolean isEmpty() {
        return top == null;
    }
    
    public void push(int value) {
        Node newNode = new Node(value);
        newNode.next = top;
        top = newNode;
    }
    
    public int pop() {
        if (isEmpty()) throw new EmptyStackException();
        int value = top.value;
        top = top.next;
        return value;
    }
    
    public int peek() {
        if (isEmpty()) throw new EmptyStackException();
        return top.value;
    }
}
队列的实现

队列是一种先进先出（FIFO）的数据结构，可以通过带有头尾指针的链表来实现。链表的尾部作为队列的尾部用于插入，头部作为队列的头部用于删除。

代码示例
class Node {
    int value;
    Node next;
    Node(int value) { this.value = value; }
}

class Queue {
    private Node head, tail;
    
    public boolean isEmpty() {
        return head == null;
    }
    
    public void enqueue(int value) {
        Node newNode = new Node(value);
        if (isEmpty()) {
            head = tail = newNode;
        } else {
            tail.next = newNode;
            tail = newNode;
        }
    }
    
    public int dequeue() {
        if (isEmpty()) throw new NoSuchElementException();
        int value = head.value;
        head = head.next;
        if (head == null) {
            tail = null;
        }
        return value;
    }
    
    public int peek() {
        if (isEmpty()) throw new NoSuchElementException();
        return head.value;
    }
}
图的表示

链表也可以用来表示图。对于图中的每个顶点，可以使用链表来存储与它相邻的顶点。这种表示方法特别适合于表示稀疏图。

代码示例

这里以邻接表的形式表示无向图为例：

import java.util.LinkedList;
import java.util.List;

class Graph {
    private int V; // 顶点数目
    private List<Integer>[] adj; // 邻接表
    
    Graph(int V) {
        this.V = V;
        adj = new LinkedList[V];
        for (int i = 0; i < V; i++) {
            adj[i] = new LinkedList<>();
        }
    }
    
    // 添加边
    void addEdge(int v, int w) {
        adj[v].add(w);
        adj[w].add(v); // 无向图是双向的
    }
    
    // 与v相邻的所有顶点
    Iterable<Integer> adj(int v) {
        return adj[v];
    }
}

这些例子展示了链表在实现数据结构和表示结构化数据时的灵活性和功用。

6. 链表的问题与练习

链表作为一种基础且重要的数据结构，在软件开发和算法面试中经常遇到。

下面是一些常见的链表面试题及其解析。

常见面试题解析
  1. 反转链表

反转链表是最基础也是最常见的链表问题之一，要求改变链表的方向。

Java解法示例：

class ListNode {
    int val;


![img](https://img-blog.csdnimg.cn/img_convert/c84841d64ee65dbe3289a4fd9dac29b8.png)
![img](https://img-blog.csdnimg.cn/img_convert/8b6737bac9d0473219b1c79dabf53bb8.png)

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化的资料的朋友，可以添加戳这里获取](https://bbs.youkuaiyun.com/topics/618658159)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

表是最基础也是最常见的链表问题之一，要求改变链表的方向。

 **Java解法示例：**

class ListNode {
int val;

[外链图片转存中…(img-O1pKaC00-1715733543044)]
[外链图片转存中…(img-xNc1cuiN-1715733543044)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

2401_84911544
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值