单向链表每k个元素翻转一次。

有一个单链表，请设计一个算法，使得每K个节点之间逆序，如果最后不够K个节点一组，则不调整最后几个节点。例如链表1->2->3->4->5->6->7->8->null，K=3这个例子。调整后为，3->2->1->6->5->4->7->8->null。因为K==3，所以每三个节点之间逆序，但其中的7，8不调整，因为只有两个节点不够一组。

给定一个单链表的头指针head,同时给定K值，返回逆序后的链表的头指针。

将单向链表完全翻转:

public static ListNode reverse(ListNode start){
ListNode cur= start;
ListNode pre = null;
ListNode next= null;
while(cur!=null){
next = cur.next;
cur.next= pre;
//同步向后移动
pre = cur;
cur = next;
}
return pre;
}每k个元素翻转一次

public class LinkNode {

public static class ListNode {
int val;
ListNode next = null;

ListNode(int val) {
this.val = val;
}

public ListNode() {
// TODO Auto-generated constructor stub
}
}

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
ListNode test = new ListNode(0);
ListNode cur = test;
for (int i = 1; i < 3; i++) {
cur.next=new ListNode(i);
cur = cur.next;
}
ListNode read = new ListNode();
read=inverse(test, 3);
while (read!=null) {
System.out.println(read.val);
read=read.next;
}
}
public static  ListNode inverse (ListNode head,int k){
if(k<2) return head;
ListNode cur=head;
ListNode pre=null;
ListNode start = null;
ListNode next = null;
int count =1 ;
while (cur!=null) {
next= cur.next;
if (count==3) {
start=pre==null?head:pre.next;
//第一次便可以确定头结点，以后头结点保持不变
head=pre==null?cur:head;
//将需要翻转的区间使用pre和right封闭。对区间内部的进行完全链表翻转
//然后将头结点和尾结点与pre和right相连接，保持链表的连续性.
reverse(pre, start, cur, cur.next);
//翻转后的头结点将变成尾结点，作为下一次的pre
pre=start;
//基数器清零
count=0;
}
cur=next;
count++;
}
return head;
}

public static void reverse(ListNode left,ListNode start,ListNode end,ListNode right){
ListNode cur= start;
ListNode pre = left;
ListNode next= null;
while(cur!=right){
next = cur.next;
cur.next= pre;
//同步向后移动
pre = cur;
cur = next;
}
if (left!=null) {
left.next=end;
}
start.next=right;
}

}

参考博客：

JAVA中关于链表的操作和基本算法
http://blog.csdn.net/kerryfish/article/details/24043099 http://blog.csdn.net/w5761499123/article/details/61616910