链栈的实现_2027考研408

最新推荐文章于 2026-06-23 19:22:08 发布
原创 最新推荐文章于 2026-06-23 19:22:08 发布 · 575 阅读 · 12 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#考研 #数据结构 #c语言 #笔记 #算法

链栈的实现——2027考研408数据结构全攻略

适用范围：2027年全国硕士研究生招生考试·计算机学科专业基础（408）
考纲章节：第三章 栈和队列 → 3.1 栈 → 栈的链式存储结构
难度等级：⭐⭐⭐（基础核心，与单链表对比命题多）

目录

  1. 知识点概念
  2. 链栈的结构定义
  3. 链栈的实现（基本操作）
  4. 链栈的进阶操作
  5. 时间与空间复杂度分析
  6. 优缺点对比
  7. 链栈与顺序栈的对比
  8. 应用场景
  9. 高频考点与易错点
  10. 真题演练
  11. 总结速记

一、知识点概念

1.1 链栈的定义

链栈（Linked Stack） 是栈的链式存储结构，本质上是只允许在表头进行插入和删除操作的单链表。链栈用链表存储栈中的元素，栈顶通常设在链表的头部。

链栈的核心特征：

  • 本质是一个单链表，只能在栈顶（链表头部）操作
  • 无需担心栈满（可无限扩容，除非内存耗尽）
  • 入栈 = 头插；出栈 = 头删
  • 无需预设容量，内存按需分配

1.2 链栈 vs 单链表

单链表（一般操作）:
[头] → [a1] → [a2] → [a3] → NULL
          ↑                    ↑
       可在任意位置插入      可在任意位置删除

链栈（受限操作）:
[头] → [a1] → [a2] → [a3] → NULL
          ↑
        栈顶（top）
        
只能: 栈顶插入(a) → [a] → [a1] → [a2] → [a3]
只能: 栈顶删除(a1) → [a2] → [a3] → NULL

📌 考研重点：链栈是单链表的特例，入栈操作即头插法创建链表，出栈操作即头删法。

1.3 链栈的存储结构

链栈结构:
┌─────────┐         ┌────┬────┐     ┌────┬────┐     ┌────┬────┐
│ top ────┼────────►│data│next│────►│data│next│────►│data│next│ NULL
└─────────┘         └────┴────┘     └────┴────┘     └────┴────┘
                      栈顶            中间结点         栈底（尾结点）

空栈: top = NULL

1.4 链栈与顺序栈的核心区别

对比维度链栈顺序栈
存储方式链式存储（离散）顺序存储（连续）
栈满问题无栈满（动态分配）有栈满（需预设容量）
入栈出栈O(1)O(1)
存储密度较低（含指针域）高（纯数据）
扩容无需扩容需扩容（有开销）
实现方式链表头作为栈顶数组+top指针

二、链栈的结构定义

2.1 C语言结构体定义

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

typedef int ElemType;

/* 链栈结点定义 */
typedef struct StackNode {
    ElemType data;               // 数据域
    struct StackNode *next;       // 指针域（指向下一个结点）
} StackNode, *LinkStack;

⚠️ 注意：LinkStack 是指向栈顶结点的指针（相当于 StackNode *top），不是整个栈的描述符。

2.2 空栈的表示

// 链栈空栈
LinkStack top = NULL;           // 栈顶指针为NULL表示空栈

三、链栈的实现（基本操作）

3.1 初始化

/* 初始化链栈（空栈） */
void InitStack(LinkStack *S) {
    *S = NULL;                   // 栈顶指针置空，无头结点
}

📌 注意：链栈通常不带头结点，栈顶就是链表的第一个数据结点。

3.2 判空

/* 判断链栈是否为空 */
bool StackEmpty(LinkStack S) {
    return S == NULL;           // 栈顶指针为NULL则空栈
}

3.3 入栈（Push）

/* 入栈操作：将元素e压入栈顶
 * 链栈的入栈本质是单链表的头插法
 */
bool Push(LinkStack *S, ElemType e) {
    StackNode *p = (StackNode *)malloc(sizeof(StackNode));
    if (p == NULL) return false;  // 内存分配失败
    
    p->data = e;                  // 将数据存入新结点
    p->next = *S;                 // 新结点指向原栈顶
    *S = p;                       // 栈顶指针指向新结点
    return true;
}

入栈图解：

入栈前:  top → [a1] → [a2] → [a3] → NULL

Push(e=99):
1. 创建新结点 p，p->data = 99
2. p->next = top (p指向a1)
3. top = p (top指向p)

入栈后:  top → [99] → [a1] → [a2] → [a3] → NULL
              ↑
            新栈顶

3.4 出栈（Pop）

/* 出栈操作：删除栈顶元素，并用e返回其值
 * 链栈的出栈本质是单链表的头删法
 */
bool Pop(LinkStack *S, ElemType *e) {
    if (StackEmpty(*S))           // 栈空，无法出栈
        return false;
    
    StackNode *p = *S;            // p指向栈顶结点
    *e = p->data;                // 用e返回栈顶元素
    *S = p->next;                 // 栈顶指针下移一位
    free(p);                      // 释放原栈顶结点
    return true;
}

出栈图解：

出栈前:  top → [a1] → [a2] → [a3] → NULL
                ↑
               p(待删除)

Pop(e):
1. *e = p->data = a1
2. top = p->next (top指向a2)
3. free(p)

出栈后:  top → [a2] → [a3] → NULL

3.5 取栈顶元素（GetTop）

/* 取栈顶元素：返回栈顶元素但不删除 */
bool GetTop(LinkStack S, ElemType *e) {
    if (StackEmpty(S))            // 栈空
        return false;
    
    *e = S->data;                 // 取出栈顶元素
    return true;
}

3.6 求栈长

/* 求链栈的长度 */
int StackLength(LinkStack S) {
    int len = 0;
    StackNode *p = S;             // p从栈顶开始
    while (p != NULL) {            // 遍历至栈底
        len++;
        p = p->next;
    }
    return len;
}

3.7 销毁链栈

/* 销毁链栈（释放所有结点） */
void DestroyStack(LinkStack *S) {
    StackNode *p;
    while (*S != NULL) {           // 依次释放每个结点
        p = *S;
        *S = (*S)->next;
        free(p);
    }
}

3.8 完整示例代码

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

typedef int ElemType;

typedef struct StackNode {
    ElemType data;
    struct StackNode *next;
} StackNode, *LinkStack;

/* 初始化 */
void InitStack(LinkStack *S) {
    *S = NULL;
}

/* 判空 */
bool StackEmpty(LinkStack S) {
    return S == NULL;
}

/* 入栈 */
bool Push(LinkStack *S, ElemType e) {
    StackNode *p = (StackNode *)malloc(sizeof(StackNode));
    if (p == NULL) return false;
    p->data = e;
    p->next = *S;
    *S = p;
    return true;
}

/* 出栈 */
bool Pop(LinkStack *S, ElemType *e) {
    if (StackEmpty(*S)) return false;
    StackNode *p = *S;
    *e = p->data;
    *S = p->next;
    free(p);
    return true;
}

/* 取栈顶 */
bool GetTop(LinkStack S, ElemType *e) {
    if (StackEmpty(S)) return false;
    *e = S->data;
    return true;
}

/* 求栈长 */
int StackLength(LinkStack S) {
    int len = 0;
    StackNode *p = S;
    while (p != NULL) {
        len++;
        p = p->next;
    }
    return len;
}

/* 打印栈（从栈顶到栈底） */
void PrintStack(LinkStack S) {
    printf("链栈（从顶到底，长度=%d）: ", StackLength(S));
    StackNode *p = S;
    while (p != NULL) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

/* 主函数测试 */
int main() {
    LinkStack S;
    ElemType e;

    InitStack(&S);
    
    // 入栈: 10 20 30 40 50
    for (int i = 1; i <= 5; i++)
        Push(&S, i * 10);
    PrintStack(S);                // 输出: 50 40 30 20 10（头插，逆序）

    // 取栈顶
    GetTop(S, &e);
    printf("栈顶元素: %d\n", e);   // 输出: 50

    // 出栈
    Pop(&S, &e);
    printf("出栈元素: %d\n", e);   // 输出: 50
    PrintStack(S);                // 输出: 40 30 20 10

    // 再出栈
    Pop(&S, &e);
    printf("出栈元素: %d\n", e);   // 输出: 40
    PrintStack(S);                // 输出: 30 20 10

    printf("栈长度: %d\n", StackLength(S)); // 输出: 3
    printf("栈是否为空: %s\n", StackEmpty(S) ? "是" : "否");

    DestroyStack(&S);
    return 0;
}

四、链栈的进阶操作

4.1 链栈的逆置

/* 逆置链栈
 * 思路：依次弹出元素，再依次压入（利用栈的特性）
 * 或直接反转链表
 */
void Reverse(LinkStack *S) {
    LinkStack tmp;
    InitStack(&tmp);
    ElemType e;
    
    // 弹出所有元素并压入tmp栈
    while (!StackEmpty(*S)) {
        Pop(S, &e);
        Push(&tmp, e);
    }
    
    // 再弹回原栈
    while (!StackEmpty(tmp)) {
        Pop(&tmp, &e);
        Push(S, e);
    }
}

4.2 链栈的复制

/* 复制链栈（深拷贝） */
LinkStack CopyStack(LinkStack S) {
    LinkStack newS;
    InitStack(&newS);
    
    if (S == NULL) return newS;
    
    // 第一遍：逆序复制到新栈
    StackNode *p = S;
    while (p != NULL) {
        Push(&newS, p->data);
        p = p->next;
    }
    
    // 第二遍：逆序弹出再压回，得到正序
    LinkStack tmp;
    InitStack(&tmp);
    ElemType e;
    while (!StackEmpty(newS)) {
        Pop(&newS, &e);
        Push(&tmp, e);
    }
    
    // 交换指针
    newS = tmp;
    return newS;
}

4.3 判断链栈是否对称

/* 判断链栈中的元素是否构成回文
 * 思路：将前半部分元素入辅助栈，然后比较后半部分
 */
bool IsSymmetric(LinkStack S) {
    if (S == NULL) return true;  // 空栈是对称的
    
    int len = StackLength(S);
    int half = len / 2;
    
    // 将前半部分压入辅助栈
    LinkStack aux;
    InitStack(&aux);
    StackNode *p = S;
    for (int i = 0; i < half; i++) {
        Push(&aux, p->data);
        p = p->next;
    }
    
    // 如果是奇数个，跳过中间结点
    if (len % 2 == 1)
        p = p->next;
    
    // 比较后半部分和辅助栈
    ElemType e;
    while (p != NULL) {
        Pop(&aux, &e);
        if (e != p->data) {
            DestroyStack(&aux);
            return false;
        }
        p = p->next;
    }
    
    DestroyStack(&aux);
    return true;
}

4.4 C++ STL stack 实现（了解）

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

int main() {
    stack<int> S;                  // STL中的stack默认基于deque实现
    
    // 入栈
    S.push(10);
    S.push(20);
    S.push(30);
    
    // 取栈顶
    cout << "栈顶: " << S.top() << endl;  // 输出: 30
    
    // 出栈
    S.pop();
    
    // 判空
    cout << "是否为空: " << S.empty() << endl;  // 输出: 0
    
    // 大小
    cout << "大小: " << S.size() << endl;  // 输出: 2
    
    return 0;
}

五、时间与空间复杂度分析

5.1 时间复杂度

操作时间复杂度说明
初始化 InitStackO(1)只需置空指针
判空 StackEmptyO(1)只需比较
入栈 PushO(1)只需申请结点并修改指针
出栈 PopO(1)只需修改指针并释放
取栈顶 GetTopO(1)直接访问
求栈长 StackLengthO(n)需遍历所有结点
销毁 DestroyStackO(n)需释放所有结点

📌 考研重点：链栈的入栈和出栈操作都是 O(1) 时间复杂度！

5.2 空间复杂度

类型空间复杂度说明
链栈本身O(n)n为当前元素个数
每个结点O(1)仅含数据域和指针域
各操作辅助空间O(1)（入栈/出栈）
O(n)（求长/销毁）		—

六、优缺点对比

6.1 链栈优点

  1. 无栈满问题：动态分配内存，只要内存足够就能入栈
  2. 空间按需分配：不预设容量，按需申请和释放
  3. 入栈出栈高效：只需 O(1) 时间修改指针
  4. 适合数据量不确定：无需担心溢出问题
  5. 插入删除灵活：不受固定容量限制

6.2 链栈缺点

  1. 存储密度低：每个结点额外存储一个指针（32位4字节，64位8字节）
  2. 缓存不友好：结点可能存储在不连续的内存位置
  3. 内存管理开销：每次入栈需 malloc，每次出栈需 free
  4. 无法随机访问：只能访问栈顶，无法直接访问栈底或中间元素
  5. 可能出现内存泄漏：忘记 free 会导致内存泄漏

七、链栈与顺序栈的对比

7.1 完整对比表

对比维度链栈顺序栈
存储方式链式（离散）顺序（连续）
栈满问题无栈满有栈满（需预设容量）
空间预分配无需需要
空间灵活性高（按需分配）低（固定容量）
入栈时间O(1)O(1)
出栈时间O(1)O(1)
取栈顶时间O(1)O(1)
求栈长时间O(n)O(1)
存储密度较低（含指针）高（纯数据）
缓存命中低（不连续）高（连续）
实现复杂度较低简单
内存开销malloc/free开销无

7.2 选择建议

场景推荐
数据量固定、可预估顺序栈
数据量不确定、变化大链栈
内存受限顺序栈（存储密度高）
入栈出栈频繁两者皆可
需要求栈长顺序栈（O(1)）

八、应用场景

8.1 适合使用链栈的场景

  • 数据量无法预知：如表达式求值、函数调用
  • 内存受限但需动态扩展：嵌入式系统
  • 频繁入栈出栈操作：如撤销操作、历史记录
  • 与顺序栈互补使用：根据实际需求选择

8.2 实际应用举例

应用使用原因
函数调用链栈存储返回地址和局部变量
表达式求值操作数栈和运算符栈
括号匹配左括号入栈，右括号出栈匹配
深度优先搜索用栈保存搜索路径
编译器语法分析符号表管理
内存管理栈帧管理

九、高频考点与易错点

9.1 高频考点

考点1：入栈 = 头插法，出栈 = 头删法 ⭐⭐⭐⭐

链栈的操作与单链表的头部操作完全一致：

// 链栈入栈 = 单链表头插法
bool Push(LinkStack *S, ElemType e) {
    StackNode *p = (StackNode *)malloc(sizeof(StackNode));
    p->data = e;
    p->next = *S;    // 新结点指向原栈顶
    *S = p;           // 栈顶指向新结点
    return true;
}

// 链栈出栈 = 单链表头删法
bool Pop(LinkStack *S, ElemType *e) {
    if (*S == NULL) return false;
    StackNode *p = *S;
    *e = p->data;
    *S = p->next;     // 栈顶下移
    free(p);
    return true;
}
考点2：链栈无栈满，顺序栈有栈满 ⭐⭐⭐
// 链栈判满
// 不需要判满！动态分配内存，只要malloc成功就能入栈

// 顺序栈判满
if (S->top == MaxSize - 1) return false; // 数组下标越界
考点3：链栈无头结点 ⭐⭐⭐
// 链栈通常不带头结点
LinkStack S = NULL;  // 直接指向第一个数据结点

// 单链表通常带头结点
LNode *L = (LNode *)malloc(sizeof(LNode));
L->next = NULL;      // 头结点
考点4：malloc/free 配对 ⭐⭐⭐
// 入栈时malloc
StackNode *p = (StackNode *)malloc(sizeof(StackNode));

// 出栈时free
free(p);  // 必须配对！

9.2 易错点汇总

易错点1：出栈前忘记判空
// ❌ 错误：直接出栈
Pop(&S, &e);  // 可能栈空！

// ✅ 正确：先判空
if (!StackEmpty(S)) {
    Pop(&S, &e);
} else {
    printf("栈空\n");
}
易错点2：入栈时malloc失败未处理
// ❌ 错误：未检查malloc返回值
StackNode *p = (StackNode *)malloc(sizeof(StackNode));
p->data = e;  // 若malloc失败，p为NULL，程序崩溃！

// ✅ 正确：检查malloc返回值
StackNode *p = (StackNode *)malloc(sizeof(StackNode));
if (p == NULL) return false;
p->data = e;
易错点3：出栈后忘记释放内存
// ❌ 错误：未释放内存，造成内存泄漏
*S = p->next;  // 栈顶下移，但p未释放

// ✅ 正确：释放内存
*S = p->next;
free(p);
易错点4：混淆链栈和单链表
// 链栈的栈顶 = 单链表的头部
// 链栈的栈底 = 单链表的尾部（next为NULL）

// ❌ 错误：链栈不支持在栈底操作
// 链栈只能在栈顶（链表头部）进行插入删除！

// ✅ 正确理解：链栈 = 只能在头部操作的特殊单链表
易错点5：求栈长复杂度误判
// 链栈求栈长需要遍历，O(n)时间
int StackLength(LinkStack S) {
    int len = 0;
    while (S != NULL) {
        len++;
        S = S->next;
    }
    return len;
}

// ❌ 错误：认为链栈求栈长是O(1)
// ✅ 正确：链栈求栈长是O(n)，顺序栈是O(1)
易错点6：销毁链栈时未置空
// ❌ 错误：销毁后未置空，可能导致悬空指针
DestroyStack(&S);
// S此时仍指向已释放的内存！

// ✅ 正确：销毁后置空
DestroyStack(&S);
S = NULL;

9.3 大题常见考法

  1. 选择题：链栈 vs 顺序栈的选择
  2. 选择题：链栈入栈出栈操作的时间复杂度
  3. 选择题：链栈无栈满 vs 顺序栈有栈满
  4. 算法设计题：链栈的基本操作实现
  5. 填空题：链栈入栈出栈的指针操作

十、真题演练

题目1（选择题）

题目：下列关于栈的叙述中，正确的是（ ）。

选项：
A. 栈是一种先进先出的线性表
B. 栈的链式存储结构中，仅能使用单链表实现
C. 链栈的入栈和出栈操作的时间复杂度都是 O(1)
D. 链栈不存在栈满的情况，但存在栈空的情况

答案：C、D

解析：

  • A错误：栈是后进先出（LIFO），不是先进先出（FIFO）
  • B错误：链栈可以用单链表实现，但也可使用其他链表
  • C正确：链栈入栈出栈都只需 O(1) 时间修改指针
  • D正确：链栈无栈满（动态分配），但栈空时 top = NULL

题目2（选择题）

题目：与顺序栈相比，链栈的主要优点是（ ）。

选项：
A. 入栈操作更容易实现
B. 支持随机访问
C. 入栈操作不会溢出
D. 出栈操作更快

答案：C

解析：

  • A错误：两者入栈都是 O(1)，难度相当
  • B错误：栈不支持随机访问，只能访问栈顶
  • C正确：链栈动态分配内存，不存在栈满溢出问题
  • D错误：两者出栈都是 O(1)

题目3（算法设计）

题目：设计一个算法，判断链栈是否为空栈。

bool StackEmpty(LinkStack S) {
    return S == NULL;
}

题目4（算法设计）

题目：设计一个算法，返回链栈中第 k 个元素（从栈顶开始）。

bool GetKth(LinkStack S, int k, ElemType *e) {
    StackNode *p = S;
    int count = 1;
    
    while (p != NULL && count < k) {
        p = p->next;
        count++;
    }
    
    if (p == NULL) return false;  // 不存在第k个元素
    *e = p->data;
    return true;
}

十一、总结速记

🔑 核心操作速记

链栈 = 单链表（只在头部操作）

入栈（头插）:
  p->next = *S
  *S = p

出栈（头删）:
  *e = (*S)->data
  *S = (*S)->next
  free(p)

空栈: S == NULL

🔑 链栈 vs 顺序栈一句话区别

链栈：无栈满（动态分配），但存储密度低，malloc/free 开销
顺序栈：有栈满（预设容量），但存储密度高，无额外指针开销

🔑 时间复杂度速记表

操作链栈顺序栈
入栈O(1)O(1)
出栈O(1)O(1)
取栈顶O(1)O(1)
求栈长O(n)O(1)
判空O(1)O(1)
销毁O(n)O(1)

🔑 考试答题模板

写链栈算法时，必须包含：

  1. ✅ 判空操作（出栈前必须判断）
  2. ✅ malloc 返回值检查（入栈时）
  3. ✅ free 释放内存（出栈时）
  4. ✅ 指针正确更新（栈顶移动）

📚 参考资料

  • 王道考研《数据结构》第3章 栈和队列
  • 严蔚敏《数据结构（C语言版）》第3章
  • 2027年408考试大纲·数据结构部分

本文涵盖2027年408考研数据结构链栈全部考点，建议结合真题反复练习代码实现。
如有疑问，欢迎在评论区交流！

顺序栈的实现_2027考研408
WODNT的博客
03-31 370
顺序栈是一种基于数组实现的后进先出(LIFO)线性结构，核心操作包括初始化、判空、判满、入栈、出栈和取栈顶元素。栈顶指针通常初始化为-1表示空栈，入栈时指针先加1再赋值，出栈时先取值再减1。顺序栈的时间复杂度均为O(1)，但存在固定容量限制。考研重点包括栈顶指针的两种约定方式、基本操作实现以及栈满/空条件判断，常考题型涉及栈的基本操作序列分析和应用场景。
2027计算机考研择校分析【27考研必读】
07-07 5072
如果同学们还没有下定决心要考哪所学校的话，可以看看下面的考研择校分析做参考。从上面的例子中我们得到几点启示可能同学们比较纠结的是专业课408和自主命题哪个好考一点？如果我中意的几所学校都是408应该怎么选择呢？2023全国各院校录取分数线汇总人数信息汇总清华大学一 一数据结构、操作系统、计算机网络、计算机组成原理点击查看一 一数据结构、操作系统、软件工程一 一数据结构、操作系统、软件工程一 一数据结构、操作系统、计算机网络、计算机组成原理一 一数据结构、操作系统、计算机网络、计算机组成原理北京大学点击查看2
双链表的实现_2027考研408
WODNT的博客
03-26 462
双链表是链表的一种改进形式，每个结点包含数据域、前驱指针和后继指针，支持双向遍历。文章详细介绍了双链表的结构定义（C语言实现）、基本操作（插入、删除、遍历、查找）及其时间复杂度分析。重点对比了双链表与单链表的优缺点，并指出双链表在需要频繁前驱操作时的优势。针对考研需求，文章还提供了循环双链表的初始化方法和典型操作实现代码，强调这是计算机考研408科目中线性表章节的重要考点。
循环双链表的实现_2027考研408
WODNT的博客
03-29 630
本文介绍了循环双链表的数据结构实现，主要内容包括： 循环双链表的基本概念和结构特点：在双向链表基础上首尾相连形成环状结构，每个结点包含前驱和后继指针，无NULL指针。 循环双链表的实现细节： C语言结构体定义 空表的三种表示方法 初始化方法（带头结点） 基本操作实现： 按位查找（普通版和优化版） 按值查找 插入操作（前插和后插），重点讲解了后插操作的4个指针修改步骤 循环双链表的优势在于插入删除操作的高效性，已知结点时前插和后插都只需O(1)时间。 通过图解展示了后插操作的具体过程。
顺序表的静态与动态实现_2027考研408
WODNT的博客
03-20 430
本文章包含2027考研408数据结构,顺序表部分的概念,区别,操作,复杂度分析,应用场景,考点考题分析等相关内容。
单链表的实现_2027考研408
WODNT的博客
03-26 391
单链表是线性表的链式存储结构，通过指针连接离散存储的结点。每个结点包含数据域和指针域，分为带头结点和不带头结点两种形式。本文详细介绍了单链表的结构定义、基本操作（初始化、查找、插入、删除）及其实现方法，对比了单链表与顺序表的优缺点。重点内容包括：带头结点的单链表操作更统一，插入删除时间复杂度为O(1)，但不支持随机访问。文中提供了C语言代码实现，并强调考研中默认使用带头结点的单链表，需重点掌握按位序操作和指针处理技巧。
408计算机考研全程班，带你稳稳上岸西电！
qq_30953547的博客
08-08 690
408计算机考研全程班，带你稳稳上岸西电！
循环单链表的实现_2027考研408
WODNT的博客
03-29 368
本文介绍了循环单链表的核心概念与实现方法，重点包括：1) 循环单链表的定义与结构特征（无NULL指针、首尾相连）；2) 带头结点与不带头结点的两种实现方式；3) 基本操作实现（初始化、查找、插入）及时间复杂度分析；4) 循环单链表的优势（尾插法O(1)时间复杂度）与普通单链表的对比。文章针对考研408数据结构考点，强调循环单链表的遍历终止条件、空表判断等易错点，并提供了代码实现示例。
又一所985改408！中国人民大学计算机专硕改为408！
计算机与软件考研
08-01 4648
中国人民大学是一所985大学，虽然在很多人的眼中，是一所“文科学校”，但是计算机学科评估B+，软件工程学科评估B，计算机综合实力也不差。而且中国人民大学位于北京市海淀区，在中关村附近，周...
RV1126+FFMPEG多路码流监控项目——高低分辨率码流推送流媒体
weixin_64611877的博客
06-20 280
本章的内容主要是讲解如何通过高低分辨率队列的每一帧数据，并且通过FFMPEG推流器分别传输到高低码流分辨率流媒体服务器，本章节代码在rkmedia_assignment_manage.cpp和rkmedia_data_process.cpp里面。低分辨率编码码流推送的过程和高分辨率编码码流的推送的过程基本上一致，唯一的区别在于分辨率的设置。
软件工程 vs 计算机科学与技术：哪个更适合你？课程/就业/考研三维对比
2503_93374004的博客
06-23 798
计算机科学与技术和软件工程专业对比指南：计科侧重底层理论与系统研发，课程包含硬件与数学，适合算法、科研及考公；软工聚焦软件开发全周期，课程偏工程实践，就业适配度高且考研难度较低。核心差异在于计科探索"计算机为何工作"，软工钻研"如何做出好软件"。建议根据兴趣与职业规划选择——偏好理论/科研选计科，倾向开发/快速就业选软工，但两者就业重合度高，关键取决于个人技能提升。附赠课程对比表与学习路线图，帮助新生理性决策。
考研408《操作系统》复习笔记，第三章《3.1 内存管理基本概念》
m0_73991249的博客
06-23 250
本文回顾了计算机组成原理中存储编址方式、单位换算及程序装入链接机制。主要内容包括：1）存储单元编址方式（字节编址为8bit，字编址取决于机器字长）；2）存储单位以2^n换算，网络速度以10^n换算；3）程序装入三阶段（编译、链接、装入），重点分析静态/动态重定位的区别及其对进程调换的影响；4）内存保护通过基址/界限寄存器实现地址转换和越界检查；5）进程内存映像的组成结构，特别强调I/O操作与指针变量的存储位置差异。最后通过例题巩固动态链接库的加载时机等核心概念。
考研408《操作系统》复习笔记，第三章《3.2.1 内存分配：连续分配》
最新发布
m0_73991249的博客
06-23 180
本文介绍了内存连续分配的几种方式：单一连续分配（单进程独占内存）、固定分区分配（预先划分相等或不等分区，可能产生内部碎片）和动态分区分配（按需分配，可能产生外部碎片）。重点分析了动态分区分配的四种算法：首次适应（按地址升序）、邻近适应（循环首次适应）、最佳适应（按容量升序）和最坏适应（按容量降序），并简要提及伙伴系统（按2的次幂分配）。各种方法在碎片产生、分配效率和适用场景上各有优劣。
视频直播点播//音视频点播/云点播/云直播EasyDSS一体化音视频平台重塑智慧校园新生态
EasyDSS官方技术博客
06-17 275
智慧校园建设不止是硬件设备的数字化，更是应用场景与协同效率的智能化升级。
2027地理学考研初试科目/参考书调整：中国地质大学（武汉）、东北师范、兰州大学
2301_78220461的博客
06-23 192
东北师范大学，生态与环境科学院，6月5日发布公告，调整初试参考书目：专业：资源与环境（环境工程）专业型硕士《环境管理学》，叶文虎、张勇编著，高等教育出版社，，2025年出版。
考研复习 Day 53 | 密码学--第十章 现代密码学发展前沿及应用（上）
QS_JSG的博客
06-16 479
量子密码的基本思想由美国学者S. Wiesner于1969年首先提出，后在IBM公司C.H. Bennett和加拿大密码学家G. Brassard的推动下发展起来，20世纪90年代进入研究高潮。目前已形成系统的量子密码理论体系，包括量子密钥分配、验证与存储、量子秘密共享、量子加密算法、量子身份认证和量子签名、量子多方安全协议及量子密码分析等。：采用四种偏振态（0°、45°、90°、135°），约定0°和45°代表0，90°和135°代表1。：量子比特传输过程中状态不确定，只有测量后才确定，安全性高。
算法与数据结构之Floyd算法
weixin_73953650的博客
06-20 514
超详细的Floyd算法教程，一看就懂！
Hermes Agent 技能进化系统拆解：Skill 的元数据结构、自注册加载与退化机制 [07]
Starry-SkyJing的博客
06-22 128
[07] Hermes Agent 技能进化系统拆解：Skill 的元数据结构、自注册加载与退化机制 > TL;DR：Skill 不是静态的文档——它是 Agent 的"程序性记忆"系统。SKILL
C/C++ 数据结构（十一）树
2301_80252792的博客
06-22 315
本文系统介绍了树结构基础与二叉树核心知识。主要内容包括：1.树的基础概念与术语（节点关系、度、深度等）；2.二叉树的数学特性、存储方式（链式/顺序）及堆结构；3.四种遍历算法（前/中/后序递归非递归实现，层序队列实现）；4.常用递归操作（求高、节点计数、插入删除）；5.应用实例（二叉搜索树、四/八叉树的游戏优化原理）。重点强调了完全二叉树与普通二叉树的区别，以及递归在树操作中的核心作用，为数据结构学习提供了完整框架。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值