牛客题解 | 【模板】链表

最新推荐文章于 2025-03-28 09:27:16 发布
原创 最新推荐文章于 2025-03-28 09:27:16 发布 · 234 阅读 · 9 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #算法力扣 #面试 #算法力扣面试

题目## 题目

题目链接

解题思路

  1. 插入操作：

    • 创建一个新节点。
    • 如果链表为空，直接将新节点作为头节点。
    • 遍历链表，找到第一个值为 x 的节点，在其前插入新节点。
    • 如果没有找到 x，将新节点插入到链表末尾。

  2. 删除操作：

    • 如果链表为空，直接返回。
    • 如果头节点的值为 x，直接删除头节点。
    • 遍历链表，找到第一个值为 x 的节点，删除该节点。

  3. 输出链表：

    • 遍历链表输出每个节点的值。
    • 如果链表为空，输出 “NULL”。

代码

#include <iostream>
#include <string>
using namespace std;

struct ListNode {
    int val;
    ListNode* next;
    ListNode(int x) : val(x), next(nullptr) {}
};

class LinkedList {
private:
    ListNode* head;

public:
    LinkedList() : head(nullptr) {}

    void insert(int x, int y) {
        ListNode* newNode = new ListNode(y);
        if (!head) {
            head = newNode;
            return;
        }

        if (head->val == x) {
            newNode->next = head;
            head = newNode;
            return;
        }

        ListNode* prev = nullptr;
        ListNode* curr = head;
        while (curr && curr->val != x) {
            prev = curr;
            curr = curr->next;
        }

        if (prev) {
            newNode->next = prev->next;
            prev->next = newNode;
        } else {
            newNode->next = head;
            head = newNode;
        }
    }

    void deleteNode(int x) {
        if (!head) return;

        if (head->val == x) {
            ListNode* temp = head;
            head = head->next;
            delete temp;
            return;
        }

        ListNode* prev = nullptr;
        ListNode* curr = head;
        while (curr && curr->val != x) {
            prev = curr;
            curr = curr->next;
        }

        if (curr) {
            prev->next = curr->next;
            delete curr;
        }
    }

    void printList() {
        if (!head) {
            cout << "NULL" << endl;
            return;
        }

        ListNode* curr = head;
        while (curr) {
            cout << curr->val << " ";
            curr = curr->next;
        }
        cout << endl;
    }
};

int main() {
    int n;
    cin >> n;
    LinkedList list;

    string op;
    while (n--) {
        cin >> op;
        if (op == "insert") {
            int x, y;
            cin >> x >> y;
            list.insert(x, y);
        } else if (op == "delete") {
            int x;
            cin >> x;
            list.deleteNode(x);
        }
    }

    list.printList();
    return 0;
}

import java.util.Scanner;

class ListNode {
    int val;
    ListNode next;
    ListNode(int x) { val = x; }
}

class LinkedList {
    private ListNode head;

    public LinkedList() {
        head = null;
    }

    public void insert(int x, int y) {
        ListNode newNode = new ListNode(y);
        if (head == null) {
            head = newNode;
            return;
        }

        if (head.val == x) {
            newNode.next = head;
            head = newNode;
            return;
        }

        ListNode prev = null;
        ListNode curr = head;
        while (curr != null && curr.val != x) {
            prev = curr;
            curr = curr.next;
        }

        if (prev != null) {
            newNode.next = prev.next;
            prev.next = newNode;
        } else {
            newNode.next = head;
            head = newNode;
        }
    }

    public void deleteNode(int x) {
        if (head == null) return;

        if (head.val == x) {
            head = head.next;
            return;
        }

        ListNode prev = null;
        ListNode curr = head;
        while (curr != null && curr.val != x) {
            prev = curr;
            curr = curr.next;
        }

        if (curr != null) {
            prev.next = curr.next;
        }
    }

    public void printList() {
        if (head == null) {
            System.out.println("NULL");
            return;
        }

        ListNode curr = head;
        while (curr != null) {
            System.out.print(curr.val + " ");
            curr = curr.next;
        }
        System.out.println();
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        LinkedList list = new LinkedList();

        for (int i = 0; i < n; i++) {
            String op = sc.next();
            if (op.equals("insert")) {
                int x = sc.nextInt();
                int y = sc.nextInt();
                list.insert(x, y);
            } else if (op.equals("delete")) {
                int x = sc.nextInt();
                list.deleteNode(x);
            }
        }

        list.printList();
    }
}

class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None

class LinkedList:
    def __init__(self):
        self.head = None

    def insert(self, x, y):
        new_node = ListNode(y)
        if not self.head:
            self.head = new_node
            return

        if self.head.val == x:
            new_node.next = self.head
            self.head = new_node
            return

        prev = None
        curr = self.head
        while curr and curr.val != x:
            prev = curr
            curr = curr.next

        if prev:
            new_node.next = prev.next
            prev.next = new_node
        else:
            new_node.next = self.head
            self.head = new_node

    def delete(self, x):
        if not self.head:
            return

        if self.head.val == x:
            self.head = self.head.next
            return

        prev = None
        curr = self.head
        while curr and curr.val != x:
            prev = curr
            curr = curr.next

        if curr:
            prev.next = curr.next

    def print_list(self):
        if not self.head:
            print("NULL")
            return

        curr = self.head
        while curr:
            print(curr.val, end=" ")
            curr = curr.next
        print()

# 读取输入
n = int(input())
linked_list = LinkedList()

for _ in range(n):
    op = input().strip().split()
    if op[0] == "insert":
        x, y = int(op[1]), int(op[2])
        linked_list.insert(x, y)
    elif op[0] == "delete":
        x = int(op[1])
        linked_list.delete(x)

linked_list.print_list()

算法及复杂度分析

算法：

  • 链表的基本操作

时间复杂度:

  • 插入操作(insert)： O ( n ) \mathcal{O}(n) O(n)

    • 需要遍历链表找到插入位置
    • 最坏情况下需要遍历整个链表

  • 删除操作(delete)： O ( n ) \mathcal{O}(n) O(n)

    • 需要遍历链表找到要删除的节点
    • 最坏情况下需要遍历整个链表

  • 打印操作(print_list)： O ( n ) \mathcal{O}(n) O(n)

    • 需要遍历整个链表输出所有节点

  • 总体时间复杂度： O ( q n ) \mathcal{O}(qn) O(qn)

    • q q q 是操作次数
    • n n n 是链表长度
    • 每个操作最坏情况下都需要遍历整个链表

空间复杂度:

  • 链表存储： O ( n ) \mathcal{O}(n) O(n)

    • n n n 是链表的节点数
    • 每个节点需要存储值和指针

  • 其他变量： O ( 1 ) \mathcal{O}(1) O(1)

    • 只需要少量额外变量来处理操作

  • 总体空间复杂度： O ( n ) \mathcal{O}(n) O(n)

    • 主要由链表本身的存储空间决定

题目链接

解题思路

  1. 使用一个固定大小的数组来存储队列元素。
  2. 维护两个指针 head 和 tail，分别指向队首和队尾。
  3. push 操作：将元素加入队尾，更新 tail 指针。
  4. pop 操作：输出并移除队首元素，更新 head 指针。
  5. front 操作：输出队首元素。
  6. 检查队列是否满或空，以决定是否输出 “full” 或 “empty”。

代码

#include <iostream>
#include <vector>
#include <string>
using namespace std;

class CircularQueue {
private:
    vector<int> data;
    int head, tail, size, capacity;

public:
    CircularQueue(int n) : data(n), head(0), tail(0), size(0), capacity(n) {}

    void push(int x) {
        if (size == capacity) {
            cout << "full\n";
        } else {
            data[tail] = x;
            tail = (tail + 1) % capacity;
            size++;
        }
    }

    void pop() {
        if (size == 0) {
            cout << "empty\n";
        } else {
            cout << data[head] << "\n";
            head = (head + 1) % capacity;
            size--;
        }
    }

    void front() {
        if (size == 0) {
            cout << "empty\n";
        } else {
            cout << data[head] << "\n";
        }
    }
};

int main() {
    int n, q;
    cin >> n >> q;
    CircularQueue cq(n);

    string op;
    while (q--) {
        cin >> op;
        if (op == "push") {
            int x;
            cin >> x;
            cq.push(x);
        } else if (op == "pop") {
            cq.pop();
        } else if (op == "front") {
            cq.front();
        }
    }
    return 0;
}

import java.util.Scanner;

class CircularQueue {
    private int[] data;
    private int head, tail, size, capacity;

    public CircularQueue(int n) {
        data = new int[n];
        head = 0;
        tail = 0;
        size = 0;
        capacity = n;
    }

    public void push(int x) {
        if (size == capacity) {
            System.out.println("full");
        } else {
            data[tail] = x;
            tail = (tail + 1) % capacity;
            size++;
        }
    }

    public void pop() {
        if (size == 0) {
            System.out.println("empty");
        } else {
            System.out.println(data[head]);
            head = (head + 1) % capacity;
            size--;
        }
    }

    public void front() {
        if (size == 0) {
            System.out.println("empty");
        } else {
            System.out.println(data[head]);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int q = sc.nextInt();
        CircularQueue cq = new CircularQueue(n);

        for (int i = 0; i < q; i++) {
            String op = sc.next();
            if (op.equals("push")) {
                int x = sc.nextInt();
                cq.push(x);
            } else if (op.equals("pop")) {
                cq.pop();
            } else if (op.equals("front")) {
                cq.front();
            }
        }
    }
}

class CircularQueue:
    def __init__(self, n):
        self.data = [0] * n
        self.head = 0
        self.tail = 0
        self.size = 0
        self.capacity = n

    def push(self, x):
        if self.size == self.capacity:
            print("full")
        else:
            self.data[self.tail] = x
            self.tail = (self.tail + 1) % self.capacity
            self.size += 1

    def pop(self):
        if self.size == 0:
            print("empty")
        else:
            print(self.data[self.head])
            self.head = (self.head + 1) % self.capacity
            self.size -= 1

    def front(self):
        if self.size == 0:
            print("empty")
        else:
            print(self.data[self.head])

# 读取输入
n, q = map(int, input().split())
cq = CircularQueue(n)

for _ in range(q):
    op = input().strip()
    if op.startswith("push"):
        _, x = op.split()
        cq.push(int(x))
    elif op == "pop":
        cq.pop()
    elif op == "front":
        cq.front()

算法及复杂度分析

  • 算法：循环队列的基本操作
  • 时间复杂度： O ( 1 ) \mathcal{O}(1) O(1) 对于每个操作。
  • 空间复杂度： O ( n ) \mathcal{O}(n) O(n)，其中 n n n 是队列的容量。

这个问题考察了循环队列的实现，重点在于正确维护 head 和 tail 指针的移动和边界条件的处理。

wc529065
关注
牛客题解 | 链表相加(二)
wc529065的博客
03-08 879
牛客题库题解
牛客题解 | 删除链表中重复的结点
wc529065的博客
03-27 481
牛客题库题解
牛客TOP101之链表篇（高效刷题，带你手撕算法）
qq_36317312的博客
05-04 3372
1、反转链表 1、给定一个单链表的头结点pHead(该头节点是有值的，比如在下图，它的val是1)，长度为n，反转该链表后，返回新链表的表头。 如当输入链表{1,2,3}时， 经反转后，原链表变为{3,2,1}，所以对应的输出为{3,2,1}。 以上转换过程如下图所示： 输入：{1,2,3} 返回值：{3,2,1} 输入：{} 返回值：{} 说明：空链表则输出空 常规思路：迭代 具体细节：在遍历链表时，将当前节点的next 指针改为指向前一个节点。由于节点没有引用其前一个节点，因此必须事先存储其前一个
【牛客剑指offer】数据结构——链表
weixin_46046227的博客
03-10 306
牛客剑指offer 链表 结构 链表 JZ6 从尾到头打印链表 简单 29.23% JZ24 反转链表 简单 39.67% JZ25 合并两个排序的链表 简单 32.53% JZ52 两个链表的第一个公共结点 简单 38.19% JZ23 链表中环的入口结点 中等 36.95% JZ22 链表中倒数最后k个结点 简单 36.44% JZ35 复杂链表的复制 较难 23.45% JZ76 删除链表中重复的结点 中等 22.23% JZ18 删除链表的节点
牛客——链表
哦啦啦啊哦哦
05-05 562
文章目录1、反转链表2、链表内指定区间反转3、链表中的节点每k个一组翻转4、合并两个排序的链表5、合并k个已排序的链表6、判断链表中是否有环7、链表中环的入口结点1、1、1、1、 1、反转链表 class Solution: def ReverseList(self , head: ListNode) -> ListNode: # write code here if not head:return None prev=None# 前驱节点
【剑指offer】【java】【链表】两个链表的第一个公共结点
qq_29295351的博客
03-06 237
题目 输入两个链表，找出它们的第一个公共结点。（注意因为传入数据是链表，所以错误测试数据的提示是用其他方式显示的，保证传入数据是正确的） 思路 故p1遍历到尾结点后再从phead2开始遍历 p2遍历到尾结点后再从phead1开始 两个指针同步next移位，走过的距离是 a+c+b=b+c+a 所以他们会在公共结点汇集 代码 /* public class ListNode { int ...
牛客_反转链表
zhangvalue的博客
02-23 596
题目描述 输入一个链表，反转链表后，输出新链表的表头。 思路： 链表是单向遍历，想要反转链表需要使用两个变量来控制 其中firstNode主要作用是作为一个中间结点的作用，不然单链表中间断掉失去下一个结点的信息 secondeNode作为最终的结点 /* public class ListNode { int val; ListNode next = null; ...
牛客题解 | 删除有序链表中重复的元素-II
wc529065的博客
03-27 343
牛客题库题解
牛客题解 | 反转字符串
wc529065的博客
03-28 1036
牛客题库题解
牛客题解 | 大数加法
wc529065的博客
03-03 849
牛客题库题解
[牛客]链表分割
远方的远方
05-14 391
编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的结点之前 给定一个链表的头指针 ListNode* pHead，请返回重新排列后的链表的头指针。注意：分割以后保持原来的数据顺序不变。 new关键字之后会创建实例对象，其他的复制都只是引用，比如 new A；//建立A的对象 B=A；//B是A的引用 /* pu
链表不得不刷的进阶题目，牛客TOP101链表相关——链表刷题
honglan297的博客
08-17 382
紧承上一篇 链表基础题目分享 的博客，本篇博客题目多来自于牛客 TOP101 中链表相关，难度较上一篇稍难半分。博主希望通过言简意赅的思路和代码，为大家提供不同的解题灵感，受限于精力原因只有少部分题目包含了详细图解，很抱歉，后续可能会进行补全。期盼能大家能在下面的链表题解中有所启发思考，共勉。...
牛客刷题之链表
qq_40651109的博客
07-27 249
题目描述 给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。 解题思路： 首先判断链表是否为空，为空直接返回空； 然后，将头节点分别赋给两个指针； 判断list1是否为空，若为空，直接返回null,否则，让list1先向前移动两个位置，让list2移动一个位置； 若有环，此时list1和list2相等，...
牛客网-剑指offer(三 )链表
hjxu2016的博客
04-02 397
牛客网剑指offer第二题，替换空格，原地址在这https://www.nowcoder.com/ta/coding-interviews想要练习的小伙伴可以去练习，期待大家都能拿到好的offer。输入一个链表，从尾到头打印链表每个节点的值。首先记录一下链表的定义先从python开始,python没有指针这个概念,所以定义起来一般就这样,python里是将链表的值添加到list里,c++利用栈的用...
牛客网---链表分割
sophia__yu的博客
11-06 368
编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的结点之前。 给定一个链表的头指针 ListNode* pHead，请返回重新排列后的链表的头指针。注意：分割以后保持原来的数据顺序不变。 对于这个题：思路是： 先将原链表数据分为2个集合，一个是小于x的集合l1，另一个是大于等于x的集合l2，只是把数据放进数组，并不排序，然后把l2中数据添加在集合l1后面，这样就完成小...
牛客网算法学习笔记-链表
u012656267的博客
05-25 3948
对于一个链表，我们需要用一个特定阈值完成对它的分化，使得小于等于这个值的结点移到前面，大于该值的结点在后面，同时保证两类结点内部的位置关系不变。 给定一个链表的头结点head，同时给定阈值val，请返回一个链表，使小于等于它的结点在前，大于等于它的在后，保证结点值不重复。 测试样例： {1,4,2,5},3 {1,2,4,5} 单独建立两个头结点，并且建立两个尾结点，保证有头指针
【牛客网】反转链表
tiewadhd的博客
08-19 726
转载于剑指Offer - 题目： 输入一个链表，反转链表后，输出链表的所有元素。 代码： class Solution { public: ListNode* ReverseList(ListNode* pHead) { ListNode* pReverseHead = NULL; ListNode* pNode = pHead; ListNode* pPre
浅刷牛客链表题，逐步深入链表，理解链表
yanxiang3306
11-04 1110
主要思想就是定义一个快指针，一个慢指针，快的一次走两步，慢的一次走一步，当快的走到链表的尾结点的时候，慢的就是中间结点的位置，然后把它后面的结点进行反转，上面说过怎么反转了，最后，从两端开始比较即可！思路描述：为了反转链表，简单一点说就是把结点的next值进行一个修改，如果我们用cur来记录当前的结点，那么在修改指向的时候，我们需要知道它的前一个结点(pre)和后一个结点(curNext)，因为一旦指向修改完成后，后面的结点就找不到了，所以我们需要记录一下。要求：空间复杂度 O(1)，时间复杂度O(n)
【牛客专项练习】数据结构—链表
weixin_42221791的博客
07-24 836
数据结构——链表
牛客练习赛142题解
最新发布
07-13
牛客练习赛142是一场编程竞赛，通常包含多个算法题目，涵盖如数组、字符串、链表、动态规划等常见数据结构与算法知识点。针对这类比赛的解题思路和方法，可以从以下几个方面进行分析： ### 题目类型与解题策略 1. *...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值