Cracking the coding interview--Q2.5

原文：

Given a circular linked list, implement an algorithm which returns node at the beginning of the loop.

DEFINITION

Circular linked list: A (corrupt) linked list in which a node’s next pointer points to an earlier node, so as to make a loop in the linked list.

EXAMPLE

Input: A -> B -> C -> D -> E -> C [the same C as earlier]

Output: C

译文：

给定一个循环链表，实现一个算法返回这个环的开始结点。

定义：

循环链表：链表中一个结点的指针指向先前已经出现的结点，导致链表中出现环。

例子：

输入：A -> B -> C -> D -> E -> C [结点C在之前已经出现过]

输出：结点C

如下图所示：

方法一：

假设链表结点数据主要为a-z英文，则可以使用一个整形变量int，因为int在java中占用32个位，用一个位代表一个字母是否出现过

则遍历当前链表，每个链表数据都判断是否已经出现过，如果没有出现过则标记1出现，直到遍历完毕不存在循环loop或者找到起始点

	/**
	 * 假设Node结点数据只有小写英文字母
	 * 遍历链表数据data，并且通过weight的32位记录出现过的字母。
	 * 当重复出现第二次便为loop的开始点
	 */
	public static char findLoopStartNode(LinkList_5 list) {
		char result = '#';
		int weight = 0;
		
		Node_5 cur = list.head;
		while(cur != null) {
			int curData = (int)cur.data;
			if((weight & (1<<curData)) != 0) {
				result =  cur.data;
				break;
			} else {
				weight |= (1<<curData);
			}
			cur = cur.next;
		}
		return result;
	}

方法二：

《编程之美》中也有讲过。方法很tricky，设置快慢指针， (快指针速度为2，慢指针速度为1)使它们沿着链表移动，如果这个链表中存在环， 那么快指针最终会追上慢指针而指向同一个结点。接下来的问题是，快指针追上慢指针后， 怎么找到这个环的开始结点？ 现在我们还没有答案，那让我们先来分析一下，快指针会在哪里追上慢指针。

其实只要证明快慢指针第一次相遇的地方和head的距离是环长度的整数倍即可:
假设相遇处离环开始点相距x个点，环长度为n个点
慢指针:  k+qn+x=m (1)
又有  2m-m=m=pn (2)
有(1),(2)可得:  k+qn+x=pn
所以k+x = (p-q)n，即相遇处离head的距离为环长的整数倍.
所以将其中一个指针移至head，同时两指针以相同速度再次相遇即为环的开始处.

	/**
	 * 最终两者相遇点距离起始位置正好为 循环loop的整数倍
	 * 此时慢者从头开始，快者原位，两个开始同步骤走动，则相遇点即loop起始点
	 */
	public static char findLoopStartNode2(LinkList_5 list) { 
		Node_5 fast = list.head;
		Node_5 slow = list.head;
		// fast 走两步, slow 走一步
		// 假设不存在Loop
		while(fast != null && fast.next != null) {
			// 第一次走动，判别特殊,头结点算走一步
			if(fast == list.head) {
				fast = list.head.next;
				slow = list.head;
			} else {
				fast = fast.next.next;
				slow = slow.next;
			}
			// 两者相遇
			if(fast == slow) {
				break;
			}
		}
		// 不存在环结构Loop
		if(fast == null && fast.next == null) {
			return '#';
		}
		
		// 两者相遇之后慢者slow从头开始走
		slow = null;
		while(fast != slow) {
			if(slow == null) {
				slow = list.head;
			} else {
				slow = slow.next;
			}
			fast = fast.next;
		}
		return fast.data;
	}

方法三：

java中使用hashMap

	/**
	 * 使用haspMap记录每个元素是否出现过
	 */
	public static char findLoopStartNode3(LinkList_5 list) {
		Map map = new HashMap();
		char result = '#';

		Node_5 cur = list.head;
		while (cur != null) {
			char curData = cur.data;
			// 判断当前结点是否已经出现过
			if(map.containsKey(curData)) {
				result = curData;
				break;
			} 
			map.put(curData, curData);
			cur = cur.next;
		}
		return result;
	}

总代码如下：

package chapter_2_LinkedLists;

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

class Node_5 {
	public char data;
	public Node_5 next;
}

class LinkList_5 {
	public Node_5 head;
}
 
/**
 *
	 给定一个循环链表，实现一个算法返回这个环的开始结点。
	定义：
	循环链表：链表中一个结点的指针指向先前已经出现的结点，导致链表中出现环。
	例子：
	输入：A -> B -> C -> D -> E -> C [结点C在之前已经出现过]
	输出：结点C
 
 */
public class Question_2_5 {
	
	/**
	 * 假设Node结点数据只有小写英文字母
	 * 遍历链表数据data，并且通过weight的32位记录出现过的字母。
	 * 当重复出现第二次便为loop的开始点
	 */
	public static char findLoopStartNode(LinkList_5 list) {
		char result = '#';
		int weight = 0;
		
		Node_5 cur = list.head;
		while(cur != null) {
			int curData = (int)cur.data;
			if((weight & (1<<curData)) != 0) {
				result =  cur.data;
				break;
			} else {
				weight |= (1<<curData);
			}
			cur = cur.next;
		}
		return result;
	}
	
	/**
	 * 最终两者相遇点距离起始位置正好为 循环loop的整数倍
	 * 此时慢者从头开始，快者原位，两个开始同步骤走动，则相遇点即loop起始点
	 */
	public static char findLoopStartNode2(LinkList_5 list) { 
		Node_5 fast = list.head;
		Node_5 slow = list.head;
		// fast 走两步, slow 走一步
		// 假设不存在Loop
		while(fast != null && fast.next != null) {
			// 第一次走动，判别特殊,头结点算走一步
			if(fast == list.head) {
				fast = list.head.next;
				slow = list.head;
			} else {
				fast = fast.next.next;
				slow = slow.next;
			}
			// 两者相遇
			if(fast == slow) {
				break;
			}
		}
		// 不存在环结构Loop
		if(fast == null && fast.next == null) {
			return '#';
		}
		
		// 两者相遇之后慢者slow从头开始走
		slow = null;
		while(fast != slow) {
			if(slow == null) {
				slow = list.head;
			} else {
				slow = slow.next;
			}
			fast = fast.next;
		}
		return fast.data;
	}
	
	/**
	 * 使用haspMap记录每个元素是否出现过
	 */
	public static char findLoopStartNode3(LinkList_5 list) {
		Map map = new HashMap();
		char result = '#';

		Node_5 cur = list.head;
		while (cur != null) {
			char curData = cur.data;
			// 判断当前结点是否已经出现过
			if(map.containsKey(curData)) {
				result = curData;
				break;
			} 
			map.put(curData, curData);
			cur = cur.next;
		}
		return result;
	}
	 
	public static void main(String args[]) {
		Scanner scanner = new Scanner(System.in);
		int num = scanner.nextInt();
		scanner.nextLine();
		while(num-- > 0) {
			LinkList_5 list = new LinkList_5();
			int start = scanner.nextInt();
			scanner.nextLine();
			String str = scanner.nextLine();
			Node_5 cur = null;
			Node_5 loopStart = null;
			
			for(int i=0; i<str.length() -1; i++) {
				Node_5 node = new Node_5();
				node.data = str.charAt(i);
				if((i+1) == start) {
					loopStart = node;
				}
				if(cur == null) {
					list.head = node;
					cur = node;
				} else {
					cur.next = node;
					cur = node;	
				}
			}
			// 最后字符结点不算进去，直接接回循环起点处
			cur.next = loopStart;
			
			char ch = findLoopStartNode3(list);
			if(ch == '#') {
				System.out.format("不存在Loop循环");
			} else {
				System.out.format("Loop循环入口点:%5c", ch);
			}
		}
	}
}

参考自：http://hawstein.com/posts/2.5.html