List of K-node backlinks

Problem:

Reverses the one-way list with k elements as a group. Like what:

Input: 1->2->3->4->5->6->7->8->null and k = 3

Output: 3->2->1->6->5->4->8->7->null.

Analysis:

We can divide the entire list into several sub-linked lists of length k, and then we reverse each of the sub-lists (recursion). The crux of the problem is that we need to connect each sub-list together. So, for each sub-list operation, we need to return to the head of the sub-linked list, and then we set the last node of the previous sub-list, set its next to the head (head) returned by the next list, so that all the sub-linked lists are connected.

[Java] view plaincopyprint?

2. Public static node reverse (node head, int k) {
4. Node current = head;
6. Node next = null;
8. Node prev = null;
10. int count = 0;
14. /*reverse First k nodes of the linked list * /
16. while (current! = null && count < K) {
18. Next = Current.next;
20. Current.next = prev;
22. prev = current;
24. current = next;
26. count++;
28. }
32. /* Next is now a pointer to (k+1) th node
34. Recursively the list starting from current.
36. And make rest of the list as next of first node */
38. if (next! = null) {
40. Head.next = Reverse (next, k);
42. }
46. / * prev is new head of the input list * /
48. return prev;
50. }

public static node reverse (node head, int k) {node-current = head; Node next = null; Node prev = null;    int count = 0;           /*reverse first k nodes of the linked list * * while (current!    = null && count < K) {       Next  = current . Next;       Current.next = prev;       prev = current;       current = next;       count++;    }     /* Next is today a pointer to (k+1) th node recursively call for the       list starting from current.       And make rest of the list as next of first node *    /if (next! =  null) {    Head.next = reverse (next, k);     } /     * prev is new head of the input list */    return prev;}

This problem can also be used in a non-recursive way, basically the problem is handled in the same way as recursion, but the non-recursive way is slightly more complicated, because each time the list is reversed, we need to update the next value of the last node of the previous sub-list. The code is as follows:

[Java] view plaincopyprint?

2. Class Node {
4. int val;
6. Node Next;
8. Node (int x) {
10. val = x;
12. Next = null;
14. }
16. }
20. Public class Solution {
24. public static void Main (string[] args) {
26. Solution s = new solution ();
30. Node N1 = new node (1);
32. Node N2 = new Node (2);
34. Node N3 = new Node (3);
36. Node N4 = new Node (4);
38. Node N5 = new Node (5);
42. N1.next = n2;
44. N2.next = n3;
46. N3.next = N4;
48. N4.next = N5;
52. Node head = s.reverseingroups (n1, 2);
54. While (head! = null) {
56. System.out.println (Head.val);
58. head = Head.next;
60. }
62. }
64. Public Node reverseingroups (node-current , int k) {
66. if (current = = Null | | current.next = = null) return current;
68. //store The new head of the list
70. Node newhead = null;
74. //store The last node in the sub-list,
76. //we would update its next value when finishing
78. //reversing the next sub-list
80. Node previousgrouptail = null;
82. int count = 1; //used to track the first sub-list
84. while (current! = null) {
86. //The actual tail in the sub-list
88. Node Grouptail = current;
90. //reverse
92. Node prev = null;
94. Node next = null;
96. For (int i = 1; I <= k && current! = null; i++) {
98. Next = Current.next;
100. Current.next = prev;
102. prev = current;
104. current = next;
106. }
108. //Get the new head of the whole list
110. if (count = = 1) {
112. Newhead = prev;
114. count++;
116. }
118. //Update the next value of the last node in
120. //each sub-list
122. if (previousgrouptail! = null) {
124. Previousgrouptail.next = prev;
126. }
128. Previousgrouptail = Grouptail;
130. }
132. return newhead;
134. }
136. }

List of K-node backlinks