反转，旋转链表

1.基础问题：反转整个链表
反转一个单链表。
示例:
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL
进阶:
你可以迭代或递归地反转链表。你能否用两种方法解决这道题？
2.问题解法
因为看到了进阶提示，所以我在开始就在思考用递归法求解：
先设置两个指针，temp=head.next，next=temp.next；

先翻转head和temp这两个节点，然后将next当成新链表的首节点进入递归翻转。即重复第一步操作，直到面临递归边界，只剩下一个或两个节点时，这个例子是最后只剩下一个节点的边界。


但面临最后一个单独节点时，不需要翻转，直接返回该节点，递归返回。

递归返回时，将这次递归的翻转节点链接到下一次递归返回来的链表末端，如上图。重复该操作，即可反转整个链表。

代码如下：

/**
 * 链表节点定义
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
public class Solution {
	 public ListNode reverseList(ListNode head) {
	 	//边界条件判断以及特殊情况判断
	        if ( head == null||head.next == null) { 
				return head;
			}
			ListNode temp = head.next, next = temp.next;
			
			if(next==null) {	//最后只剩下两个节点的边界条件判断
				head.next = temp.next;
				temp.next = head;
				head = temp;
				return head;
			}
			
			head.next = temp.next;	//这次递归中的两个节点的反转
			temp.next = head;
			head = temp;

			next = reverseList(next);//下一次递归 

			ListNode finallist = next;	//重新链接
			while (finallist.next != null) {
				finallist = finallist.next;
			}
			head.next.next = null;
			finallist.next = head;
			return next;
	    }
}

这样的解法时间复杂度是O(n)，空间复杂度也是O（n）。（我在leetcode上看了一下运行时间最短的解法，发现比起别人来的我还是差远啦）下面是leetcode的示例代码，这个代码很好的使用了链表的这种数据结构的特性，利用链表的链接和断开，精辟了很多，短短几行就解决了。

 class Solution {
        public ListNode reverseList(ListNode head) {
            ListNode pre = null;
            ListNode curr = head;

            while (curr != null) {
                ListNode temp = curr.next;
                curr.next = pre;
                pre = curr;
                curr = temp;
            }
            return pre;
        }
    }

3.升级版问题：反转部分链表
反转从位置 m 到 n 的链表。请使用一趟扫描完成反转。
说明:
1 ≤ m ≤ n ≤ 链表长度。
示例:
输入: 1->2->3->4->5->NULL, m = 2, n = 4
输出: 1->4->3->2->5->NULL
4.对应解法
其实这个对比上面的只是需要判断m和n的位置，将这两个位置的链表截取就行翻转就可以，大致思路是一致的。截取位置可以利用n-m的差先计算两个位置间的节点个数，然后再利用两个步长不一致的指针（一个先走n-m个节点，一个呆在首节点的位置，再同时走过m个节点）就可以求出了。
代码如下：

public class Solution {
	public ListNode reverseBetween(ListNode head, int m, int n) {
		// 计算节点个数
		int result = n - m;
		ListNode dummy = new ListNode(0), flag = dummy;
		ListNode pre = head, aft = head, temp = null, newlist = null;
		dummy.next = head;

		// 快慢指针
		for (int i = 0; i < result; i++) {
			aft = aft.next;
		}
		for (int i = 1; i < m; i++) {
			flag = flag.next;
			pre = pre.next;
			aft = aft.next;
		}
		// 截取的链表与原链表断开
		temp = aft.next;
		aft.next = null;

		// 重新链接
		newlist = reverseList(pre, aft);
		flag.next = newlist;

		ListNode loc = newlist;
		while (loc.next != null) {
			loc = loc.next;
		}
		loc.next = temp;

		return dummy.next;
	}

	private ListNode reverseList(ListNode pre, ListNode aft) {
		if (pre == aft)
			return pre;
		ListNode temp = pre.next, next = temp.next;
		if (temp == aft) {
			pre.next = temp.next;
			temp.next = pre;
			pre = temp;
			return pre;
		}
		pre.next = temp.next;
		temp.next = pre;
		pre = temp;

		next = reverseList(next, aft);

		ListNode finallist = next;
		while (finallist.next != null) {
			finallist = finallist.next;
		}
		pre.next.next = null;
		finallist.next = pre;
		return next;
	}
}

这个解法只需要遍历一遍链表，甚至都不用遍历完整个链表，时间复杂度是O（n），因为反转是用的递归，所有空间复杂度最大是O（n），最小是O（1）.
5.拓展题目：旋转链表
给定一个链表，旋转链表，将链表每个节点向右移动 k 个位置，其中 k 是非负数。
示例 :
输入: 1->2->3->4->5->NULL, k = 2
输出: 4->5->1->2->3->NULL
解释:
向右旋转 1 步: 5->1->2->3->4->NULL
向右旋转 2 步: 4->5->1->2->3->NULL
6.解法
这个虽然看起来和反转有一定的关系，但是实际解法是不一样的，我这里是先整个链表看成一个闭环，然后根据K来求出新的单向链表的首节点和尾节点。
代码如下：

public class Solution {
	 public ListNode rotateRight(ListNode head, int k) {
	 //特殊情况判断
       if(head==null  || head.next==null)
			 return head;
		 
		 ListNode dummy = new ListNode(0);
		 dummy.next = head;
		 ListNode pre = dummy.next;
		 ListNode end = dummy.next;
		 int len=0,num=0;
		 //通过K来求首节点的位置
		 while(end.next!=null) {
			 end=end.next;
			 len++;
		 }
         len++;
		 if(k>=len) {
			 k=k%len;
		 }
		 num=len-k;
		 for (int i = 1; i < num; i++) {
			pre=pre.next;
		}
		//重新链接
		 end.next=head;
		 dummy.next=pre.next;
		 pre.next=null;
		
		 return dummy.next;
    }
}

这个解法的时间复杂度为O（n），空间复杂度是O（1），只用了一个常量级空间。