链表基础知识详解(1)，一线大厂架构师都推荐的Golang零基础大全

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Golang全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Go语言开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024b （备注go）

正文

在链表的中间插入元素意味着在指定的位置或者在给定的节点之后插入新元素。

• 在链表尾部插入

在链表的尾部插入元素即将新元素添加到链表的末尾。

• 代码示例

public void insertAtStart(int data) {
Node newNode = new Node(data);
newNode.next = head;
head = newNode;
}

public void insertAfter(Node prevNode, int data) {
if (prevNode == null) {
System.out.println(“Previous node cannot be null”);
return;
}
Node newNode = new Node(data);
newNode.next = prevNode.next;
prevNode.next = newNode;
}

public void insertAtEnd(int data) {
Node newNode = new Node(data);
if (head == null) {
head = new Node(data);
return;
}
newNode.next = null;
Node last = head;
while (last.next != null) {
last = last.next;
}
last.next = newNode;
}

删除操作

• 删除指定元素

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

• 删除头部元素

删除链表的第一个元素。

• 删除尾部元素

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

• 代码示例

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[] adj; // 邻接表

Graph(int V) {
this.V = V;

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

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Go）

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

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

class Graph {
private int V; // 顶点数目
private List[] adj; // 邻接表

Graph(int V) {
this.V = V;

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

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Go）
[外链图片转存中…(img-CUEy3YZx-1713618377991)]

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