两个单链表的共同节点

两个单链表的共同节点是指在这两个链表中存在的相同的元素。要找到它们的第一个共同节点，你可以采用“快慢指针”算法。首先，定义两个指针，一个快指针每次移动两步，另一个慢指针每次移动一步。如果链表中有公共节点，那么在某个时刻快指针和慢指针会指向同一个节点，因为快指针会在每个公共节点处比慢指针快一倍。

这里是一个简单的步骤过程：
1. 分别初始化两个指针，初始位置分别为两个链表的头结点。
2. 同时遍历两个链表，直到其中一个指针到达链表末尾。
3. 如果两个指针都未到链表末尾，说明找到了共同节点；此时，快指针所指的就是第一个共同节点。

如果你需要在Python中编写一个函数来查找这两个链表的第一个共同节点，可以这样做：

def find_common_node(head1, head2):
    if not head1 or not head2:
        return None

    slow = head1
    fast = head2

    while slow and fast:
        if slow == fast:
            return slow
        slow = slow.next if slow else None
        fast = fast.next.next if fast else None

    return None

相关问题

2、利用c++，给定两个单链表，编写算法找出两个链表的公共结点。

在C++中，找到两个单链表的公共节点可以使用双指针法。这个方法的基本思想是，分别从两个链表的头部开始，同时前进，如果它们指向相同的节点，则说明找到了公共节点。当其中一个链表遍历完时，另一个链表应该还在继续遍历，直到遇到相同的节点或者到达链表尾部。

下面是一个简单的C++函数，它接收两个链表的头节点作为输入，并返回第一个公共节点，如果没有公共节点则返回nullptr：

#include <iostream>
using namespace std;

// 链表节点结构
struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};

ListNode* findIntersectionNode(ListNode* list1, ListNode* list2) {
    if (!list1 || !list2) return nullptr; // 如果任何一个链表为空，直接返回null

    // 让快指针先走一步
    ListNode* fast = list1;
    ListNode* slow = list1;

    // 当快慢指针都指向链表尾部时，它们相交
    while (fast && fast->next) {
        fast = fast->next->next;
        slow = slow->next;
        if (fast == slow) break;
    }

    // 如果没相交，直接返回
    if (!fast || !fast->next) return nullptr;

    // 从链表头部开始，让两个指针再次相遇
    fast = list1;
    slow = slow->next;
    while (fast != slow) {
        fast = fast->next;
        slow = slow->next;
    }

    return fast; // 返回公共节点
}

int main() {
    // 测试示例
    ListNode* list1 = new ListNode(1);
    list1->next = new ListNode(2);
    list1->next->next = new ListNode(3);
    list1->next->next->next = new ListNode(4);
    list1->next->next->next->next = new ListNode(5);

    ListNode* list2 = new ListNode(6);
    list2->next = new ListNode(7);
    list2->next->next = new ListNode(8);
    list2->next->next->next = list1->next->next; // 列表2的部分链路与列表1共享

    ListNode* intersection = findIntersectionNode(list1, list2);
    if (intersection)
        cout << "Intersection node found: " << intersection->val << endl;
    else
        cout << "No intersection found." << endl;

    return 0;
}

在这个示例中，我们创建了两个链表，其中`list2`的一部分与`list1`有共同节点。`findIntersectionNode`函数会找到这两个链表的第一个公共节点。如果没有公共节点，函数将返回nullptr。

给定两个单链表，编写算法找出两个链表的公共结点。给出完整能运行的c++代码

在C++中，我们可以设计一个算法，通过比较两个链表的每个节点，找到第一个共同的节点。这里是一个解决方案，使用了哈希集合（unordered_set）来优化查找过程：

#include <iostream>
#include <unordered_set>

// 链表节点类
struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};

// 找到两个链表的第一个公共节点
ListNode* findIntersectionNode(ListNode* headA, ListNode* headB) {
    std::unordered_set<ListNode*> set;

    // 将链表A的所有节点添加到哈希集中
    while (headA != nullptr) {
        set.insert(headA);
        headA = headA->next;
    }

    // 从链表B开始，检查每个节点是否在哈希集中
    headA = headB;
    while (headA != nullptr && !set.count(headA)) {
        headA = headA->next;
    }

    return headA;
}

// 测试代码
int main() {
    // 创建两个示例链表
    ListNode* list1 = new ListNode(4);
    list1->next = new ListNode(1);
    list1->next->next = new ListNode(8);
    list1->next->next->next = new ListNode(4);
    list1->next->next->next->next = new ListNode(5); // 重复节点

    ListNode* list2 = new ListNode(5);
    list2->next = new ListNode(0);
    list2->next->next = new ListNode(1);
    list2->next->next->next = new ListNode(8); // 公共节点

    ListNode* intersection = findIntersectionNode(list1, list2);
    if (intersection != nullptr) {
        std::cout << "公共节点的值: " << intersection->val << std::endl;
    } else {
        std::cout << "没有公共节点" << std::endl;
    }

    delete list1;
    delete list2;

    return 0;
}

这段代码首先遍历链表A，将所有的节点添加到哈希集合中。然后，它从链表B的头部开始，如果遇到的节点已经在集合中，那么就找到了公共节点。