C++字符串处理与链表操作实战指南

1. 字符串处理与大小写转换实战

在C++编程中，字符串处理是最基础也最常用的操作之一。今天我想重点分享字符串大小写转换的实现原理和实际应用场景。

1.1 ASCII码与大小写转换原理

计算机中所有字符都是以ASCII码形式存储的。英文字母的大小写转换实际上就是通过ASCII码值的加减来实现的：

• 大写字母A-Z的ASCII码范围是65-90
• 小写字母a-z的ASCII码范围是97-122
• 大小写字母之间的ASCII码值相差32（小写字母的码值更大）

cpp复制if (s[i] >= 'a' && s[i] <= 'z') {
    s[i] -= 32; // 小写转大写
}

注意：直接使用32这个魔数(magic number)虽然可行，但在实际项目中建议使用字符字面量差值('a'-'A')，这样代码可读性更好。

1.2 实际应用：句子缩写生成器

假设我们需要实现一个句子缩写生成器，提取每个单词的首字母并转为大写。完整实现思路如下：

1. 遍历字符串，识别单词边界（空格或标点）
2. 提取每个单词的首字符
3. 如果是小写字母则转换为大写
4. 跳过非字母字符

cpp复制#include <iostream>
#include <string>
using namespace std;

string getAbbreviation(const string& s) {
    string result;
    bool newWord = true;
    
    for (char c : s) {
        if (isalpha(c)) {
            if (newWord) {
                if (c >= 'a' && c <= 'z') {
                    c -= 32; // 转换为大写
                }
                result += c;
                newWord = false;
            }
        } else {
            newWord = true;
        }
    }
    return result;
}

int main() {
    string input = "central processing unit";
    cout << getAbbreviation(input) << endl; // 输出"CPU"
    return 0;
}

1.3 输入处理技巧：getchar()的使用

在处理混合输入时（如数字后跟字符串），经常会遇到换行符残留问题。这时可以使用getchar()来吸收多余的换行符：

cpp复制int n;
cin >> n;
getchar(); // 吸收数字输入后的换行符

string s;
getline(cin, s); // 现在可以正确读取整行输入

2. 函数与参数传递深入解析

2.1 函数定义三要素

每个C++函数都包含三个基本部分：

1. 返回类型：决定函数返回值的类型，void表示不返回值
2. 函数名：遵循标识符命名规则，最好能体现函数功能
3. 参数列表：声明函数接受的参数类型和名称

cpp复制// 返回类型 函数名(参数列表)
int addNumbers(int a, int b) {
    return a + b;
}

2.2 形参与实参的区别

• 形参(Formal Parameter)：函数定义中声明的参数，是函数的局部变量
• 实参(Actual Parameter)：调用函数时传入的具体值

cpp复制void printSum(int x, int y) { // x和y是形参
    cout << x + y << endl;
}

int main() {
    int a = 5, b = 3;
    printSum(a, b); // a和b是实参
    return 0;
}

2.3 引用参数的优势与应用

引用是C++中强大的特性，它本质上是一个变量的别名。使用引用作为函数参数有两大优势：

1. 避免拷贝开销：特别是对于大型数据结构
2. 允许修改实参：函数内对引用的修改会影响原始变量

cpp复制void swap(int &x, int &y) {
    int temp = x;
    x = y;
    y = temp;
}

int main() {
    int a = 1, b = 2;
    swap(a, b);
    cout << a << " " << b << endl; // 输出"2 1"
    return 0;
}

在考研机试中，引用参数可以简化代码并提高效率。但要注意题目要求，有些环境可能对引用支持有限。

3. 指针与链表实现详解

3.1 指针基础操作

指针是C/C++中最强大也最容易出错的概念之一。理解指针需要掌握以下几个关键点：

1. 声明指针：使用*符号
2. 取地址：使用&获取变量地址
3. 解引用：使用*访问指针指向的值

cpp复制int x = 10;
int *ptr = &x; // ptr指向x的地址
cout << *ptr << endl; // 输出10（解引用）

指针与数组的关系特别密切：

cpp复制int arr[3] = {1, 2, 3};
int *p = arr; // 等价于 p = &arr[0]
cout << *(p + 1) << endl; // 输出2（指针算术）

3.2 链表节点定义

链表是由节点组成的线性数据结构，每个节点包含数据和指向下一个节点的指针。在C++中通常用结构体定义节点：

cpp复制struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(nullptr) {} // 构造函数
};

这个定义包含：

• int val：存储节点数据
• ListNode *next：指向下一个节点的指针
• 构造函数：初始化新节点，参数x赋值给val，next设为nullptr

3.3 虚拟头节点技巧

虚拟头节点(dummy node)是链表操作中的一个重要技巧，它位于实际头节点之前，可以简化边界条件处理：

cpp复制ListNode* dummy = new ListNode(0); // 创建虚拟头节点
dummy->next = head; // 连接到实际链表

// 在链表头部插入新节点
ListNode* newNode = new ListNode(5);
newNode->next = dummy->next;
dummy->next = newNode;

// 最终链表：dummy(0)->newNode(5)->original head...

使用虚拟头节点的好处：

1. 统一处理头节点和其他节点的操作
2. 避免空链表特殊情况
3. 简化插入/删除逻辑

4. 链表基本操作实现

4.1 创建链表

手动创建链表的示例代码：

cpp复制ListNode* createLinkedList() {
    ListNode *head = new ListNode(1);
    head->next = new ListNode(2);
    head->next->next = new ListNode(3);
    return head;
}

更实用的方法是编写一个函数根据数组创建链表：

cpp复制ListNode* createFromArray(vector<int>& arr) {
    ListNode dummy(0);
    ListNode *curr = &dummy;
    
    for (int num : arr) {
        curr->next = new ListNode(num);
        curr = curr->next;
    }
    
    return dummy.next;
}

4.2 遍历链表

遍历链表的基本模式：

cpp复制void printList(ListNode *head) {
    ListNode *curr = head;
    while (curr != nullptr) {
        cout << curr->val << " ";
        curr = curr->next;
    }
    cout << endl;
}

4.3 插入节点

在链表中插入节点有三种情况：

1. 头部插入
2. 中间插入
3. 尾部插入

使用虚拟头节点可以统一处理这些情况：

cpp复制ListNode* insertNode(ListNode *head, int index, int value) {
    ListNode dummy(0);
    dummy.next = head;
    ListNode *curr = &dummy;
    
    // 移动到插入位置前一个节点
    for (int i = 0; i < index && curr->next; i++) {
        curr = curr->next;
    }
    
    ListNode *newNode = new ListNode(value);
    newNode->next = curr->next;
    curr->next = newNode;
    
    return dummy.next;
}

4.4 删除节点

删除节点同样需要考虑边界条件：

cpp复制ListNode* deleteNode(ListNode *head, int index) {
    ListNode dummy(0);
    dummy.next = head;
    ListNode *curr = &dummy;
    
    // 移动到要删除节点的前一个位置
    for (int i = 0; i < index && curr->next; i++) {
        curr = curr->next;
    }
    
    if (curr->next) {
        ListNode *toDelete = curr->next;
        curr->next = toDelete->next;
        delete toDelete; // 释放内存
    }
    
    return dummy.next;
}

5. 常见问题与调试技巧

5.1 指针常见错误

1. 空指针解引用：

cpp复制ListNode *p = nullptr;
cout << p->val << endl; // 运行时错误

2. 内存泄漏：

cpp复制ListNode *node = new ListNode(1);
// 忘记delete node

3. 悬垂指针：

cpp复制ListNode *p = new ListNode(1);
delete p;
cout << p->val << endl; // p已成为悬垂指针

5.2 链表调试技巧

1. 可视化工具：使用纸笔画出链表结构
2. 打印链表：实现printList函数方便调试
3. 边界测试：
   • 空链表
   • 单节点链表
   • 头尾节点操作

5.3 考研机试中的链表题

在考研机试中，链表题常见考察点包括：

1. 链表反转
2. 环检测
3. 合并有序链表
4. 删除倒数第N个节点

以链表反转为例，迭代实现：

cpp复制ListNode* reverseList(ListNode* head) {
    ListNode *prev = nullptr;
    ListNode *curr = head;
    
    while (curr) {
        ListNode *next = curr->next;
        curr->next = prev;
        prev = curr;
        curr = next;
    }
    
    return prev;
}

递归实现：

cpp复制ListNode* reverseListRecursive(ListNode* head) {
    if (!head || !head->next) return head;
    
    ListNode *newHead = reverseListRecursive(head->next);
    head->next->next = head;
    head->next = nullptr;
    
    return newHead;
}

在实际编程练习中，我发现理解指针关系最好的方法就是画图。每个节点用一个方框表示，数据写在左边，next指针用箭头表示。这样在实现插入、删除等操作时，可以清晰地看到指针应该如何变化。