分段反转链表java_最全，最简洁，java单链表反转，按k反转等

1，反转整个链表

下面的代码都没有判断头节点为空的情况，所以如果是实际开发中使用，请#####自行添加逻辑

int[] arr = {1, 123, 22, 34, 55, 6, 77, 324, 213, 11, 333, 434};

//节点对象

static class Node {

int content;

Node next;

}

//添加节点

void addNode(int content) {

Node node = new Node();

node.content = content;

node.next = headNode;

headNode = node;

}

//打印所有节点内容

void printNode() {

Node p = headNode;

while (p != null) {

System.out.print(p.content + ", ");

p = p.next;

}

}

Node headNode = null;

public static void main(String[] arr) {

int[] arr = {1, 123, 22, 34, 55, 6, 77, 324, 213, 11, 333, 434};

for (int i = arr.length-1; i >=0; i--) {

addNode(arr[i]);

}

printNode();

System.out.println("-");

headNode = revertNode1(headNode);

// headNode = revertNode2(headNode);

// headNode = revertNode3(headNode,null);

printNode();

}

//记录3个节点的方法，分别记录当前节点，正在操作节点，

//和下一个节点因为单链表只有一个方向，所以在断开两个节点

//的链接之前必须先把下一个节点记录一下。

Node revertNode1(Node start){

Node pre = null;

Node now = start;

Node next;

while (now != null) {

//先记录下一个节点

next = now.next;

//将当前节点跟下一个节点断开，并指向上一个节点

now.next = pre;

//相当于移位操作，把当前节点和上一个节点向下移位

pre = now;

now = next;

}

//now节点现在为null，所以pre是以前的最后一个节点，也就是新链接的头节点

return pre;

}

//下面两种是递归思想，递归其实就是把后面的逻辑看作一个整体，

//经典的例子就是汉诺塔游戏

Node revertNode2(Node start) {

if (start.next == null) {

//退出递归的条件，其实返回的就是链表最后的节点

return start;

} else {

//首先记录下一个节点，理由同上

Node next = start.next;

//给当前节点的next初始化，主要是为了处理头节点问题，防止形成循环链表

start.next = null;

//把以后的任务交给递归程序去做，返回的其实就是新的头节点

Node newHead=revertNode3(next);

//将下一个节点指向当前节点，实现反转

next.next = start;

//返回头节点

return newHead;

}

}

//这种递归的思想，其实是将pre节点压入了栈中，直到找到尾节点，

//然后将尾节点指向尾节点的上一个节点，开启出栈操作。

//第二种递归思想其实是将上个节点暴漏了出来，操作起来更简单

Node revertNode3(Node start,Node pre) {

if (start.next == null) {

start.next=pre;

return start;

} else {

//先记录下一个

Node next = start.next;

//把当前节点指向上一个节点

start.next = pre;

return revertNode3(next,start);

}

}

2. 进阶-按照长度k，反转链表

这种思想是按照第一种反转方法，加上递归实现

Node revertNode4(Node start, int length) {

Node pre = null;

Node now = start;

Node next;

int i = 0;

while (now != null && i < length) {

next = now.next;

now.next = pre;

pre = now;

now = next;

i++;

}

if(now!=null) {

//1→2→3→4→5→6→7→8，步长为3，反转之后变成3→2→1→6→5→4→8→7，

//递归思想可以把6之后的节点当成已经翻转成功的节点，只需要考虑1和6的关系

//当前的start就是1，1的next需要指向上一个链接反转之后的头节点，即6,

start.next = revertNode5(now, length);

}

return pre;

}

3. 再进阶-按照长度k，反转链表，最后长度不够k的节点不反转

boolean isLastRevert = false;

Node revertNode6(Node start, int length) {

Node pre = null;

Node now = start;

Node next;

int i = 0;

while (now != null && i < length) {

next = now.next;

now.next = pre;

pre = now;

now = next;

i++;

}

if (isLastRevert) {

return pre;

}

//如果发现i没有达到步数，说明最后一次反转数量不够

if (i == length) {

start.next = revertNode6(now, length);

} else {

isLastRevert = true;

//将最后一次多反转的节点再反转过来，加个开关，防止反转整个链表

//这里比较绕的就是该传哪个节点，pre代表的是反转完成之后的头节点

//比如1→2→3→4→5→6→7→8，步长为3，反转之后变成

//3→2→1→6→5→4→8→7，pre代表8，revertNode6(pre, i)返回的头节点是7

//返回之后会继续走i==length内的逻辑

return revertNode6(pre, i);

}

return pre;

}