PAT甲级链表公共节点问题解析与双指针解法

1. PAT甲级真题-Sharing题目解析

这道题目来自PAT（Programming Ability Test）甲级考试，题目编号为"Sharing (25)"，分值25分。PAT是由浙江大学计算机科学与技术学院主办的编程能力测试，其甲级考试难度相当于ACM/ICPC区域赛水平，主要考察数据结构和算法应用能力。

从题目名称"Sharing"可以推断，本题很可能涉及共享数据结构或资源的处理，典型场景包括：

• 链表节点的共享（两个链表在某节点后合并）
• 图的公共边或顶点
• 字符串的公共子串
• 树结构的公共祖先

结合PAT甲级真题的命题特点，这道题最可能考察的是链表公共节点的处理，这是数据结构中的经典问题。题目通常会给出两个链表的头节点，要求找出它们第一个共享的节点。

2. 链表公共节点问题的标准解法

2.1 问题定义

给定两个单向链表的头节点headA和headB，找出并返回两个链表相交的起始节点。如果两个链表没有交点，返回null。

要求：

• 时间复杂度O(n)
• 空间复杂度O(1)
• 不能改变链表原始结构

2.2 双指针解法原理

这是最优美的解法之一，通过两个指针同步遍历两个链表：

1. 初始化指针pA和pB分别指向headA和headB
2. 同时向前移动两个指针
3. 当pA到达链表末尾时，重定位到headB；同理pB到达末尾时重定位到headA
4. 当pA和pB相遇时，即为第一个公共节点

这种方法的正确性基于数学原理：两个指针走过的总路径长度相同（a+b+c），因此必然在交点相遇。

cpp复制ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
    ListNode *pA = headA, *pB = headB;
    while (pA != pB) {
        pA = pA ? pA->next : headB;
        pB = pB ? pB->next : headA;
    }
    return pA;
}

2.3 哈希表解法

虽然不符合O(1)空间要求，但也是常见思路：

1. 遍历链表A，将所有节点地址存入哈希表
2. 遍历链表B，检查每个节点是否在哈希表中
3. 第一个存在的节点即为交点

cpp复制ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
    unordered_set<ListNode*> visited;
    while (headA) {
        visited.insert(headA);
        headA = headA->next;
    }
    while (headB) {
        if (visited.count(headB)) return headB;
        headB = headB->next;
    }
    return nullptr;
}

3. PAT真题的特殊处理要求

根据PAT考试的特点，实际题目可能会有以下变体：

3.1 输入格式处理

PAT题目通常需要处理特定输入格式，例如：

• 第一行给出两个链表的头节点地址和总节点数N
• 后续N行每行格式为：地址 数据 下一个节点地址
• 地址为5位数字，-1表示NULL

示例输入：

code复制11111 22222 5
11111 1 12345
12345 2 23456
23456 3 -1
22222 4 12345
33333 5 -1

3.2 数据结构构建

需要先将输入数据构建为链表结构：

cpp复制struct Node {
    int addr, data, next;
};

unordered_map<int, Node> nodes; // 地址到节点的映射

void buildList(int head, vector<Node>& list) {
    while (head != -1) {
        list.push_back(nodes[head]);
        head = nodes[head].next;
    }
}

3.3 完整解决方案

结合PAT输入特点的完整解法：

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

struct Node {
    int addr, data, next;
};

int main() {
    int headA, headB, N;
    cin >> headA >> headB >> N;
    
    unordered_map<int, Node> nodes;
    for (int i = 0; i < N; i++) {
        Node node;
        cin >> node.addr >> node.data >> node.next;
        nodes[node.addr] = node;
    }
    
    vector<Node> listA, listB;
    buildList(headA, listA);
    buildList(headB, listB);
    
    // 从尾部开始比较
    int i = listA.size() - 1, j = listB.size() - 1;
    int shared = -1;
    while (i >= 0 && j >= 0 && listA[i].addr == listB[j].addr) {
        shared = listA[i].addr;
        i--; j--;
    }
    
    if (shared != -1) {
        printf("%05d %d\n", nodes[shared].addr, nodes[shared].data);
    } else {
        printf("-1\n");
    }
    
    return 0;
}

4. 性能优化与边界处理

4.1 时间复杂度分析

• 双指针法：O(m+n)，每个链表最多遍历两次
• 哈希表法：O(m+n)，但需要额外空间
• PAT解法：O(m+n)，需要完整遍历两个链表

4.2 边界条件

必须考虑的特殊情况：

1. 一个或两个链表为空
2. 链表在第一个节点就相交
3. 链表在最后一个节点相交
4. 链表没有交点
5. 链表有环（虽然题目通常保证无环）

4.3 内存优化技巧

对于PAT的大数据量测试点：

1. 使用unordered_map而非map，查找效率更高
2. 预先分配vector容量避免多次扩容
3. 使用scanf/printf而非cin/cout加速IO

5. 常见错误与调试技巧

5.1 典型错误模式

1. 未处理-1表示NULL的情况
2. 地址输出未格式化为5位数字（printf("%05d")）
3. 哈希表解法忘记检查节点是否为NULL
4. 双指针法未正确处理两个链表长度相等的情况

5.2 调试建议

1. 先用小规模测试用例验证
2. 打印中间结果检查链表构建是否正确
3. 对相交和不相交的情况分别测试
4. 特别注意边界条件的测试

关键提示：PAT考试中，格式错误会导致全部测试点失败，务必确保地址输出为5位数字，即使地址值为0也要输出00000。

6. 算法扩展与变体

6.1 环形链表交点

如果链表可能有环，需要先检测环的存在：

1. 使用快慢指针检测环
2. 找到环的入口节点
3. 再应用标准解法

6.2 多链表公共节点

对于k个链表的第一个公共节点：

1. 计算所有链表长度
2. 先移动长链表的指针到与短链表相同位置
3. 然后同步移动比较

6.3 树结构的最近公共祖先

类似思路可以解决二叉树中两个节点的最近公共祖先(LCA)问题。

7. 实际工程应用

链表交点问题在以下场景有实际应用：

1. 内存管理中的共享内存块检测
2. 版本控制系统中的分支合并点查找
3. 网络拓扑中的公共连接节点识别
4. 生物信息学中的基因序列比对

在工程实现中，还需要考虑：

1. 链表可能非常大，需要流式处理
2. 多线程环境下的同步问题
3. 持久化存储中的节点表示方式