编程导航算法通关村第一关 | 两个链表第一个公共子结点的5种解法

两个链表第一个公共子结点

这是一道经典的链表问题，剑指offer52 先看一下题目：输入两个链表，找出它们的第一个公共节点。例如下面的两个链表：

没思路时怎么办？
把常用数据结构和算法都想一遍
常用数据结构有数组，链表，队列，栈，hash，集合，树，堆；常用的算法有查找，排序，双指针，递归，迭代，分治，贪心，回溯，动态规划等

题解1. 哈希和集合

思路：先将一个链表元素全部存入map里，然后遍历第二个链表，同时检测hash中是否存在当前节点，如果有，则存在交点
代码如下：

ListNode* findFirstCommonNodeBySet(ListNode* headA, ListNode* headB) {
	set<ListNode*> set;
	// 遍历headA链表
	while (headA != NULL) {
		set.insert(headA);
		headA = headA->next;
	}
	// 遍历hashB,看hashA中是否存在
	while (headB != NULL) {
		// 如果存在，则直接返回该结点
		if (set.count(headB)) {
			return headB;
		}
		headB = headB->next;
	}
	return NULL;
}

题解2. 栈写法

思路：定义两个栈，分别存入两个链表，然后分别出栈并比较，如果相同就继续，直到找到不同的。因为每次弹出栈顶元素，所以相当于从两个链表的末尾结点往前找。这种方法需要2个O(n)空间，所以面试时不占优势。
代码如下：

ListNode* findFirstCommonNodeByStack(ListNode* headA, ListNode* headB) {
	stack<ListNode*> stackA;
	stack<ListNode*> stackB;
	// 把两个链表元素全部分别存入两个栈
	while (headA != NULL) {
		stackA.push(headA);
		headA = headA->next;
	}
	while (headB != NULL) {
		stackB.push(headB);
		headB = headB->next;
	}
	//
	ListNode* preNode = NULL;
	while (stackA.size() > 0 && stackB.size() > 0) {
		if (stackA.top() == stackB.top()) {
			preNode = stackA.top();
			stackA.pop();
			stackB.pop();
		}
		else {
			break;
		}
	}
	return preNode;
}

题解3. 拼接两个链表

看完了上面两种方法，那有没有空间复杂度是O(1)的方法呢
方法是有的，先举一个直观的例子：
有两个链表：
A：1—2—3—6—4—5
B：a—b—4—5
如果分别拼接成AB和BA会怎么样呢？
AB：0-1-2-3-4-5-a-b-4-5
BA：a-b-4-5-0-1-2-3-4-5
显然可以发现两种拼接后都是以4-5作为末尾的，而4就是我们要找的第一个公共子结点，所以拼接两个链表这种方式也能做，但既然咱讨论空间复杂度为O(1)的方法，那就不用创建新链表，直接在原链表上进行操作，这里用到的是双指针算法，用双指针可以模拟拼接的效果
先来看下代码：

ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
	// 首先判空
    if(headA == NULL || headB == NULL) {
        return NULL;
    }
    // 定义好两个工作指针，分别指向两个链表的头结点
    ListNode *p1 = headA;
    ListNode *p2 = headB;
    // 循环体内两个工作指针不断向后遍历
    while(p1 != p2) {
        p1 = p1->next;
        p2 = p2->next;
        // 没有找到公共子结点
        if(p1 != p2) {
            // 一个链表访问完了就跳到另一个链表继续访问，
            // 这样就能不创建新链表而模拟出拼接的效果
            if(p1 == NULL) p1 = headB;
            if(p2 == NULL) p2 = headA;
        }
    }
    return p1;
}

循环体里加一个if(p1 != p2)判断可以防止不存在交集的两个链表造成死循环

题解4. 差和双指针

我们重新审视一下上个题解中的模拟拼接的操作：

if(p1 != p2) {
    // 一个链表访问完了就跳到另一个链表继续访问，
    // 这样就能不创建新链表而模拟出拼接的效果
    if(p1 == NULL) p1 = headB;
    if(p2 == NULL) p2 = headA;
}

这样交错跳到另一个链表访问的原因是这两个链表长度不一致，如果是下面两个链表
A：1—2—4—5
B：a—b—4—5
是不是就可以直接同时从头往后遍历找相同结点了，所以有没有一种方法能实现这个效果呢
当然有，，这里用到的就是差和双指针：
思路：
有两个链表LinkListA，LinkListB，假设LinkListA的长度为L1，LinkListB的长度为L2，记两个链表长度差值为sub = | L1 - L2 |，我们把长的一条链表前面的部分不看，直接从第sub个结点开始，那么剩下的结点不就和短的链表的节点数一样了吗，这样就实现了我们上面所想的方法
代码实现：

ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
		// 判空
        if(headA == NULL || headB == NULL) {
            return NULL;
        }
        int l1 = 0, l2 = 0;
        ListNode *p1 = headA;
        ListNode *p2 = headB;
        // 统计两个链表长度
        while(p1 != NULL) {
            p1 = p1->next;
            l1 ++;
        }
        while(p2 != NULL) {
            p2 = p2->next;
            l2 ++;
        }
        // 工作指针归位
        p1 = headA;
        p2 = headB;
        // 让长的指针从第sub开始
        if(l1 > l2) {
            int sub = l1 - l2;
            while(sub --) {
                p1 = p1->next;
            }
        }
        if(l2 > l1) {
            int sub = l2 - l1;
            while(sub --) {
                p2 = p2->next;
            }
        }
        // 同时遍历两个链表
        while(p1 != p2) {
            p1 = p1->next;
            p2 = p2->next;
        }
        return p1;
    }

题解5. 暴力解法

暴力解法就不说了hh