经典算法题总结：链表篇

已于 2024-08-10 18:03:19 修改
阅读量638 收藏 24
点赞数 23
分类专栏： 数据结构与算法 文章标签： 算法 链表 数据结构
于 2024-08-10 18:00:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/RQfreefly/article/details/141093847
版权

链表的题目注意画图辅助思考防止断链；如果需要构造新的链表使用伪头结点（dummyHead）可以简化操作；双指针（快慢指针，左右指针）。

链表的递归算法：只要是递归形式的遍历，都可以有前序位置和后序位置，分别在递归之前和递归之后。所谓前序位置，就是刚进入一个节点（元素）的时候，后序位置就是即将离开一个节点（元素）的时候，那么进一步，你把代码写在不同位置，代码执行的时机也不同：

链表数据结构定义：

public class ListNode {
    public int val;
    public ListNode next;

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

}


public class DoubleListNode {
    public int key;
    public int value;
    public DoubleListNode pre;
    public DoubleListNode next;

    public DoubleListNode() {}

    public DoubleListNode(int key, int value) {
        this.key = key;
        this.value = value;
    }

}

206. 反转链表（⭐️⭐️）

思路

递归实现反转链表常常用来考察递归思想，我这里就用纯递归来翻转链表。对于递归算法，最重要的就是明确递归函数的定义。具体来说，我们的 reverse 函数定义是这样的：输入一个节点 head，将「以 head 为起点」的链表反转，并返回反转之后的头结点。明白了函数的定义，再来看这个问题。比如说我们想反转这个链表：

那么输入 reverse(head) 后，会在这里进行递归：

ListNode last = reverse(head.next);

不要跳进递归（你的脑袋能压几个栈呀？），而是要根据刚才的函数定义，来弄清楚这段代码会产生什么结果：

这个 reverse(head.next) 执行完成后，整个链表就成了这样：

并且根据函数定义，reverse 函数会返回反转之后的头结点，我们用变量 last 接收了。

现在再来看下面的代码：

head.next.next = head;

接下来：

head.next = null;
return last;

代码

public class ReverseList {

    public ListNode reverseListIterationVersion(ListNode head) {
        if (head == null || head.next == null) {
            return null;
        }
        ListNode newHead = null;
        ListNode next = null;
        ListNode cur = head;
        while (cur != null) {
            next = cur.next;
            cur.next = newHead;
            newHead = cur;
            cur = next;
        }
        return head;
    }

    public ListNode reverseListRecursionVersion(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        ListNode last = reverseListRecursionVersion(head.next);
        head.next.next = head;
        head.next = null;
        return last;
    }

}

复杂度

  • 时间复杂度：O(N)
  • 空间复杂度：迭代：O(1)，递归： O(N)

146. LRU 缓存（⭐️⭐️）

思路

LRU 缓存机制可以通过哈希表辅以双向链表实现，我们用一个哈希表和一个双向链表维护所有在缓存中的键值对。双向链表按照被使用的顺序存储了这些键值对，靠近头部的键值对是最近使用的，而靠近尾部的键值对是最久未使用的。哈希表即为普通的哈希映射（HashMap），通过缓存数据的键快速映射到其在双向链表中的位置。

这是一个LRU（Least Recently Used）缓存的实现，用于缓存键值对，保持最近访问的数据在缓存中，并在缓存容量不足时淘汰最久未使用的数据。

构造方法：

  • LRUCache(int capacity): 构造LRU缓存对象，传入缓存容量作为参数。

方法：

  • int get(int key): 获取缓存中指定键的值，如果不存在则返回-1，存在则返回对应的值，并将该节点移到链表头部，表示最近使用。
  • void put(int key, int value): 向缓存中插入或更新键值对。如果缓存中已存在该键，则更新对应值并将节点移到链表头部；如果不存在该键，则插入新节点到链表头部，并更新哈希表。如果插入节点后缓存容量超出限制，则移除链表尾部的节点，并从哈希表中删除对应键。

成员变量：

  • HashMap<Integer, Node> cache: 哈希表用于快速查找缓存中的节点。
  • int size: 当前缓存大小。
  • int capacity: 缓存容量。
  • Node head: 链表头部表示最近使用。
  • Node tail: 链表尾部表示最久未使用。

私有方法：

  • removeNode(Node node): 移除指定节点。
  • addToHead(Node node): 将节点添加到链表头部。
  • removeTail(): 移除链表尾部节点。
  • moveToHead(Node node): 将节点移到链表头部，表示最近使用。

内部类：

  • Node: 链表节点类，用于存储键值对及构建双向链表。包含键、值、前驱节点和后继节点。

代码

import java.util.HashMap;

public class LRUCache {
    private HashMap<Integer, DoubleListNode> cache = new HashMap<>();
    private int size = 0; // 当前缓存的大小
    private int capacity = 0; // 当前缓存的容量
    private DoubleListNode head = new DoubleListNode();
    private DoubleListNode tail = new DoubleListNode();

    public LRUCache(int capacity) {
        this.capacity = capacity;
        head.next = tail;
        tail.pre = head;
    }

    public int get(int key) {
        DoubleListNode node = cache.get(key);
        if (node == null) {
            return -1;
        } else {
            moveToHead(node);
            return node.value;
        }
    }

    public void put(int key, int value) {
        DoubleListNode node = cache.get(key);
        if (node == null) {
            DoubleListNode newNode = new DoubleListNode(key, value);
            cache.put(key, newNode);
            addToHead(newNode);
            size++;
            if (size > capacity) {
                cache.remove(tail.pre.key);
                removeTail();
                size--;
            }
        } else {
            node.value = value;
            moveToHead(node);
        }
    }

    private void moveToHead(DoubleListNode node) {
        removeNode(node);
        addToHead(node);
    }

    private void addToHead(DoubleListNode node) {
        // 先改变 node 的指针
        node.pre = head;
        node.next = head.next;
        // 再从右到左改变节点的指针，避免断链
        head.next.pre = node;
        head.next = node;
    }

    private void removeTail() {
        DoubleListNode node = tail.pre;
        removeNode(node);
    }

    private void removeNode(DoubleListNode node) {
        // 从右往左边改变指针，避免断链
        node.next.pre = node.pre;
        node.pre.next = node.next;
    }

}

复杂度

  • 时间复杂度：对于 put 和 get 都是 O(1)
  • 空间复杂度：O(capacity)

升级：过 x 秒之后没有操作的元素会自动过期删除（开一个定时任务）。

25. K 个一组翻转链表（⭐️⭐️）

思路

迭代：

两个关键的函数定义：

private ListNode findEnd(ListNode head, int k)
private void reverse(ListNode start, ListNode end)

注意前后两个节点的 next 指针的处理。

递归：

代码

public class ReverseKGroup {

    // 解法一：迭代
    public ListNode reverseKGroupIterationVersion(ListNode head, int k) {
        ListNode end = findEnd(head, k);
        if (end == null) {
            return head;
        }
        ListNode start = head;
        reverseIterationVersion(start, end);
        head = end;
        ListNode preEnd = start;
        while (preEnd.next != null) {
            start = preEnd.next;
            end = findEnd(start, k);
            if (end == null) {
                return head;
            }
            reverseIterationVersion(start, end);
            preEnd.next = end;
            preEnd = start;
        }
        return head;
    }

    private ListNode findEnd(ListNode head, int k) {
        ListNode end = head;
        while (--k > 0 && end != null) {
            end = end.next;
        }
        return end;
    }
    
    private void reverseIterationVersion(ListNode start, ListNode end) {
        ListNode subStart = end.next;
        ListNode newHead = null;
        ListNode cur = start;
        ListNode next = null;

        while (cur != subStart) {
            next = cur.next;
            cur.next = newHead;
            newHead = cur;
            cur = next;
        }

        start.next = subStart;
    }
    
    // 解法二：递归
    public ListNode reverseKGroupRecursionVersion(ListNode head, int k) {
        if (head == null) {
            return null;
        }
        // 区间[a, b)，包含 k 个待反转的元素
        ListNode a = head;
        ListNode b = head;
        for (int i = 0; i < k; i++) {
            // 不足 k 个，不需要反转
            if (b == null) {
                return head;
            }
            b = b.next;
        }
        ListNode newHead = reverseRecursionVersion(a, b);
        a.next = reverseKGroupRecursionVersion(b, k);
        return newHead;
    }

    private ListNode reverseRecursionVersion(ListNode a, ListNode b) {
        ListNode newHead = null;
        ListNode cur = a;
        ListNode next = null;

        while (cur != b) {
            next = cur.next;
            cur.next = newHead;
            newHead = cur;
            cur = next;
        }

        return newHead;
    }

}

复杂度

  • 时间复杂度：O(N)
  • 空间复杂度：O(1)

21. 合并两个有序链表（⭐️⭐）

思路

代码

public class MergeTwoLists {

    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode dummyHead = new ListNode(-1);
        ListNode p = dummyHead;
        ListNode p1 = l1;
        ListNode p2 = l2;

        while (p1 != null && p2 != null) {
            if (p1.val < p2.val) {
                p.next = p1;
                p1 = p1.next;
            } else {
                p.next = p2;
                p2 = p2.next;
            }
            p = p.next;
        }
        if (p1 != null) {
            p.next = p1;
        }
        if (p2 != null) {
            p.next = p2;
        }
    }

    return dummyHead.next;
}

复杂度

  • 时间复杂度：O(M + N)
  • 空间复杂度：O(1)

141. 环形链表（⭐️⭐️）

思路

代码

public class Solution {

    public boolean hasCycle(ListNode head) {
        // 如果链表为空或只有一个节点，肯定不存在循环，直接返回false
        if (head == null || head.next == null) {
            return false; 
        }
        ListNode slow = head;
        ListNode fast = head;

        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
            if (slow == fast) {
                return true;
            }
        }

        return false;
    }

}

复杂度

  • 时间复杂度：O(N)
  • 空间复杂度：O(1)

142. 环形链表 II（⭐️⭐️）

思路

代码

public class Solution {

    public ListNode detectCycle(ListNode head) {
        if (head == null || head.next == null) {
            return null;
        }
        ListNode fast = head;
        ListNode slow = head;

        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
            if (slow == fast) {
                break;
            }
        }

        slow = head;

        while (slow != fast) {
            slow = slow.next;
            fast = fast.next;
        }

        return fast;
    }

}

复杂度

  • 时间复杂度：O(N)
  • 空间复杂度：O(1)

23. 合并 K 个升序链表（⭐️⭐️）

思路

代码

import java.util.PriorityQueue;

public class MergeKLists {

    public ListNode mergeKLists(ListNode[] lists) {
        if (lists == null || lists.length == 0) {
            return null;
        }

        PriorityQueue<ListNode> priorityQueue = new PriorityQueue<>(
                Comparator.comparingInt(o -> o.val)
        );

        ListNode dummyHead = new ListNode(-1);
        ListNode cur = dummyHead;

        for (ListNode list : lists) {
            if (list == null) {
                continue;
            }
            priorityQueue.add(list);
        }

        while (!priorityQueue.isEmpty()) {
            ListNode node = priorityQueue.poll();
            cur.next = node;
            cur = cur.next;
            if (node.next != null) {
                priorityQueue.add(node.next);
            }
        }


        return dummyHead.next;
    }

}

复杂度

  • 时间复杂度：O(K * N * log K)，其中 K 为最小堆的最大的元素数量
  • 空间复杂度：O(K)

160. 相交链表（⭐️⭐️）

思路

pA 和 pB一同走过 a + b + c 路径长度时相遇在相交点。

代码

public class Solution {
    
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if (headA == null || headB == null) {
            return null;
        }
        ListNode pA = headA;
        ListNode pB = headB;
        while (pA != pB) {
            pA = pA == null ? headB : pA.next;
            pB = pB == null ? headA : pB.next;
        }
        return pA;
    }
    
}

复杂度

  • 时间复杂度：O(M + N)
  • 空间复杂度：O(1)

143. 重排链表(⭐️⭐️)

思路

代码

import java.util.ArrayList;

public class ReorderList {

    // 方法一：利用线性表，双指针遍历
    public void reorderListVerison1(ListNode head) {
        if (head == null) {
            return;
        }
        ArrayList<ListNode> list = new ArrayList<>();
        ListNode cur = head;
        while (cur != null) {
            list.add(cur);
            cur = cur.next;
        }
        int left = 0;
        int right = list.size() - 1;
        while (left < right) {
            list.get(left).next = list.get(right);
            left++;
            if (left == right) {
                break;
            }
            list.get(right).next = list.get(left);
            right--;
        }
        list.get(right).next = null;
    }

    // 方法二：快慢指针找到中间节点，再将后面半个链表反转，然后再插入
    public void reorderListVersion2(ListNode head) {
         if (head == null) {
             return;
         }
         ListNode mid = findMiddleNode(head);
         ListNode l1 = head;
         ListNode l2 = mid.next;
         mid.next = null;
         l2 = reverseList(l2);
         mergeList(l1, l2);
    }

    private void mergeList(ListNode l1, ListNode l2) {
        ListNode l1Next = null;
        ListNode l2Next = null;

        while (l1 != null && l2 != null) {
            l1Next = l1.next;
            l2Next = l2.next;

            l1.next = l2;
            l1 = l1Next;
            l2.next = l1;

            l2 = l2Next;
        }
    }

    private ListNode reverseList(ListNode head) {
        ListNode newHead = null;
        ListNode cur = null;
        ListNode next = null;

        while (cur != null) {
            next = cur.next;
            cur.next = newHead;
            newHead = cur;
            cur = next;
        }

        return newHead;
    }

    private ListNode findMiddleNode(ListNode head) {
        ListNode slow = head;
        ListNode fast = head;
        while (fast.next != null && fast.next.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        return slow;
    }

}

复杂度

  • 时间复杂度：O(N)
  • 空间复杂度：方法一：O(N)，方法二：O(1)

19. 删除链表的倒数第 N 个结点（⭐️⭐️）

思路

双指针。

代码

public class RemoveNthFromEnd {

    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummyHead = new ListNode(-1);
        dummyHead.next = head;
        ListNode x = findFromEnd(dummyHead, n + 1);
        x.next = x.next.next;
        return dummyHead.next;
    }

    // 双指针找到倒数第 n 个节点
    private ListNode findFromEnd(ListNode head, int n) {
        ListNode p1 = head;
        for (int i = 0; i < n; i++) {
            p1 = p1.next;
        }
        ListNode p2 = head;
        while (p1 != null) {
            p1 = p1.next;
            p2 = p2.next;
        }
        return p2;
    }

}

复杂度

  • 时间复杂度：O(N)
  • 空间复杂度：O(1)

82. 删除排序链表中的重复元素 II（⭐️⭐️）

思路

代码

public class DeleteDuplicates {

    public ListNode deleteDuplicates(ListNode head) {
        if  (head == null) {
            return null;
        }

        ListNode dummyHead = new ListNode(-1, head);
        ListNode cur = dummyHead;

        while (cur.next != null && cur.next.next != null) {
            if (cur.next.val == cur.next.next.val) {
                int x = cur.next.val;
                while (cur.next != null && cur.next.val == x) {
                    cur.next = cur.next.next;
                }
            } else {
                cur = cur.next;
            }
        }

        return dummyHead.next;
    }

}

复杂度

  • 时间复杂度：O(N)
  • 空间复杂度：O(1)

148. 排序链表（⭐️⭐️）

思路

方法一：自顶向下归并排序

方法二：自底向上归并排序

代码

public class SortList {

    public ListNode sortList(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        // 使用快慢指针找到链表中点，分为左右两个部分
        ListNode slow = head;
        ListNode fast = head.next;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }

        ListNode mid = slow.next;
        slow.next = null;
        ListNode left = sortList(head);
        ListNode right = sortList(mid);

        // 合并左右两个有序链表
        ListNode dummyHead = new ListNode(-1);
        ListNode  cur = dummyHead;
        while (left != null && right != null) {
            if (left.val < right.val) {
                cur.next = left;
                left = left.next;
            } else {
                cur.next = right;
                right = right.next;
            }
            cur = cur.next;
        }
        cur.next = left == null ? right :left;

        return dummyHead.next;
    }

}

在这个代码片段中，快指针 (fast) 需要先走一步的原因是为了确保链表在长度为偶数时，slow 指针能够准确地指向链表的中间节点。

具体来说，如果 fast 和 slow 指针都从链表头开始同步移动，每次 fast 移动两步，slow 移动一步，那么当 fast 到达链表末尾时，slow 指针会停在整个链表长度的中间位置（无论链表长度是奇数还是偶数）。

但是，如果不先让 fast 走一步，对于偶数长度的链表，slow 指针会在中间偏后的位置。通过让 fast 指针先走一步，当链表长度为偶数时，slow 指针会正好停在中间节点的前一个位置，从而使链表能够正确地分成两个部分。

复杂度

  • 时间复杂度：O(N * log(N))
  • 空间复杂度：O(log(N))

2. 两数相加（⭐️⭐）

思路

代码

public class AddTwoNumbers {

    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode dummyHead = new ListNode(-1);
        ListNode cur = dummyHead;
        int carry = 0; // 进位

        while (l1 != null || l2 != null) {
            int l1Value = l1 == null ? 0 : l1.val;
            int l2Value = l2 == null ? 0 : l2.val;
            int sum = l1Value + l2Value + carry;
            carry = sum / 10;
            sum = sum % 10;
            cur.next = new ListNode(sum);
            cur = cur.next;

            if (l1 != null) {
                l1 = l1.next;
            }
            if (l2 != null) {
                l2 = l2.next;
            }
        }

        if (carry == 1) {
            cur.next = new ListNode(carry);
        }

        return dummyHead.next;
    }

}

复杂度

  • 时间复杂度：O(N)
  • 空间复杂度：O(1)

rongqing2019
关注
  • 23
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
链表经典算法题
Frank的博客
10-03 1713
定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。
【算法】——链表题汇总
qq_43412060的博客
09-03 418
一、单链表的初始化 二、剑指 1、反转链表 2、复杂链表的复制 3、删除链表的指定结点 4、从尾到头打印链表 5、合并两个有序链表 6、链表中倒数第k个结点 7、两个链表的第一个公共节点 7、二叉树与双向链表 三、其他 1、圆圈中最后剩下的数字 2、返回链表的中间结点 3、判断链表是否是回文结构 4、判断链表中是否有环 5、返回链表入环的第一个结点 6、删除排序链表中的重复结点 6.1删除排序链表中的重复元素——使得每个元素只出现一次 6.1删除排序链表中的重复元素——只保留原始链表 7、链表分割 8、链表
力扣每日一题刷题总结：链表篇（持续更新）
南航小菜鸡
11-10 3247
3. 无重复字符的最长子串 2021.11.10 给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。 输入: s = “pwwkew” 输出: 3 重要思想方法：滑动窗口，遍历字符串，左端位置默认为0，右端也默认为0，从右端向右逐渐滑动 class Solution { public: //右端-左端+1即为字符串长度，散列表中的元素即为拆分的字符串 //如果没有遇到散列表中的字符，则加入散列表并继续右移 //如果遇到散列表中的字符，将原有字符删除并左端向右滑
算法：链表
最新发布
一名还在努力学习技术的程序员的博客
06-29 834
本篇博客是关于链表算法的练习题，每道题都超链接了力扣的网页，每道题都有详细的解答过程
C++链表相关算法题
qjyws的博客
12-04 1951
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、从尾到头打印链表&链表反转二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、从尾到头打印链表&链表反转 题目描述：输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。 输入：hea
面试高频算法题总结，个人博客
05-29
本篇文章将对一些常见的面试算法题目进行总结，重点讨论Python语言下的实现方式。 一、排序算法 1. 冒泡排序：基础排序算法，通过不断交换相邻的逆序元素来完成排序。Python实现简洁易懂，但效率较低。 2. 快速...
计算机基础提高资料：算法篇2
05-16
本文汇总了计算机基础提高资料中的算法篇第二部分所涵盖的知识点，包括折半查找、直接插入排序、归并排序、二叉树遍历、二分查找的应用条件、二叉排序树查找、顺序表插入操作、希尔排序的基本原理、单淘汰赛机制、...
计算机笔试真题汇总：数据结构篇1
08-08
计算机笔试中的数据结构题目是考察程序员基础能力的重要部分，涵盖了诸如二叉树、栈、数组、链表等核心概念。以下是对题目中涉及知识点的详细解释： 1. **二叉线索树**：二叉线索树是为了在二叉树中方便地进行中序...
java面试题总结
06-04
2. **数据结构与算法**：理解数组、链表、栈、队列、树、图等基本数据结构，并能够熟练运用排序（如冒泡、快速、归并、堆排序）和查找（如二分查找）算法。面试时可能会要求编写代码来实现特定的数据结构或算法。 3...
leetcode题库-leetcode:算法代码-JavaScript
06-29
在本篇文章中，我们将深入探讨JavaScript在算法实现中的应用，以及如何通过LeetCode的练习来提升你的编程能力。 首先，让我们了解一下JavaScript作为算法实现语言的优势。JavaScript是一种动态类型的脚本语言，它的...
Android面试题总结
02-18
这篇内容涵盖了广泛的Android面试知识点，包括算法、数据结构、编程技术、并发编程、数据库操作、网络协议、Android特性和设计模式等。以下是这些知识点的详细解释： 1. **算法**： - **最大数问题**：可以使用...
Algorithm:个人算法刷题总结，利用JS语言，每道题尝试优化最优解或最简洁的方法
03-20
本篇将主要围绕“个人算法刷题总结”，聚焦JavaScript语言，探讨如何通过优化实现算法的最优解和最简洁的方法。 首先，算法是解决问题的步骤和方法，是计算机科学的基础。JS（JavaScript）作为一种广泛使用的脚本...
leetcode题库-leetcode:leetcode
06-29
本篇将深入探讨LeetCode题库中的核心知识点，包括算法思想、数据结构及其在实际编程中的应用。 一、算法基础 1. 排序算法：LeetCode中有大量关于排序的题目，如快速排序、归并排序、堆排序等。通过这些题目，你可以...
前端大厂最新面试题-算法.docx
06-06
智力题总结 * 时针与分针夹角度数问题 * 用3升、5升杯子怎么量出4升水？ * 浑浊药罐问题 * 卡片证明问题 * 赛马问题，25 匹马，5 个赛道，最少几次能选出最快的三匹马？ * 五队夫妇参加聚会握手问题 * 你只能带行走...
leetcode:leetcode算法
05-10
在这个平台，用户可以通过解决各种难度的算法题来锻炼自己的编程思维。本篇文章将深入探讨LeetCode中的算法，并结合Java语言来阐述其核心知识点。 一、LeetCode平台概述 LeetCode提供了一个全面的算法练习库，涵盖...
程序员面试精选100题，非常经典
11-07
在本篇文章中，我们将探讨一个经典的编程面试题目：如何将一棵二元查找树（Binary Search Tree，简称BST）转换成一个排序的双向链表（Doubly Linked List）。这个问题不仅考验了对数据结构的理解，还涉及到算法设计...
c语言面试题总结
01-08
本篇文章将根据"c语言面试题总结"的主题，深入探讨C语言面试中可能会遇到的知识点。 一、C语言基础 1. 变量与数据类型：了解C语言中的基本数据类型，如int、char、float、double等，以及它们的存储大小和范围。...
牛客网算法题总结：链表反转解析
"这篇总结主要涉及的是在牛客平台上完成的一些简单的算法题目，特别是关于链表操作的问题，其中重点介绍了如何反转链表。" 在算法编程中，链表是一种非常基础且重要的数据结构，它由一系列节点组成，每个节点包含...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值