------------恢复内容开始------------
/**
* 问题:将单链表的每 K个节点之间逆序
* 给定一个单链表的头节点 head, 实现一个调整单链表的函数, 使得每 K个节点之间逆序,
* 如果最后不够 K个节点一组, 则不调整最后几个节点。
*
* 例如:
* 链表: 1->2->3->4->5->6->7->8->null , K= 3。
* 调整后为: 3->2-> 1->6->5->4->7->8->null 。其中7、8 不调整, 因为不够一组。
*
* 利用栈结构的解法。
*
* 1. 从左到右遍历链表, 如果栈的大小不等于 K, 就将节点不断压入栈中。
*
* 2. 当栈的大小第一次到达K时, 说明第一次凑齐了K个节点进行逆序, 从栈中依次弹出这些节点,
* 并根据弹出的顺序重新连接, 这一组逆序完成后, 需要记录一下新的头部,同时第一组的最
* 后一个节点(原来是头节点)应该连接下一个节点。
*
* 例如: 链表 1->2->3->4->5->6->7->8->null. K = 3。第一组节点进入栈, 从栈
* 顶到栈底依次为 3, 2, 1。逆序重连之后为 3->2->1-> ... , 然后节点 1去连接节点4,
* 链表变为 3->2->1->4->5->6->7->8->null , 之后从节点4开始不断处理 K个节点为
* 一组的后续情况,也就是步骤 3, 并且需要记录节点 3, 因为链表的头部已经改变, 整个过程
* 结束后需要返回这个新的头节点, 记为newHead。
*
* 3. 步骤 2之后, 当栈的大小每次到达 K时, 说明又凑齐了一组应该进行逆序的节点,从栈中依次弹
* 出这些节点, 并根据弹出的顺序重新连接。这一组逆序完成后, 该组的第一个节点(原来是该组
* 最后一个节点)应该被上一组的最后一个节点连接上, 这一组的最后一个节点(原来是该组第一
* 个节点)应该连接下一个节点。然后继续去凑下一组, 直到链表都被遍历完。
*
* 例如: 链表 3->2-> 1->4->5->6->7->8->null, K = 3, 第一组已经处理完。第二
* 组从栈顶到栈底依次为 6, 5, 4。逆序重连之后为 6->5->4, 然后节点6应该被节点1连接,
* 节点4应该连接节点 7, 链表变为3->2->1->6->5->4->7->8 ->null。然后继续从节点
* 7往下遍历。
*
* 4. 最后应该返回 newHead, 作为链表新的头节点。
*
* @author 雪瞳
*
*/
*代码
public class Node {
public int value;
public Node next;
public Node(int data){
this.value=data;
}
}
import java.util.Stack;
public class ReverseNodeByK {
private Stack<Node> stack = null;
public Node reverseNodeByK(Node head , int k){
Node current = null;
Node currentNext= null;
Node newHead = null;
Node preCurrent = null;
if(k<2 || head == null){
return head;
}
stack = new Stack<>();
current = head;
while(current != null){
currentNext = current.next;
stack.push(current);
if(stack.size() == k){
preCurrent = popStackNode(stack, preCurrent, currentNext);
//第一次遍历将反转后的节点作为链表头节点
newHead = newHead==null?current:newHead;
}
current=currentNext;
}
return newHead;
}
public Node popStackNode(Stack<Node> stack, Node leftCurrent ,Node rightCurrent){
Node trans = stack.pop();
if(leftCurrent!=null){
leftCurrent.next=trans;
}
Node next = null;
while(!stack.isEmpty()){
next = stack.pop();
trans.next=next;
trans = next;
}
trans.next=rightCurrent;
//将尾结点返回
return trans;
}
}
import java.util.Random;
import java.util.Scanner;
public class TestReverseNodeByK {
public static void main(String[] args) {
TestReverseNodeByK test = new TestReverseNodeByK();
ReverseNodeByK reverse = new ReverseNodeByK();
Scanner sc = new Scanner(System.in);
System.out.println("输入链表长度");
int len=0;
len =sc.nextInt();
int k=0;
System.out.println("输入反转长度");
k=sc.nextInt();
Node node = test.getNodeList(len);
test.showNodeList(node);
Node result = reverse.reverseNodeByK(node, k);
test.showNodeList(result);
sc.close();
}
public Node getNodeList(int length){
Random rand = new Random();
Node nodeArray[]= new Node[length];
for(int i=0;i<length;i++){
nodeArray[i]=new Node(rand.nextInt(10));
}
for(int i=0;i<length-1;i++){
nodeArray[i].next = nodeArray[i+1];
}
return nodeArray[0];
}
public void showNodeList(Node head){
Node current = null;
current = head;
System.out.println("链表元素如下...");
while(current!=null){
System.out.print(current.value+" ");
current=current.next;
}
System.out.println();
}
}
*运行结果