剑指offer-面试题37-两个链表的第一个公共结点

package case37_FindFirstCommonNode;

import java.util.Stack;

/**
 * 题目：输入两个链表，找出他们的第一个公共结点。
 * 
 * @author WangSai
 *
 */
public class FindFirstCommonNode {

	/**
	 * 方法1：
	 * 
	 * 思路：从单链表的尾节点开始寻找，把两个链表分别压入栈stack1和stack2中，然后依次弹出栈，就可以实现从链表尾部开始比较。因为单链表只有一个next引用，
	 * 所以，从第一个公共结点开始就会成Y形。从尾节点开始比较，寻找第一个不相同的地方，即可。
	 * 
	 * @param head1,链表1的头结点
	 * @param head2，链表2的头结点
	 * @return 链表1和链表2的第一个公共结点。
	 */
	private static MyNode getMyFirstCommonNode(MyNode head1, MyNode head2) {
		// 异常值检测
		if (head1 == null || head2 == null)
			return null;
		// 若输入的两个结点为同一个链表的头结点
		if (head1 == head2)
			return head1;
		Stack<MyNode> stack1 = new Stack<>();
		Stack<MyNode> stack2 = new Stack<>();
		MyNode myCommonNode = null;
		// 把链表1压入栈中
		while (head1 != null) {
			stack1.push(head1);
			head1 = head1.next;
		}
		// 把链表2压入栈中
		while (head2 != null) {
			stack2.push(head2);
			head2 = head2.next;
		}
		MyNode stack1Node = stack1.pop();
		MyNode stack2Node = stack2.pop();
		while (!stack1.empty() && !stack2.empty() && stack1Node == stack2Node) {
			myCommonNode = stack1Node;
			stack1Node = stack1.pop();
			stack2Node = stack2.pop();

		}
		return myCommonNode;

	}

	/**
	 * 方法2：
	 * 
	 * 思路：两个链表若有公共结点，则从尾部一定重合。因为单链表只有1个next引用。先分别链表1和链表2，获得两个链表的长度count1和count2，链表长度较长
	 * 的链表，先往前走几步Math.abs（count1-count2）,然后，一起遍历。若有公共结点，则从该结点开始，后面全部重合，呈现Y形。即可获得第一个公共结点。
	 * 
	 * @param head1,链表1的头结点
	 * @param head2，链表2的头结点
	 * @return 链表1和链表2的第一个公共结点。
	 */
	private static MyNode getMyFirstCommonNode2(MyNode head1, MyNode head2) {
		if (head1 == null || head2 == null)
			return null;
		if (head1 == head2)
			return head1;
		MyNode n1 = head1;
		MyNode n2 = head2;
		int count1 = 0, count2 = 0;
		// 遍历链表1，获取元素数量
		while (n1 != null) {
			n1 = n1.next;
			count1++;
		}
		// 遍历链表2，获取元素数量
		while (n2 != null) {
			n2 = n2.next;
			count2++;
		}
		// 元素多的那个链表先开始走几步，然后，当链表剩余的元素相同时，开始比较。
		int dif = count2 - count1;
		while (dif < 0) {
			head1 = head1.next;
			dif++;
		}
		while (dif > 0) {
			head2 = head2.next;
			dif--;
		}
		while (head1 != null && head2 != null && head1 != head2) {
			head1 = head1.next;
			head2 = head2.next;
		}
		// 执行到这一步，有两种情况：
		// 情况1：因为两个元素head1==head2，返回head1即可。
		// 情况2：遍历到最后没有相同的元素。
		if (head1 == head2)
			return head1;
		return null;
	}

	public static void main(String[] args) {
		test1();
		System.out.println("test1()*********** over");
		test2();
		System.out.println("test2()*********** over");
		test3();
		System.out.println("test3()*********** over");
		test4();
		System.out.println("test4()*********** over");
	}

	// 链表1和链表2最后一个结点相同
	// 链表1：head1(0)——>N1(1)——>N2(2)——>N3(3)——>null
	// 链表2：head2(5)——>M1(6)——>M2(7)——>N3(3)——>null
	private static void test1() {
		MyNode head1 = new MyNode(0);
		MyNode N1 = new MyNode(1);
		MyNode N2 = new MyNode(2);
		MyNode N3 = new MyNode(3);
		head1.next = N1;
		N1.next = N2;
		N2.next = N3;

		MyNode head2 = new MyNode(5);
		MyNode M1 = new MyNode(6);
		MyNode M2 = new MyNode(7);
		// MyNode M3 = new MyNode(8);
		head2.next = M1;
		M1.next = M2;
		M2.next = N3;
		System.out.println("链表1:head1(0)——>N1(1)——>N2(2)——>N3(3)——>null:");
		System.out.println("链表2:head2(5)——>M1(6)——>M2(7)——>N3(3)——>null:");
		System.out.println(getMyFirstCommonNode(head1, head2).data);
		System.out.println(getMyFirstCommonNode2(head1, head2).data);

	}

	// 链表1和链表2从第一个结点开始就相同,即输入同一个链表的头结点
	// 链表1：head1(9)——>N1(1)——>N2(2)——>N3(3)——>null
	// 链表2：head1(9)——>N1(1)——>N2(2)——>N3(3)——>null
	private static void test2() {
		MyNode head1 = new MyNode(9);
		MyNode N1 = new MyNode(1);
		MyNode N2 = new MyNode(2);
		MyNode N3 = new MyNode(3);
		head1.next = N1;
		N1.next = N2;
		N2.next = N3;

		System.out.println("链表1:head1(9)——>N1(1)——>N2(2)——>N3(3)——>null:");
		System.out.println("链表2:head1(9)——>N1(1)——>N2(2)——>N3(3)——>null:");
		System.out.println(getMyFirstCommonNode(head1, head1).data);
		System.out.println(getMyFirstCommonNode2(head1, head1).data);

	}

	// 链表1:head1(0)——>N1(1)——>N2(2)——>N3(3)——>null
	// 链表2:head2(5)——>M1(6)——>M2(7)——>M3(8)——>null
	// 没有公共结点
	private static void test3() {
		MyNode head1 = new MyNode(0);
		MyNode N1 = new MyNode(1);
		MyNode N2 = new MyNode(2);
		MyNode N3 = new MyNode(3);
		head1.next = N1;
		N1.next = N2;
		N2.next = N3;

		MyNode head2 = new MyNode(5);
		MyNode M1 = new MyNode(6);
		MyNode M2 = new MyNode(7);
		MyNode M3 = new MyNode(8);
		head2.next = M1;
		M1.next = M2;
		M2.next = M3;
		System.out.println("链表1:head1(0)——>N1(1)——>N2(2)——>N3(3)——>null:");
		System.out.println("链表2:head2(5)——>M1(6)——>M2(7)——>M3(8)——>null:");
		System.out.println(getMyFirstCommonNode(head1, head2));
		System.out.println(getMyFirstCommonNode2(head1, head2));

	}

	// 链表1:head1(0)——>N1(1)——>N2(2)——>N3(3)——>null
	// 链表2:head2(5)——>M1(6)——>N2(2)——>N3(3)——>null
	// 从中部开始相同。
	private static void test4() {
		MyNode head1 = new MyNode(0);
		MyNode N1 = new MyNode(1);
		MyNode N2 = new MyNode(2);
		MyNode N3 = new MyNode(3);
		head1.next = N1;
		N1.next = N2;
		N2.next = N3;

		MyNode head2 = new MyNode(5);
		MyNode M1 = new MyNode(6);
		// MyNode M2 = new MyNode(7);
		// MyNode M3 = new MyNode(8);
		head2.next = M1;
		M1.next = N2;
		System.out.println("链表1:head1(0)——>N1(1)——>N2(2)——>N3(3)——>null:");
		System.out.println("链表2:head2(5)——>M1(6)——>N2(2)——>N3(3)——>null:");
		System.out.println(getMyFirstCommonNode(head1, head2).data);
		System.out.println(getMyFirstCommonNode2(head1, head2).data);

	}
}