剑指Offer面试题37：两个链表的第一个公共节点

最新推荐文章于 2021-09-11 00:24:13 发布
最新推荐文章于 2021-09-11 00:24:13 发布
阅读量346 收藏
点赞数
分类专栏： 算法 面试题 文章标签： java 剑指offer 算法 面试题 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gg543012991/article/details/52651260
版权

以下内容参考自博客：http://blog.csdn.net/derrantcm/article/details/46761093

题目：两个链表的第一个公共节点
        输入两个链表，找出他们的第一个公共节点。
算法分析：
算法1.直接法
在链表上顺序遍历每个节点，每遍历一个节点的时候，在第二个链表上顺序遍历每个节点。如果在第二个链表上有一个节点和第一个链表上的节点相同，说明两个链表在这个节点上重合，于是就找到了他们的公共节点。如果第一个链表的长度为m,第二个链表的长度为n，显然该方法的时间复杂度为O（mn）.

算法2.使用栈
由于两个链表是单向链表，因此从某一节点开始，他们的pNext都指向了下一节点，但由于是单向链表，每个节点只有一个pNext，因此从第一个公共节点开始后，他们的所有节点都是重合的，不可能再出现分叉。所以两个有公共节点的链表，拓扑形状看起来像Y，而不是X。
 

如果存在共同节点的话，那么从该节点起，两个链表之后的元素都是相同的。也就是说两个链表从尾部往前到某个点，节点都是一样的。我们可以用两个栈分别来装这两条链表。这样两个链表的尾节点有位于两个栈的栈顶，接下来比较两个栈顶节点是否相同。如果相同，则把栈顶弹出，接着比较下一个栈顶，直到找到最后一个相同的节点。
在上述思想中，我们需要用到两个辅助栈，如果两个链表的长度分别为m和n的话，那个空间复杂度为O（m+n）。这种思想的时间复杂度也是O（m+n）。和最开始的直接法相比，时间效率得到了提高，相当于用时间效率换取了空间效率。

算法3.先行法 
首先遍历两个链表得到他们的长度，就能知道那个链表比较长，以及长的链表比短的链表多几个节点。在第二次遍历的时候，在较长的链表上先走若干步，接着再同时在两个链表上遍历，找到的第一个相同的节点就是他们的第一个公共节点。
这种思想的时间复杂度也是O（m+n），但我们不再需要辅助栈，因此提高了空间的效率。

算法4.使用哈希表
利用hash表的特点，想将链表1放入hashMap中，并设置每个键对应的值为空（因为这里不需要用到hashMap的值），然后循环第二个链表，判断第二个链表的每一个节点在hashMap中是否都存在相同的键，如果是，则表明找到 了第一个相同的节点，返回该节点，即返回了第一个相同的公共节点。
遇到的问题：
1.一个警告：The static method test3() from the type Solution should be accessed in a static way
*             原因：静态方法在对象创建前就存在了，它的使用不依赖对象是否被创建，所以可以用"类.方法"的方式调用，而不需要使用“对象.方法”的方式进行调用。
2.Java中单向链表的建立：
private static class ListNode{
        int val;
        ListNode next;
        /*public ListNode(){            //无参构造函数，可以不写，下文没有用到
            
        }*/
        public ListNode(int val){
            this.val = val;
        }
        @Override
        public String toString(){
            return val + "";
        }
    }  
增加链表中成员的方法：
1-2-3\
       6-7
   4-5/
   
        ListNode n1 = new ListNode(1);
        ListNode n2 = new ListNode(2);
        ListNode n3 = new ListNode(3);
        ListNode n4 = new ListNode(4);
        ListNode n5 = new ListNode(5);
        ListNode n6 = new ListNode(6);
        ListNode n7 = new ListNode(7);
        
        n1.next = n2;
        n2.next = n3;
        n3.next = n6;
        n6.next = n7;
        
        n4.next = n5;
        n5.next = n6;  
算法参考：http://blog.csdn.net/derrantcm/article/details/46761093
3、得到链表长度：
private static int getListLength(ListNode head){
        int result = 0;
        while(head != null){
            result++;
            head = head.next;
        }
        return result;
    }  
算法2源程序： 
/**************************************************************      
* Copyright (c) 2016, 
* All rights reserved.                   
* 版 本 号：v1.0                   
* 题目描述：两个链表的第一个公共节点
*   	       输入两个链表，找出他们的第一个公共节点。
*   		1-2-3\
			  	  6-7
		  	  4-5/
* 			例如，该链表的第一个公共节点为6。
* 输入描述：无
* 程序输出：找到的第一个公共节点是：6
*			找到的第一个公共节点是：null
*			找到的第一个公共节点是：7
*			找到的第一个公共节点是：1
*
* 问题分析： 1.一个警告：The static method test3() from the type Solution should be accessed in a static way
* 			原因：静态方法在对象创建前就存在了，它的使用不依赖对象是否被创建，所以可以用"类.方法"的方式调用
* 			2.单向链表的生成方法：详见程序
* 			3.得到链表长度：详见程序
* 算法描述：首先遍历两个链表得到他们的长度，就能知道那个链表比较长，以及长的链表比短的链表多几个节点。
* 			在第二次遍历的时候，在较长的链表上先走若干步，接着再同时在两个链表上遍历，找到的第一个相同的节点就是他们的第一个公共节点。
*			这种思想的时间复杂度也是O（m+n），但我们不再需要辅助栈，因此提高了空间的效率。

* 完成日期：2016-09-24
***************************************************************/ 

package org.marsguo.offerproject37;
class Solution{
	/*
	链表节点类
	*/
	private static class ListNode{			//ListNode被声明为了内部类
		int val;
		ListNode next;
		/*public ListNode(){			//无参构造函数，可以不写，下文没有用到
			
		}*/
		public ListNode(int val){
			this.val = val;
		}
		@Override
		public String toString(){
			return val + "";
		}
	}
	 /**
     * 找两个结点的第一个公共结点，如果没有找到返回null，方法比较好，考虑了两个链表中有null的情况
     *
     * @param head1 第一个链表
     * @param head2 第二个链表
     * @return 找到的公共结点，没有返回null
     */
	public static ListNode findFirstCommonNode(ListNode head1,ListNode head2){
		int length1 = getListLength(head1);				//得到两个链表的长度
		int length2 = getListLength(head2);
		
		int diff = length1 - length2;
		ListNode longListHead = head1;				//现在还不能确定head1就是长链表，head2就是短链表，但可通过下一步确定。
		ListNode shortListHead = head2;
		
		if(diff < 0){					//如果head1短head2长则调换两个头指针的指向，非常好
			longListHead = head2;
			shortListHead = head1;
			diff = length2 - length1;
		}
		for(int i = 0; i < diff; i++){			//让长的链表先走diff步，之后两个链表指针在同时移动，
			longListHead = longListHead.next;
		}
		/*
		while循环用于找到第一个相同的公共节点，如果没有则不断找向下一个节点，直到找到后退出循环
		*/
		while(longListHead != null && shortListHead != null && longListHead != shortListHead){
			longListHead = longListHead.next;				
			shortListHead = shortListHead.next;
		}
		
		return longListHead;			//返回第一个相同的公共节点，如果没有返回null;
	}
	/*
	得到单向链表长度
	*/
	private static int getListLength(ListNode head){
		int result = 0;
		while(head != null){
			result++;
			head = head.next;
		}
		return result;
	}
	
	public static void test1(){
		/*
		第一个公共节点在链表的中间
		1-2-3\
			  6-7
		  4-5/
		  */
		ListNode n1 = new ListNode(1);
		ListNode n2 = new ListNode(2);
		ListNode n3 = new ListNode(3);
		ListNode n4 = new ListNode(4);
		ListNode n5 = new ListNode(5);
		ListNode n6 = new ListNode(6);
		ListNode n7 = new ListNode(7);
		
		n1.next = n2;
		n2.next = n3;
		n3.next = n6;
		n6.next = n7;
		
		n4.next = n5;
		n5.next = n6;
		
		System.out.print("找到的第一个公共节点是：");
		System.out.println(findFirstCommonNode(n1, n4));			//返回6
		
	}
	
	public static void test2(){
		/*
		没有公共节点
		1-2-3-4
			
		5-6-7
		  */
		ListNode n1 = new ListNode(1);
		ListNode n2 = new ListNode(2);
		ListNode n3 = new ListNode(3);
		ListNode n4 = new ListNode(4);
		ListNode n5 = new ListNode(5);
		ListNode n6 = new ListNode(6);
		ListNode n7 = new ListNode(7);
		
		n1.next = n2;
		n2.next = n3;
		n3.next = n4;
		
		n5.next = n6;
		n6.next = n7;
		
		System.out.print("找到的第一个公共节点是：");
		System.out.println(findFirstCommonNode(n1, n5));			//返回null
	}
	
	public static void test3(){
		/*
		公共节点是最后一个节点
		1-2-3-4\
				7
			5-6/
		*/
		ListNode n1 = new ListNode(1);
		ListNode n2 = new ListNode(2);
		ListNode n3 = new ListNode(3);
		ListNode n4 = new ListNode(4);
		ListNode n5 = new ListNode(5);
		ListNode n6 = new ListNode(6);
		ListNode n7 = new ListNode(7);
		
		n1.next = n2;
		n2.next = n3;
		n3.next = n4;
		n4.next = n7;
		
		n5.next = n6;
		n6.next = n7;
		
		System.out.print("找到的第一个公共节点是：");
		System.out.println(findFirstCommonNode(n1, n5));			//返回7
	}
	
	public static void test4(){
		/*
		公共节点是第一个节点
		1-2-3-4-5
		两个链表完全重合
		*/
		ListNode n1 = new ListNode(1);
		ListNode n2 = new ListNode(2);
		ListNode n3 = new ListNode(3);
		ListNode n4 = new ListNode(4);
		ListNode n5 = new ListNode(5);
		ListNode n6 = new ListNode(6);
		ListNode n7 = new ListNode(7);
		
		n1.next = n2;
		n2.next = n3;
		n3.next = n4;
		n4.next = n5;
		n5.next = n6;
		n6.next = n7;
		
		System.out.print("找到的第一个公共节点是：");
		System.out.println(findFirstCommonNode(n1, n1));			//返回7
	}
}
public class FirstCommonNode {
	public static void main(String[] args){
		//Solution solution = new Solution();
		
		Solution.test1();
		Solution.test2();
		Solution.test3();
		//solution.test3();			//The static method test3() from the type Solution should be accessed in a static way
		Solution.test4();
	}
}

算法3源程序： 
/**************************************************************      
* Copyright (c) 2016, 
* All rights reserved.                   
* 版 本 号：v1.0                   
* 题目描述：两个链表的第一个公共节点
*   	       输入两个链表，找出他们的第一个公共节点。
*   		1-2-3\
			  	  6-7
		  	  4-5/
* 			例如，该链表的第一个公共节点为6。
* 输入描述：无
* 程序输出：找到的第一个公共节点是：6
*			找到的第一个公共节点是：null
*			找到的第一个公共节点是：7
*			找到的第一个公共节点是：1
*
* 问题分析： 1.一个警告：The static method test3() from the type Solution should be accessed in a static way
* 			原因：静态方法在对象创建前就存在了，它的使用不依赖对象是否被创建，所以可以用"类.方法"的方式调用
* 			2.单向链表的生成方法：详见程序
* 			3.得到链表长度：详见程序
* 			4.在Method1方法中，ListNode类被声明为了private，所以这里不能通过导入包的方式调用
* 算法描述：如果存在共同节点的话，那么从该节点起，两个链表之后的元素都是相同的。也就是说两个链表从尾部往前到某个点，
* 			节点都是一样的。我们可以用两个栈分别来装这两条链表。这样两个链表的尾节点有位于两个栈的栈顶，
* 			接下来比较两个栈顶节点是否相同。如果相同，则把栈顶弹出，接着比较下一个栈顶，直到找到最后一个相同的节点。

* 完成日期：2016-09-24
***************************************************************/

package org.marsguo.offerproject37;

import java.util.Stack;

//import org.marsguo.offerproject37.Solution.ListNode;

//import org.marsguo.offerproject37.Solution.ListNode;  	//在Method1方法中，ListNode类被声明为了private，所以这里不能通过导入包的方式调用

class Solution_Method2{
	
	public static class ListNode{
		int val;
		ListNode next;
		public ListNode(){			//无参构造函数，可以不写，下文没有用到
			
		}
		public ListNode(int val){
			this.val = val;
		}
		@Override
		public String toString(){
			return val + "";
		}
	}
	
	public static ListNode FindFirstCommonNode(ListNode head1,ListNode head2){
		if(head1 == null || head2 == null){
			return null;
		}
		/*
		用栈存储ListNode
		*/
		Stack<ListNode> stack1 = new Stack<>();			
		Stack<ListNode> stack2 = new Stack<>();
		
		while(head1 != null){
			stack1.push(head1);			//将链表1的内容压入栈
			head1 = head1.next;
		}
		
		while(head2 != null){
			stack2.push(head2);			//将链表2的内容压入栈
			head2 =head2.next;
		}
		
		ListNode commonListNode = null;		//共同节点标志位，初始值设为空
		/*
		用stack1的栈顶元素和stack2每次出栈元素相比较，如果相同，则stack1出栈，并把
		出栈元素赋给commonListNode
		*/
		while(!stack1.isEmpty() && !stack2.isEmpty() && stack1.peek() == stack2.pop()){
			commonListNode = stack1.pop();
		}
		return commonListNode;
	}
	
	public static void test1(){
		/*
		第一个公共节点在链表的中间
		1-2-3\
			  6-7
		  4-5/
		  */
		ListNode n1 = new ListNode(1);
		ListNode n2 = new ListNode(2);
		ListNode n3 = new ListNode(3);
		ListNode n4 = new ListNode(4);
		ListNode n5 = new ListNode(5);
		ListNode n6 = new ListNode(6);
		ListNode n7 = new ListNode(7);
		
		n1.next = n2;
		n2.next = n3;
		n3.next = n6;
		n6.next = n7;
		
		n4.next = n5;
		n5.next = n6;
		
		System.out.print("找到的第一个公共节点是：");
		System.out.println(FindFirstCommonNode(n1, n4));			//返回6
		
	}
	
	public static void test2(){
		/*
		没有公共节点
		1-2-3-4
			
		5-6-7
		  */
		ListNode n1 = new ListNode(1);
		ListNode n2 = new ListNode(2);
		ListNode n3 = new ListNode(3);
		ListNode n4 = new ListNode(4);
		ListNode n5 = new ListNode(5);
		ListNode n6 = new ListNode(6);
		ListNode n7 = new ListNode(7);
		
		n1.next = n2;
		n2.next = n3;
		n3.next = n4;
		
		n5.next = n6;
		n6.next = n7;
		
		System.out.print("找到的第一个公共节点是：");
		System.out.println(FindFirstCommonNode(n1, n5));			//返回null
	}
	
	public static void test3(){
		/*
		公共节点是最后一个节点
		1-2-3-4\
				7
			5-6/
		*/
		ListNode n1 = new ListNode(1);
		ListNode n2 = new ListNode(2);
		ListNode n3 = new ListNode(3);
		ListNode n4 = new ListNode(4);
		ListNode n5 = new ListNode(5);
		ListNode n6 = new ListNode(6);
		ListNode n7 = new ListNode(7);
		
		n1.next = n2;
		n2.next = n3;
		n3.next = n4;
		n4.next = n7;
		
		n5.next = n6;
		n6.next = n7;
		
		System.out.print("找到的第一个公共节点是：");
		System.out.println(FindFirstCommonNode(n1, n5));			//返回7
	}
	
	public static void test4(){
		/*
		公共节点是第一个节点
		1-2-3-4-5
		两个链表完全重合
		*/
		ListNode n1 = new ListNode(1);
		ListNode n2 = new ListNode(2);
		ListNode n3 = new ListNode(3);
		ListNode n4 = new ListNode(4);
		ListNode n5 = new ListNode(5);
		ListNode n6 = new ListNode(6);
		ListNode n7 = new ListNode(7);
		
		n1.next = n2;
		n2.next = n3;
		n3.next = n4;
		n4.next = n5;
		n5.next = n6;
		n6.next = n7;
		
		System.out.print("找到的第一个公共节点是：");
		System.out.println(FindFirstCommonNode(n1, n1));			//返回7
	}
}

public class FindFirstCommonMethod2 {
	public static void main(String[] args){
		Solution.test1();
		Solution.test2();
		Solution.test3();
		Solution.test4();
	}
}

算法4源程序： 
/**************************************************************      
* Copyright (c) 2016, 
* All rights reserved.                   
* 版 本 号：v1.0                   
* 题目描述：两个链表的第一个公共节点
*   	       输入两个链表，找出他们的第一个公共节点。
*   		1-2-3\
			  	  6-7
		  	  4-5/
* 			例如，该链表的第一个公共节点为6。
* 输入描述：无
* 程序输出：找到的第一个公共节点是：6
*			找到的第一个公共节点是：null
*			找到的第一个公共节点是：7
*			找到的第一个公共节点是：1
*
* 问题分析： 1.一个警告：The static method test3() from the type Solution should be accessed in a static way
* 			原因：静态方法在对象创建前就存在了，它的使用不依赖对象是否被创建，所以可以用"类.方法"的方式调用
* 			2.单向链表的生成方法：详见程序
* 			3.得到链表长度：详见程序
* 			4.在Method1方法中，ListNode类被声明为了private，所以这里不能通过导入包的方式调用
* 算法描述：使用哈希表

* 完成日期：2016-09-24
***************************************************************/

package org.marsguo.offerproject37;

import java.util.HashMap;

import org.marsguo.offerproject37.Solution_Method2.ListNode;		//调用该包下的ListNode节点。

class Solution_HashMap{
	public static ListNode FindFirstCommonNode(ListNode head1,ListNode head2){
		ListNode current1 = head1;
		ListNode current2 = head2;
		
		HashMap<ListNode,Integer> hashMap = new HashMap<ListNode,Integer>();
		while(current1 != null){
			hashMap.put(current1, null);		//将链表值分别放入Hash表中，值都设为空
			current1 = current1.next;
		}
		while(current2 != null){
			/*
			判断hash表中是否有和链表2相同的键，有则返回该键，该键即为第一个相同的节点
			*/
			if(hashMap.containsKey(current2))		//hashMap.containsKey():判断一个Map中是否包含指定Key的key-value键值对存在。
				return current2;
			current2 = current2.next;
		}
		
		return null;
	}
	
	public static void test1(){
		/*
		第一个公共节点在链表的中间
		1-2-3\
			  6-7
		  4-5/
		  */
		ListNode n1 = new ListNode(1);
		ListNode n2 = new ListNode(2);
		ListNode n3 = new ListNode(3);
		ListNode n4 = new ListNode(4);
		ListNode n5 = new ListNode(5);
		ListNode n6 = new ListNode(6);
		ListNode n7 = new ListNode(7);
		
		n1.next = n2;
		n2.next = n3;
		n3.next = n6;
		n6.next = n7;
		
		n4.next = n5;
		n5.next = n6;
		
		System.out.print("找到的第一个公共节点是：");
		System.out.println(FindFirstCommonNode(n1, n4));			//返回6
		
	}
	
	public static void test2(){
		/*
		没有公共节点
		1-2-3-4
			
		5-6-7
		  */
		ListNode n1 = new ListNode(1);
		ListNode n2 = new ListNode(2);
		ListNode n3 = new ListNode(3);
		ListNode n4 = new ListNode(4);
		ListNode n5 = new ListNode(5);
		ListNode n6 = new ListNode(6);
		ListNode n7 = new ListNode(7);
		
		n1.next = n2;
		n2.next = n3;
		n3.next = n4;
		
		n5.next = n6;
		n6.next = n7;
		
		System.out.print("找到的第一个公共节点是：");
		System.out.println(FindFirstCommonNode(n1, n5));			//返回null
	}
	
	public static void test3(){
		/*
		公共节点是最后一个节点
		1-2-3-4\
				7
			5-6/
		*/
		ListNode n1 = new ListNode(1);
		ListNode n2 = new ListNode(2);
		ListNode n3 = new ListNode(3);
		ListNode n4 = new ListNode(4);
		ListNode n5 = new ListNode(5);
		ListNode n6 = new ListNode(6);
		ListNode n7 = new ListNode(7);
		
		n1.next = n2;
		n2.next = n3;
		n3.next = n4;
		n4.next = n7;
		
		n5.next = n6;
		n6.next = n7;
		
		System.out.print("找到的第一个公共节点是：");
		System.out.println(FindFirstCommonNode(n1, n5));			//返回7
	}
	
	public static void test4(){
		/*
		公共节点是第一个节点
		1-2-3-4-5
		两个链表完全重合
		*/
		ListNode n1 = new ListNode(1);
		ListNode n2 = new ListNode(2);
		ListNode n3 = new ListNode(3);
		ListNode n4 = new ListNode(4);
		ListNode n5 = new ListNode(5);
		ListNode n6 = new ListNode(6);
		ListNode n7 = new ListNode(7);
		
		n1.next = n2;
		n2.next = n3;
		n3.next = n4;
		n4.next = n5;
		n5.next = n6;
		n6.next = n7;
		
		System.out.print("找到的第一个公共节点是：");
		System.out.println(FindFirstCommonNode(n1, n1));			//返回7
	}
}
public class FindNodeHashMapMethod {
	public static void main(String[] args){
		Solution_HashMap.test1();
		Solution_HashMap.test2();
		Solution_HashMap.test3();
		Solution_HashMap.test4();
	}
}

程序运行结果：



安心写代码吧
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】-单链表-求两个单链表的公共节点
vector的博客
06-12 503
typedef struct LNode{ int data; struct LNode *next; }LNode, *LinkList; /*链表*/ LinkList List_TailInsert(LinkList L) { int x; L = (LinkList)malloc(sizeof(LNode)); L->next = NULL; LNode *s, *r = L; cout << "尾插法创建单链表："; while (true) { ci...
两个链表的第一个公共结点（双指针法、异步走法 ）
PingBryant的博客
03-23 348
题目 输入两个链表，找出它们的第一个公共结点。 当不存在公共节点时，返回空节点。 样例 给出两个链表如下所示： A： a1 → a2 ↘ c1 → c2 → c3 ↗ B: b1 → b2 → b3 输出第一个公共节点c1 题解 1. 用两个指针 p1，p2 分别指向两个链表的头结点 headA，headB ，同时向后遍历。 2.
Leetcode 剑指 Offer 52. 两个链表的第一个公共节点
weixin_43891775的博客
03-07 92
Leetcode 剑指 Offer 52. 两个链表的第一个公共节点 题目 输入两个链表，找出它们的第一个公共节点。 如下面的两个链表： 在节点 c1 开始相交。 示例 1： 输入：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）。从各自的
剑指 offer 52 两个链表的第一个公共节点（双指针）
Y_M的博客
07-26 174
1 题目描述 2 算法思路 思路： 用两个指针A，B分别指向两个链表的头，然后以相同的速度遍历，如果指针到了末尾，就从对方的头再来 由题目可知，链表不存在循环，因此只要存在交点，就一定可以通过这种追赶的方式找到。 两个链表长度分别为L1+C、L2+C， C为公共部分的长度，按照楼主的做法： 第一个人走了L1+C步后，回到第二个人起点走L2步；第2个人走了L2+C步后，回到第一个人起点走L1步。 当两个人走的步数都为L1+L2+C时就两个家伙就相爱了 如果不存在，那么最后，no.
两个链表的第一个公共结点（双指针法）——剑指Offer
weixin_38933749的博客
05-12 141
题目描述 输入两个链表，找出它们的第一个公共结点。 （注意因为传入数据是链表，所以错误测试数据的提示是用其他方式显示的，保证传入数据是正确的） 题目分析 连接两个链表，使两个链表的长度相等，当遇到第一个相同的结点，直接返回该结点。 代码 C++代码如下： /* struct ListNode { int val; struct ListNode *next; ListNode(int x) : val(x), next(NULL) { } };*/ class Solution { publi
【JZ-52】两个链表的第一个公共节点（链表、双指针）
子木_98的博客
03-21 149
目录题目解题思路具体代码复杂度分析 题目 解题思路 双指针法 创建两个指针pA和pB，分别初始化为链表A和B的头结点，然后向后逐节点遍历。 当pA到达链表A尾部时，将其重定位到链表B的头结点；类似的，当pB到达链表B尾部时，将其重定位到链表A的头结点。 若某一时刻pA和pB相遇，则该节点就是第一个公共结点。 若两个链表存在相交，则末尾结点必然相同，因此当pA/pB到达链表结尾时，记录下链表A/B对应的元素，不相同则说明两个链表不相交。 原理： A和B两个链表长度可能不同，但是A+B和B+A的长度是相同
求两个单链表的公共节点
zhaokunhnu的博客
03-20 601
/*public class ListNode {    int val ;    ListNode next=null;    public void setVal(int val) {        this.val = val;    }    } */import java.util.Stack;/** *  * @author zhaokun *    两个链表的第一个公共点  第一个之...
查找两个单链表的公共节点
许你一片梁城的博客
09-18 4752
查找两个单链表的公共节点 算法思路：首先要明白单链表有公共节点的情况是什么，因为单链表中每个节点的next指针是唯一的，所以当存在公共节点的时候，其后面的所有节点也都是相同的，所以这是的链表是一个“Y”，而不是我们惯性思维想到的“X”。根据这个结论可知，如果两个链表存在公共节点的话，它们的尾结点也肯定是相同的。 明白了有公共节点的链表构造之后就好办了，假设两个链表的长度分别是 len1 和 len2 第一种暴力方法：遍历第一个链表的节点，每个节点都再遍历第二个链表的所有节点，...
查找两个单链表的公共结点
qq_61706112的博客
09-11 411
/*给定两个单链表，编写算法找出两个链表的公共结点*/ #include<stdio.h> #include<stdlib.h> typedef int ElemType; typedef struct LNode { ElemType data; struct LNode *next; }LNode,*LinkList; LinkList TailCreateList(LinkList &L) { L = (LinkList)malloc(sizeof(LNode.
小白算法积累——单链表8#两个单链表的公共节点
aprilzj123的博客
02-18 865
题目：给定两个单链表，编写算法找出两个链表的公共结点 关键字：两个链表+查找公共节点 思路 关注：递归算法的设计重点在于找到“递归”的部分，即重复调用函数，改变部分相关变量 设f(L,x)的功能是：删除以L为首结点指针的单链表中所有值等于x的结点，显然有f(L->next,x) 1.通用逆置函数:遍历循环+头尾元素互换 需要变量：L, 相对头尾结点下标：from, to 逆置截止结点下标：&...
王道408 数据结构之 给定两个单链表，编写算法找出两个链表的公共节点
qq_40066238的博客
07-14 2840
基本思想 所谓找出两个单链表的公共节点，就是将链表相交的部分的第一个节点找出来，此节点后的所有节点都是公共节点。 如图，链表A的5个节点分别为a1,a2,c1,c2,c3，链表B的6个节点分别为b1,b2,b3,c1,c2,c3（注意此处没有考虑虚拟头节点的存在） 显然，从c1开始它们便不可能再出现分支，我们的算法也应当返回c1的地址。 当A、B的长度相同时，找出c1非常简单，只要我们设置两个指针curA, curB同时指向A、B的第一个数据节点，并依次比较两个指针指向的地址值是否相同，最终一定会在c1处
俩个单链表第一个公共节点
qq_42199781的博客
08-19 194
如题，题目要求找寻俩个单链表的第一个公共节点，如果有公共节点，则返回这个公共节点，否则返回None 首先，分析问题，单链表如果有公共节点，即肯定是这样的 常规做法：首先看哪个链表长，长链表先走（他们的差）步，然后再一起遍历，有公共节点则返回，没有返回None，但是这种太麻烦了，你还得分别遍历俩个链表，分别求其长度，求到长度以后，然后再开始遍历。有兴趣的写一下吧。 今天要介绍的这种方法，很简洁。 ...
两个单链表的第一个公共节点
小景的博客
08-23 190
https://www.nowcoder.com/practice/6ab1d9a29e88450685099d45c9e31e46?tpId=13&rp=1&ru=%2Fta%2Fcoding-interviews&qru=%2Fta%2Fcoding-interviews%2Fquestion-ranking 一、问题描述 输入两个链表，找出它们的第一个公共结点。（注意因为传入数据是链表，所以错误测试数据的提示是用其他方式显示的，保证传入数据是正确的） 二、代码..
求两个单链表的第一个公共节点
weixin_43086349的博客
03-02 281
两个链表的第一个公共节点
【剑指offer】面试题37-两个单链表的第一个公共结点
天涯海角
01-22 988
问题描述：输入两个链表，找出链表的第一个公共结点。问题分析：方法1：粗暴的办法。 从一个链表的第一个结点开始，再另一个链表上查找是否是交点（指向结点的指针一样），这样的话，如果一个链表的长度是m，另一个链表的长度是n，则时间复杂度是O（mn）。 方法2： 我们知道链表相交，不仅仅只是结点里的data值一样，next指针也是一样的，也就是说，如果两个链表从某一个结点处开始相交，那么之后两个链表一
C语言 寻找两个单链表的公共节点实现与原理
qq_41740162的博客
04-06 2222
两个单链表,找出两个链表的公共节点公共节点的定义``如果对您有帮助,请点个攒呗``实现思想方法一方法二实现代码结构体功能函数运行截图``欢迎大家在评论区赐教,谢谢`` 公共节点的定义 有的同学在第一次看到这个题目的时候,以为公共节点,就是两个链表中节点的数据相等如下图 很大一部分同学认为红色框框里面的就是相同节点,其实不然,正确的是这样子的 如果对您有帮助,请点个攒呗 两个链表指向相同地址的节...
【链表】C++两个链表的公共结点
HiPricilla的博客
07-17 2339
题目：（剑指offer编程题）输入两个单向链表，找出它们的第一个公共结点。 公共结点是地址相同的两个结点，也就是同一个结点，由于是单向链表，所有从公共结点之后两链表重合。 思路： 方法1：最容易想到的办法是用两个循环，遍历第一个链表，对每一个元素遍历第二个链表，找相同的结点。这种算法时间复杂度为O(mn)（假设链表长度分别为m和n），不适用这种方法。 方法2：如果两个链表有公共结点，那
两个链表的第一个公共节点
JJ_HH
06-10 222
package com.dugstudio.SwordToOfferBook.Singleton.Interview; /** * @Author JH * @CreateDate 18-6-10 * @Description 两个链表的第一个公共节点 */ public class FindFirstCommonNode { public ListNode FindFirstC...
求两个链表的第一个公共节点
Medlen
03-12 1499
题目描述 输入两个链表，找出它们的第一个公共结点。 做法有两种： 1、利用HashSet，先将第一个链表中所有节点放入，Set集合中，然后遍历第二个链表，找出第一个和Set集合中匹配的节点。时间复杂度为O(n) 2、利用特性，因为两个链表有公共节点，那么从公共节点开始，他们后面的所有节点数目是一致的。所以，让较长链表先走length长度，直到两个链表的剩余节点数目一致，然后两个链表一起走，直到找到...
《剑指Offer》精华思路总结：42道经典算法题
8. **两个链表的第一个公共节点**：双指针法，分别从两个链表的头开始遍历。 ### 四、树和二叉树 1. **重建二叉树**：根据前序遍历和中序遍历或后序遍历和中序遍历重建树。 2. **二叉树的下一个节点**：通过右孩子...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值