单链表相交问题

最新推荐文章于 2022-12-09 16:29:03 发布
最新推荐文章于 2022-12-09 16:29:03 发布
阅读量362 收藏
点赞数 1
分类专栏： 剑指offer 算法设计 文章标签： 链表相交 有环链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dcwjh/article/details/102649895
版权

两个单链表相交的一系列问题

  1. 单链表可能有环，也可能无环
  2. 两个单链表可能相交也可能不相交。
    若相交，请返回相交的第一个节点，若不相交请返回null

逻辑如下：
根据有环和无环可以分为三种情况：

1. 两个链表都无环，可能相交“Y”，可能不相交
2. 一个有环，一个无环，则不可能相交
3. 两个都有环，可能会出现三种情况

如下如所示
在这里插入图片描述

class Node{
	int data;
	Node next;
	public Node(int data){
		this.data = data;
	}
}

1. 判断有环无环: 有环返回第一个进入环的节点，无环返回null

1.1 HashSet方法

将节点一个一个添加进HashSet中，出现重复的元素（不是节点的值，是节点本身）证明有环

	public static Node getLoopNode(Node head) {
        if(head == null)
            return head;
        HashSet<Node> set = new HashSet<>();
        Node cur = head;
        while(cur != null) {
            if(set.contains(cur))
                return cur;
            set.add(cur);
            cur = cur.next;
        }
        return null;
    }

1.2 快慢指针方法

若快指针（一次两步）等于慢指针（一次一步），则有环，此时让快指针从头开始，快慢指针再次重新移动直至相遇，返回相遇节点。

	public static Node getLoopNode1(Node head){
        if(head == null || head.next == null || head.next.next == null)
            return null;
        Node fast = head.next.next;
        Node slow = head.next;
        while(fast != slow){
            if( fast.next == null || fast.next.next == null)
                return null;
            fast = fast.next.next;
            slow = slow.next;
        }
        fast = head;
        while(fast != slow){
            fast = fast.next.next;
            slow = slow.next;
        }
        return fast;

    }

2. 根据有无环判断单链表相交情况

2.1 无环

在这里插入图片描述
方法一：暴力法
两次循环寻找第一个公共节点：T(m, n) = O( m n mn mn)

	public Node getIntersectionNode(ListNode headA, ListNode headB) {
        if(headA == null || headB == null)
            return null;
        HashSet<ListNode> set = new HashSet<>();
        ListNode cur = headA;
        while(cur != null){
            set.add(cur);
            cur = cur.next;
        }
        cur = headB;
        while(cur != null){
            if(set.contains(cur))
                return cur;
            cur = cur.next;
        }
        return null;
        
    }

方法二：哈希表发

	public Node getIntersectionNode(Node headA, Node headB) {
        if(headA == null || headB == null)
            return null;
        HashSet<ListNode> set = new HashSet<>();
        Node cur = headA;
        while(cur != null){
            set.add(cur);
            cur = cur.next;
        }
        cur = headB;
        while(cur != null){
            if(set.contains(cur))
                return cur;
            cur = cur.next;
        }
        return null;
        
    }

方法三: 双指针法

思路：
指针 pA 指向 A 链表，指针 pB 指向 B 链表，依次往后遍历
如果 pA 到了末尾，则 pA = headB 继续遍历
如果 pB 到了末尾，则 pB = headA 继续遍历
比较长的链表指针指向较短链表head时，长度差就消除了
如此，只需要将最短链表遍历两次即可找到位置

简而言之就是让两个指针走的路程长度一样多，第二次必定会相遇。

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

public Node getIntersectionNode(Node headA, Node headB) {
    if (headA == null || headB == null) return null;
    Node pA = headA, pB = headB;
    while (pA != pB) {
        pA = pA == null ? headB : pA.next;
        pB = pB == null ? headA : pB.next;
    }
    return pA;
}


	public static Node noLoop(Node head1, Node head2) {
		if (head1 == null || head2 == null) {
			return null;
		}
		Node cur1 = head1;
		Node cur2 = head2;
		int n = 0;
		while (cur1.next != null) {
			n++;
			cur1 = cur1.next;
		}
		while (cur2.next != null) {
			n--;
			cur2 = cur2.next;
		}
		if (cur1 != cur2) {
			return null;
		}
		cur1 = n > 0 ? head1 : head2;
		cur2 = cur1 == head1 ? head2 : head1;
		n = Math.abs(n);
		while (n != 0) {
			n--;
			cur1 = cur1.next;
		}
		while (cur1 != cur2) {
			cur1 = cur1.next;
			cur2 = cur2.next;
		}
		return cur1;
	}

方法四：两个辅助栈
将两个链表元素分别入两个栈，出栈前先保存节点，直到两个节点不相等时则返回上一个节点

public static Node noLoop(Node head1, Node head2) {
        if (head1 == null || head2 == null) {
            return null;
        }
        Stack<Node> stack1 = new Stack<>();
        Stack<Node> stack2 = new Stack<>();
        Node cur1 = head1;
        Node cur2 = head2;
        while(cur1 != null){
            stack1.push(cur1);
            cur1 = cur1.next;
        }
        while(cur2 != null){
            stack2.push(cur2);
            cur2 = cur2.next;
        }
        //栈顶不相等，说明没有共同元素，返回null
        if(stack1.peek() != stack2.peek())
        	return null;
        while(!stack1.empty() && !stack2.empty()){
            Node temp = stack1.peek();
            stack1.pop();
            stack2.pop();
            if(stack1.peek() != stack2.peek()) //下一个不相等返回上一个
                return temp;
        }
        return null;
    }

2.2 一个有环一个无环

一个有环一个无环必定没有公共节点，返回空即可

2.3 都有环

在这里插入图片描述
有环分为三种情况：
逻辑：用是否有入环相同节点来划分
将情况划为两种情况：

  1. loop1 == loop2, 此时就是图中情况二，将环忽略（就是将loop1或者loop2作为结束节点），将这种情况化成了上面无环的情况（区别：这种情况必定有相同节点）
  2. loop1 != loop2, 此时就是让loop2作为结束节点，loop1作为开始节点，loop1开始遍历
    1. 若有loop1 == loop2的情况，那loop1或者loop2都是第一个开始节点，返回一个即可；
    2. 若到了结束节点loop2没有相等的情况，则返回null。
	public static Node bothLoop(Node head1, Node loop1, Node head2, Node loop2) {
		Node cur1 = null;
		Node cur2 = null;
		if (loop1 == loop2) {  //装换成无环的结构链表，但是必有相交节点
			cur1 = head1;
			cur2 = head2;
			int n = 0;
			while (cur1 != loop1) {
				n++;
				cur1 = cur1.next;
			}
			while (cur2 != loop2) {
				n--;
				cur2 = cur2.next;
			}
			cur1 = n > 0 ? head1 : head2;
			cur2 = cur1 == head1 ? head2 : head1;
			n = Math.abs(n);
			while (n != 0) {
				n--;
				cur1 = cur1.next;
			}
			while (cur1 != cur2) {
				cur1 = cur1.next;
				cur2 = cur2.next;
			}
			return cur1;
		} else {
			cur1 = loop1.next;
			while (cur1 != loop1) {
				if (cur1 == loop2) {
					return loop1;
				}
				cur1 = cur1.next;
			}
			return null;
		}
	}


public static Node bothLoop(Node head1, Node loop1, Node head2, Node loop2) {
		Node cur1 = null;
		Node cur2 = null;
		if (loop1 == loop2) {  //装换成无环的结构链表，但是必有相交节点
			cur1 = head1;
			cur2 = head2;
			while(cur1 != cur2){
				cur1 = cur1 == loop1 ? head2 : cur1.next;
				cur2 = cur2 == loop2 ? head1 : cur2.next;
			}
			return cur1;
		} else {
			cur1 = loop1.next;
			while (cur1 != loop1) {
				if (cur1 == loop2) {
					return loop1;
				}
				cur1 = cur1.next;
			}
			return null;
		}
	}

整体代码如下：

public class FindFirstIntersectNode {

	public static class Node {
		public int value;
		public Node next;

		public Node(int data) {
			this.value = data;
		}
	}

	//主逻辑
	public static Node getIntersectNode(Node head1, Node head2) {
		if (head1 == null || head2 == null) {
			return null;
		}
		Node loop1 = getLoopNode(head1);
		Node loop2 = getLoopNode(head2);
		// 都无环
		if (loop1 == null && loop2 == null) {
			return noLoop(head1, head2);
		}
		// 都有环
		if (loop1 != null && loop2 != null) {
			return bothLoop(head1, loop1, head2, loop2);
		}
		//一个有环一个无环
		return null;
	}

	public static Node getLoopNode(Node head) {
		if (head == null || head.next == null || head.next.next == null) {
			return null;
		}
		Node n1 = head.next; // n1 -> slow
		Node n2 = head.next.next; // n2 -> fast
		while (n1 != n2) {
			if (n2.next == null || n2.next.next == null) {
				return null;
			}
			n2 = n2.next.next;
			n1 = n1.next;
		}
		n2 = head; // n2 -> walk again from head
		while (n1 != n2) {
			n1 = n1.next;
			n2 = n2.next;
		}
		return n1;
	}

	public static Node noLoop(Node head1, Node head2) {
		if (head1 == null || head2 == null) {
			return null;
		}
		Node cur1 = head1;
		Node cur2 = head2;
		int n = 0;
		while (cur1.next != null) {
			n++;
			cur1 = cur1.next;
		}
		while (cur2.next != null) {
			n--;
			cur2 = cur2.next;
		}
		if (cur1 != cur2) {
			return null;
		}
		cur1 = n > 0 ? head1 : head2;
		cur2 = cur1 == head1 ? head2 : head1;
		n = Math.abs(n);
		while (n != 0) {
			n--;
			cur1 = cur1.next;
		}
		while (cur1 != cur2) {
			cur1 = cur1.next;
			cur2 = cur2.next;
		}
		return cur1;
	}

	public static Node bothLoop(Node head1, Node loop1, Node head2, Node loop2) {
		Node cur1 = null;
		Node cur2 = null;
		if (loop1 == loop2) {
			cur1 = head1;
			cur2 = head2;
			int n = 0;
			while (cur1 != loop1) {
				n++;
				cur1 = cur1.next;
			}
			while (cur2 != loop2) {
				n--;
				cur2 = cur2.next;
			}
			cur1 = n > 0 ? head1 : head2;
			cur2 = cur1 == head1 ? head2 : head1;
			n = Math.abs(n);
			while (n != 0) {
				n--;
				cur1 = cur1.next;
			}
			while (cur1 != cur2) {
				cur1 = cur1.next;
				cur2 = cur2.next;
			}
			return cur1;
		} else {
			cur1 = loop1.next;
			while (cur1 != loop1) {
				if (cur1 == loop2) {
					return loop1;
				}
				cur1 = cur1.next;
			}
			return null;
		}
	}

	public static void main(String[] args) {
		// 1->2->3->4->5->6->7->null
		Node head1 = new Node(1);
		head1.next = new Node(2);
		head1.next.next = new Node(3);
		head1.next.next.next = new Node(4);
		head1.next.next.next.next = new Node(5);
		head1.next.next.next.next.next = new Node(6);
		head1.next.next.next.next.next.next = new Node(7);

		// 0->9->8->6->7->null
		Node head2 = new Node(0);
		head2.next = new Node(9);
		head2.next.next = new Node(8);
		head2.next.next.next = head1.next.next.next.next.next; // 8->6
		System.out.println(getIntersectNode(head1, head2).value);

		// 1->2->3->4->5->6->7->4...
		head1 = new Node(1);
		head1.next = new Node(2);
		head1.next.next = new Node(3);
		head1.next.next.next = new Node(4);
		head1.next.next.next.next = new Node(5);
		head1.next.next.next.next.next = new Node(6);
		head1.next.next.next.next.next.next = new Node(7);
		head1.next.next.next.next.next.next = head1.next.next.next; // 7->4

		// 0->9->8->2...
		head2 = new Node(0);
		head2.next = new Node(9);
		head2.next.next = new Node(8);
		head2.next.next.next = head1.next; // 8->2
		System.out.println(getIntersectNode(head1, head2).value);

		// 0->9->8->6->4->5->6..
		head2 = new Node(0);
		head2.next = new Node(9);
		head2.next.next = new Node(8);
		head2.next.next.next = head1.next.next.next.next.next; // 8->6
		System.out.println(getIntersectNode(head1, head2).value);

	}

}
Dcwjh
关注
专栏目录
算法-单链表相交问题
qq_33115589的博客
10-10 426
题目 给定两个可能有环的单链表，头节点head1和head2。 请实现一个函数，如果两个链表相交，请返回相交的第一个节点。如果不相交，返回null。 一、单链表相交的情况 两个无环单链表相交 这种方式可以用线性时间复杂度和常数级的空间时间复制度解决，考虑如上图的情况，可以的得出以下结论 两个无环单链表若相交，那么它们的最后一个结点一定是相等的。 根据这个原理我们，我们只需要遍历到两个链表的最后一个结点，判断其是否相等就能判断两个无环链表是否相交。但是，现在...
单链表的相交
z2766290841的博客
07-18 337
两个不含环的单链表的相交    相交指的是结点的地址相同，而不是结点的值相同                     ************************************************************************/ [cpp] view plain copy typedef struc
单链表相交
天蓝Ada的博客
08-30 257
给定两个单链表的头节点head1和head2，如何判断两个链表是否相交？相交的话返回true，不想交的话返回false。 给定两个链表的头结点head1和head2(注意，另外两个参数adjust0和adjust1用于调整数据,与本题求解无关)。请返回一个bool值代表它们是否相交。 思路：找到两个链表进入环的第一个节点：1、都为空，两个都无环            2、一个为空
两个单链表相交的一系列问题
qq_51654808的博客
09-25 636
两个单链表的相交问题，包含有环和无环的情况，然后用O(1)的空间复杂度解决
链表问题11——两个单链表相交的系列问题(三):判断两个有环链表是否相交
01-08
如果loop1==loop2，我们只需要考虑从链表1的头节点head1到loop1这一段与从链表2的头节点head2到loop2这一段中，在哪里第一次相交，这与问题二，前面一篇文章类似。 如果loop1!=loop2,两个链表有可能相交，也有可能...
算法：求两个单链表相交的第一个节点
Yufail的博客
03-06 1311
判断两个单链表是否相交以及相交的情况下求第一个相交节点，两个链表可以有环，也可以无环。因此我们可以从以下几个步骤分析： 判断一个单链表是否存在环路，如果无环，返回null，反之，返回入环节点。 如果两个单链表均无环，进入相应的子程序，如果无相交，返回null，反之，返回第一个相交节点。 如果一个有环，一个无环，进入相应的子程序，如果无相交，返回null，反之，返回第一个相交节点。 如果两个单链表...
算法题：求两个单链表相交的第一个节点
Luuda0808的博客
09-18 191
算法题：求两个单链表相交的第一个节点
编程之美----链表相交问题
zyq0335的专栏
05-10 5390
1 判断两个链表是否相交(假设两个链表均不带环) 有四种方法： 解法1：直观的想法 判断第一个链表的每个节点是否在第二个链表中，这种方法的时间复杂度为O(length(h1)*length(h2)) 解法2：利用计数的方法 对第一个链表的节点地址进行hash排序，建立hash表，然后针对第二个链表的每个节点的地址查询hash表，如果它在hash表中出现，那么说明两个链表有共同的节点。
单链表反转 链表相交
03-15
实现了一个简单的java版本的单链表，链表反转和链表是否相交如果相交求相交节点。关于链表是否相交是一次阿里的面试的在线试题，挂的很彻底。然后就在网上找了几个实现思路自己用java做了一个简单的实现.MyLinkedList.java 是链表的实现，Main.java 是测试代码
单链表——相交链表
最新发布
wshuoi的博客
12-09 306
相交链表
单链表的相交问题
zyl_1102179268的博客
04-26 603
链表相交问题
单链表相交问题C++
ymhdt的博客
07-12 494
给定两个可能有环也可能无环的单链表，头节点head1和和head2。请实现一个函数，如果两个链表相交，请返回相交的第一个节点。如果不想交，返回null基于这两个链表分别可能有环和无环，基于单链表只能存在一个next指针的特性，我们分成3中情况讨论：则两个链表想要相交，则一定是如下这种形态即两个链表从某个节点开始，存在公共部分，公共部分的第一个节点则为相交节点。由于单链表只能有一个next节点，有环链表的环一定在尾部，而结尾不同的两个链表是无法相交的。所以可以得出结论，不存在这样情况下的相交链表。则两个链表想
两个单链表的相交问题
qq_41980102的博客
04-19 666
两个单链表的相交问题 目录两个单链表的相交问题一、两直链表相交问题二、两成环链表相交问题 下面将会在**时间复杂度为O(N+M)和不使用额外的空间，则空间复杂度为O(1)**的情况下解决： 两个直链表是否相交、有则求相交节点 两个有环的链表是否相交（详解），有则求相交点 一个直链表和一个有环链表（不存在这种情况的相交，后面详解） 一、两直链表相交问题 ​ 暴力循环，时间复杂度O(len1*len2)，空间复杂度O(1)，没遍历一个节点，就遍历另一链表，如果有节点相同（地址相同，地址相同节点的value也
单链表面试题系列之链表相交问题
John的博客
06-13 2059
***单链表面试题系列之链表相交问题*** // 链表相交示意图 /* 判断链表是否相交的问题；（前提两个链表都不带环） 我这里有两种思路： 方法一： 联系前面讲的带环链表问题，我们可以将链表2 链接到链表1的尾部，如果两个链表相交，则必然会带环；这样的话我们就可以通过前面讲的带环链表找入口点的方法去做了； 这里给出链表带
两个单链表相交问题
weixin_30622181的博客
06-16 167
关于两个链表相交，很容易迁移到好多地方，比如： 1.找出两个链表相交的节点； 2.判断单个链表是否有环等； 3.二叉树当存在父指针的时候，求树中两个节点的最近公共祖先； 看一个图： 一下只给出相当一部分思想： 方法一：将两个链表的节点进行hash操作，然后判断出节点，这种想法是可以的。 方法二：当然采用暴力的方法也是可以的，遍历两个链表，在遍历的过程中进行比较，看节点...
单链表--两个单链表相交，输出相交节点
weixin_47311994的博客
08-03 173
目的：如果两个单链表相交，输出他们相交的节点。 实现思路：有两个链表，长链表和短链表，让长链表先走差值步，然后长链表和短链表一起遍历，直到找到相交的节点（两个节点，返回哪个都可以） public Node<T> MeetLink(SingleLink<T> link){ //1.让长链表先走差值步，然后长链表和短链表一起遍历，直到p=q return p int curSize=size; int LinkSize=link.size; int
Java实现单链表相交操作的教程
资源摘要信息:"该资源主要讲解了在Java编程语言下，如何实现单链表的基本操作，特别是如何判断两个单链表是否相交。链表作为一种常见的数据结构，在计算机科学领域有着广泛的应用，尤其在Java等面向对象编程语言中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值