剑指Offer系列（15）——反转链表

题目如下：

定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。

 

因为链表是一个单向链表，因此如果我们需要倒序复制的话，很明显是一个后进先出的数据结构，因此第一个很明显的想法就是用栈解决，即将链表顺序存入栈，再弹出即可，代码实现如下：

private static Node reverseList(Node head) {
		//注意特殊情况：传入参数为null
		if (head == null) {
			return null;
		}
		Node tmp = new Node();
	    Node result = tmp;
				
		ArrayDeque<Node> nodeStack = new ArrayDeque<>();
		while (head != null) {
			nodeStack.push(head);
			head = head.getNext();
		}
		Node tmp2 = null;
		while(nodeStack.size() > 0){
			if (tmp2 != null) {
				tmp2.setNext(tmp);
			}
			tmp.setNumber(nodeStack.pop().getNumber());
			//留存tmp ，以便设置next域
			tmp2 = tmp;
			tmp = new Node();
		}
	
		
		return result;
	}

其中Node类定义如下：

class Node{
	public Node(int n){
		this.number = n;
	}
	public Node(){
		this(0);
	}
	private int number;
	private Node next;
	
	public int getNumber() {
		return number;
	}
	public void setNumber(int number) {
		this.number = number;
	}
	public Node getNext() {
		return next;
	}
	public void setNext(Node next) {
		this.next = next;
	}
	@Override
	public String toString() {
		return "Node [number=" + number + "]";
	}
	
}

第二个想法是采用边遍历边复制的想法，我们只需要用两个下标轮换着只是前面的后面的节点构成一对节点和他的next节点关系，最后将最后一个生成的节点返回即可。

这里拿一个节点分别为a ->  b -> c的链表举例：

首先即用before指针指示第一个节点a，拿after节点指示第二个节点b，此时在新的链表中，after的next指向before

再使before节点指向第三个节点c  ，此时在新的链表中，再令before的next域指向after；（这里的before是指向c的新的对象）

此时before是最后一个节点，我们只需返回before即可。

private static Node reverseList2(Node head){

		if (head == null) {
			return null;
		}
		Node before = null;
		Node after = null;
		
		while (head != null) {
			before = new Node();
			before.setNumber(head.getNumber());
			if (after != null) {
				before.setNext(after);
			}
			if (head.getNext() == null) {
				//此时before为最后一个
				return before;
			}
			after = new Node();
			after.setNext(before);
			after.setNumber(head.getNext().getNumber());
			head = head.getNext().getNext();
		}
		//此时after是最后一个
		return after;		
		
	}

最后，要注意以下几种特殊情况的处理：
1.头节点为null         2.链表只有头节点