用于查找两个排序链表的交集的 C 程序

排序链表是链表中的一种特殊情况，它的节点按值的大小有序排列。在两个有序链表中查找它们的交集，可以使用指针，从链表头开始遍历两个链表。

算法步骤

1. 定义两个指向链表头的指针 p 和 q，从链表头开始遍历两个链表。
2. 比较 p 和 q 指向的节点的值，如果相等，则将该节点加入结果链表 result 中，同时让 p 和 q 指向下一个节点。
3. 如果 p 指向的节点的值小于 q 指向的节点的值，则让 p 指向下一个节点。
4. 如果 p 指向的节点的值大于 q 指向的节点的值，则让 q 指向下一个节点。
5. 当 p 或 q 遍历到链表末尾时，算法终止，返回结果链表 result。

代码实现

下面是用 C 语言实现上述算法的代码：

struct ListNode {
    int val;
    struct ListNode *next;
};

struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    struct ListNode *p = headA;
    struct ListNode *q = headB;
    struct ListNode *result = NULL;

    while (p && q) {
        if (p->val == q->val) {
            // p 和 q 指向的节点值相等，将该节点加入结果链表
            struct ListNode *node = (struct ListNode *)malloc(sizeof(struct ListNode));
            node->val = p->val;
            node->next = NULL;
            if (result == NULL) {
                result = node;
            } else {
                struct ListNode *temp = result;
                while (temp->next) {
                    temp = temp->next;
                }
                temp->next = node;
            }
            // p 和 q 指向下一个节点
            p = p->next;
            q = q->next;
        } else if (p->val < q->val) {
            // p 指向的节点的值小于 q 指向的节点的值，将 p 指针指向下一个节点
            p = p->next;
        } else {
            // p 指向的节点的值大于 q 指向的节点的值，将 q 指针指向下一个节点
            q = q->next;
        }
    }

    return result;
}

该程序使用了链表节点结构体 ListNode，其中 val 表示节点的值，next 表示指向下一个节点的指针。函数 getIntersectionNode 接受两个链表头指针 headA 和 headB，返回存放结果的链表头指针 result。

总结

在两个排序链表中查找它们的交集，可以使用指针，从链表头开始遍历两个链表。算法的时间复杂度为 O(m+n)，其中 m 和 n 分别表示两个链表的长度。如果两个链表的长度相差较大，则可以使用双指针法，将两个链表长度相等化，从而优化算法的时间复杂度。