【剑指offer】两个链表的第一个公共节点----java实现

【剑指offer】两个链表的第一个公共节点

题目描述为leetcode
编写一个程序,找到两个单链表相交的起始节点。
如下面的两个链表:
【剑指offer】两个链表的第一个公共节点----java实现_第1张图片
在节点 c1 开始相交。
示例 1:
【剑指offer】两个链表的第一个公共节点----java实现_第2张图片

输入:intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出:Reference of the node with value = 8
输入解释:相交节点的值为 8 (注意,如果两个列表相交则不能为 0)。从各自的表头开始算起,链表 A 为 [4,1,8,4,5],链表 B 为 [5,0,1,8,4,5]。在 A 中,相交节点前有 2 个节点;在 B 中,相交节点前有 3 个节点。

示例 2:
【剑指offer】两个链表的第一个公共节点----java实现_第3张图片

输入:intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出:Reference of the node with value = 2
输入解释:相交节点的值为 2 (注意,如果两个列表相交则不能为 0)。从各自的表头开始算起,链表 A 为 [0,9,1,2,4],链表 B 为 [3,2,4]。在 A 中,相交节点前有 3 个节点;在 B 中,相交节点前有 1 个节点。

示例 3:

【剑指offer】两个链表的第一个公共节点----java实现_第4张图片

输入:intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出:null
输入解释:从各自的表头开始算起,链表 A 为 [2,6,4],链表 B 为 [1,5]。由于这两个链表不相交,所以 intersectVal 必须为 0,而 skipA 和 skipB 可以是任意值。
解释:这两个链表不相交,因此返回 null。

注意:

如果两个链表没有交点,返回 null.
在返回结果后,两个链表仍须保持原有的结构。
可假定整个链表结构中没有循环。
程序尽量满足 O(n) 时间复杂度,且仅用 O(1) 内存。

1.暴力解法。

从头开始遍历第一个链表,遍历第一个链表的每个节点时,同时从头到尾遍历第二个链表,看是否有相同的节点,第一次找到相同的节点即第一个交点。若第一个链表遍历结束后,还未找到相同的节点,即不存在交点。时间复杂度为O(m*n)

2.借助外部空间

如果两个链表有公共结点,那么公共结点出现在两个链表的尾部。如果我们从两个链表的尾部开始往前比较,最后一个相同的结点就是我们要找的结点。But,在单链表中只能从头结点开始按顺序遍历,最后才能到达尾结点。最后到达的尾结点却要最先被比较,这是“后进先出”的特性。于是,我们可以使用栈的特点来解决这个问题:分别把两个链表的结点放入两个栈里,这样两个链表的尾结点就位于两个栈的栈顶,接下来比较两个栈顶的结点是否相同。如果相同,则把栈顶弹出接着比较下一个栈顶,直到找到最后一个相同的结点

public static ListNode FindFirstCommonNode(ListNode head1,ListNode head2) {
		if(head1 == null || head2 == null){
			return null;
		}
		Stack stack1 = new Stack();
		Stack stack2 = new Stack();
		while(head1 != null) {
			stack1.push(head1);
			head1 = head1.next;
		}
		while(head2 != null) {
			stack2.push(head2);
			head2 = head2.next;
		}
		
		ListNode node1 = null;
		ListNode node2 = null;
		ListNode common = null;
		
		while(!stack1.isEmpty() && !stack2.isEmpty()) {
			node1 = stack1.peek();
			node2 = stack2.peek();
			if(node1 == node2) {
				common = node1;
				stack1.pop();
				stack2.pop();
			}
			else {
				break;
			}
		}
		return common;	
	}
	
	public static void main(String[] args) {
		ListNode node1 = new ListNode(1);
		ListNode node2 = new ListNode(2);
		ListNode node3 = new ListNode(3);
		ListNode node4 = new ListNode(4);
		ListNode node5 = new ListNode(5);
		ListNode node6 = new ListNode(6);
		ListNode node7 = new ListNode(7);

        // first
        node1.next = node2;
        node2.next = node3;
        node3.next = node6;
        node6.next = node7;
        // second
        node4.next = node5;
        node5.next = node6;
        ListNode res = FindFirstCommonNode(node1,node4);
        System.out.println(res.val);
	}

在上述思路中,我们需要用两个辅助栈。如果链表的长度分别为m和n,那么空间复杂度是O(m+n)。这种思路的时间复杂度也是O(m+n)。和最开始的蛮力法相比,时间效率得到了提高,相当于是用空间消耗换取了时间效率。

3.不借助外界空间
我们可以首先遍历两个链表得到它们的长度,就能知道哪个链表比较长,以及长的链表比短的链表多几个结点。在第二次遍历的时候,在较长的链表上先走若干步,接着再同时在两个链表上遍历,找到的第一个相同的结点就是它们的第一个公共结点。

public static ListNode FindFirstCommonNode(ListNode head1,ListNode head2) {
		//得到两个链表的长度
		int len1 = GetListLength(head1);
		int len2 = GetListLength(head2);
		int diff = len1 - len2;
		
		ListNode headLong = head1;
		ListNode headShort = head2;
		if(diff < 0) {
			headLong = head2;
			headShort = head1;
			diff = len2 - len1;
		}
		
		//现在长链表上走几步
		for (int i = 0; i < diff; i++) {
			headLong = headLong.next;
		}
		
		//同时在两个链表遍历
		while(headLong != null && headShort != null && headLong != headShort) {
			headLong = headLong.next;
			headShort = headShort.next;
		}
		ListNode commonNode = headLong;
		return commonNode;	
	}
	
	private static int GetListLength(ListNode head) {
		int len = 0;
		ListNode tempNode = head;
		while(tempNode != null) {
			tempNode = tempNode.next;
			len++;
		}
		return len;
	}

时间复杂度是o(m),m代表最长链表的长度

你可能感兴趣的:(剑指offer,算法,链表)