两条单链表的处理问题

一、两个有序链表的公共部分

思路：双指针

public static class Node{
		int value;
		Node next;
		public Node(int value) {
			this.value = value;
		}
	}
	public static void f(Node head1,Node head2) {
		Node first = head1;
		Node second = head2;
		while(first!=null && second!=null) {
			if(first.value < second.value) first= first.next;
			else if(first.value > second.value) second= second.next;
			else {
				System.out.println(first.value+" ");
				first = first.next;
				second = second.next;
			}
		}
	}
	public static void main(String[] args) {
		Node node1 = new Node(2);
		node1.next = new Node(3);
		node1.next.next = new Node(5);
		node1.next.next.next = new Node(6);
		Node node2 = new Node(1);
		node2.next = new Node(2);
		node2.next.next = new Node(5);
		node2.next.next.next = new Node(7);
		node2.next.next.next.next = new Node(8);
		f(node1,node2);
	}

二、判断一个链表是否是回文结构

思路：将链表逆置与原链表比较
逆置方法一：利用栈结构：可以将链表所有元素都压入栈再弹出，也可以将后半部分压入栈再弹出
逆置方法二：可以直接改变链表节点的指向，不用额外的空间开销，在原链表上直接将链表后半部分逆置

方法一实现：

public static boolean isPalind(Node head) {
		Stack<Integer>stack = new Stack<>();
		Node curr = head;
		while(curr != null) {
			stack.push(curr.value);
			curr = curr.next;
		}
		curr = head;
		while(!stack.isEmpty()) {
			if(curr.value != stack.peek()) {
				return false;
			}
			curr = curr.next;
			stack.pop();
		}
		return true;
	}

方法二实现：

	//存储链表后半部分
	public static boolean isPalind(Node head) {
		if (head == null || head.next == null) {
			return true;
		}
		Stack<Integer>stack= new Stack<>();
		Node fast = head.next;
		Node slow = head;
		while(fast!=null && fast.next.next!=null) {
			slow = slow.next;
			fast = fast.next.next;
		}
		while(slow!=null) {
			stack.push(slow.value);
			slow = slow.next;
		}
		slow = head;
		while(!stack.isEmpty()) {
			if(slow.value != stack.peek()) return false;
			slow = slow.next;
			stack.pop();
		}
		return true;
	}

方法三实现：

public static boolean isPalindrome3(Node head) {
		if (head == null || head.next == null) {
			return true;
		}
		Node n1 = head;
		Node n2 = head;
		while (n2.next != null && n2.next.next != null) { // find mid node
			n1 = n1.next; // n1 -> mid
			n2 = n2.next.next; // n2 -> end
		}
		n2 = n1.next; // n2 -> right part first node
		n1.next = null; // mid.next -> null
		Node n3 = null;
		while (n2 != null) { // right part convert
			n3 = n2.next; // n3 -> save next node
			n2.next = n1; // next of right node convert
			n1 = n2; // n1 move
			n2 = n3; // n2 move
		}
		n3 = n1; // n3 -> save last node
		n2 = head;// n2 -> left first node
		boolean res = true;
		while (n1 != null && n2 != null) { // check palindrome
			if (n1.value != n2.value) {
				res = false;
				break;
			}
			n1 = n1.next; // left to mid
			n2 = n2.next; // right to mid
		}
		n1 = n3.next;
		n3.next = null;
		while (n1 != null) { // recover list
			n2 = n1.next;
			n1.next = n3;
			n3 = n1;
			n1 = n2;
		}
		return res;
	}

三、链表的相交问题

情况一：两个无环链表

不可能是X形状，因为单链表只能有一个指针
方法一：哈希，将第一条链表用哈希表存储，遍历第二条链表，找到包含的key就返 回，否则不存在

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

方法二：快慢指针，快指针一次两步，慢指针一次一步，如果有环第一次相遇将快指针返回头结点，然后和慢指针以相同的速度移动，再次相遇的时候就是环入口（这种方法网上有很多详解，大家可以查阅）

方法三：
遍历第一个链表长度为n1，遍历第二个链表长度为n2，长的链表先走|n2-n1|步，然后两个链表一起走，肯定会同时到达相交节点

情况二：一个无环一个有环
这种情况下，不可能存在相交节点，这样肯定有一个节点存在两个指针

情况三：两个有环链表

如何判断是左边还是右边情况？？？
利用两个指针，当他们相遇的时候，其中一个指针A继续往前，另外一个指针B不动，如果A会和B相遇那么就是第二种情况否则是第一种。

小结：

1.利用快慢指针法求出第一条链表的第一个入环节点loop1，第二条链表的第一个入环节点loop2
2.如果loop1null && loopnull 就是两个无环链表的相交问题，遍历链表找出最后一个节点和长度，如果最后一个链表不相等一定不相交，否则可以按上述方法
3.如果一个loop为null，一定不想交
4.判断loop1与loop2是否相等，如果相交就是答案，否则用上述判断是否是66的形式加之判断。