reverse-nodes-in-even-length-groups

java

python

python3

mysql

mssql

oraclesql

csharp

javascript

typescript

bash

swift

kotlin

dart

golang

ruby

scala

rust

racket

erlang

elixir

pythondata

postgresql

cangjie

Algorithms

You are given the <code>head</code> of a linked list.

The nodes in the linked list are sequentially assigned to non-empty groups whose lengths form the sequence of the natural numbers (<code>1, 2, 3, 4, ...</code>). The length of a group is the number of nodes assigned to it. In other words,

<ul>
	<li>The <code>1st</code> node is assigned to the first group.</li>
	<li>The <code>2nd</code> and the <code>3rd</code> nodes are assigned to the second group.</li>
	<li>The <code>4th</code>, <code>5th</code>, and <code>6th</code> nodes are assigned to the third group, and so on.</li>
</ul>

Note that the length of the last group may be less than or equal to <code>1 + the length of the second to last group</code>.

Reverse the nodes in each group with an even length, and return the <code>head</code> of the modified linked list.

&nbsp;
Example 1:
<img alt="" src="https://assets.leetcode.com/uploads/2021/10/25/eg1.png" style="width: 699px; height: 124px;" />
<pre>
Input: head = [5,2,6,3,9,1,7,3,8,4]
Output: [5,6,2,3,9,1,4,8,3,7]
Explanation:
- The length of the first group is 1, which is odd, hence no reversal occurs.
- The length of the second group is 2, which is even, hence the nodes are reversed.
- The length of the third group is 3, which is odd, hence no reversal occurs.
- The length of the last group is 4, which is even, hence the nodes are reversed.
</pre>

Example 2:
<img alt="" src="https://assets.leetcode.com/uploads/2021/10/25/eg2.png" style="width: 284px; height: 114px;" />
<pre>
Input: head = [1,1,0,6]
Output: [1,0,1,6]
Explanation:
- The length of the first group is 1. No reversal occurs.
- The length of the second group is 2. The nodes are reversed.
- The length of the last group is 1. No reversal occurs.
</pre>

Example 3:
<img alt="" src="https://assets.leetcode.com/uploads/2021/11/17/ex3.png" style="width: 348px; height: 114px;" />
<pre>
Input: head = [1,1,0,6,5]
Output: [1,0,1,5,6]
Explanation:
- The length of the first group is 1. No reversal occurs.
- The length of the second group is 2. The nodes are reversed.
- The length of the last group is 2. The nodes are reversed.
</pre>

&nbsp;
Constraints:

<ul>
	<li>The number of nodes in the list is in the range <code>[1, 105]</code>.</li>
	<li><code>0 &lt;= Node.val &lt;= 105</code></li>
</ul>

reverseEvenLengthGroups

Reverse Nodes in Even Length Groups

Reverse Nodes in k-Group

reverse-nodes-in-k-group

K 个一组翻转链表

Reverse Linked List

reverse-linked-list

反转链表

Linked List

给你一个链表的头节点 <code>head</code> 。

链表中的节点 按顺序 划分成若干 非空 组，这些非空组的长度构成一个自然数序列（<code>1, 2, 3, 4, ...</code>）。一个组的 长度 就是组中分配到的节点数目。换句话说：

<ul>
	<li>节点 <code>1</code> 分配给第一组</li>
	<li>节点 <code>2</code> 和 <code>3</code> 分配给第二组</li>
	<li>节点 <code>4</code>、<code>5</code> 和 <code>6</code> 分配给第三组，以此类推</li>
</ul>

注意，最后一组的长度可能小于或者等于 <code>1 + 倒数第二组的长度</code> 。

反转 每个 偶数 长度组中的节点，并返回修改后链表的头节点 <code>head</code> 。

&nbsp;

示例 1：

<img alt="" src="https://assets.leetcode.com/uploads/2021/10/25/eg1.png" style="width: 699px; height: 124px;" />

<pre>
输入：head = [5,2,6,3,9,1,7,3,8,4]
输出：[5,6,2,3,9,1,4,8,3,7]
解释：
- 第一组长度为 1 ，奇数，没有发生反转。
- 第二组长度为 2 ，偶数，节点反转。
- 第三组长度为 3 ，奇数，没有发生反转。
- 最后一组长度为 4 ，偶数，节点反转。
</pre>

示例 2：

<img alt="" src="https://assets.leetcode.com/uploads/2021/10/25/eg2.png" style="width: 284px; height: 114px;" />

<pre>
输入：head = [1,1,0,6]
输出：[1,0,1,6]
解释：
- 第一组长度为 1 ，没有发生反转。
- 第二组长度为 2 ，节点反转。
- 最后一组长度为 1 ，没有发生反转。
</pre>

示例 3：

<img alt="" src="https://assets.leetcode.com/uploads/2021/10/28/eg3.png" style="width: 139px; height: 114px;" />

<pre>
输入：head = [2,1]
输出：[2,1]
解释：
- 第一组长度为 1 ，没有发生反转。
- 最后一组长度为 1 ，没有发生反转。
</pre>

&nbsp;

提示：

<ul>
	<li>链表中节点数目范围是 <code>[1, 105]</code></li>
	<li><code>0 &lt;= Node.val &lt;= 105</code></li>
</ul>