<p>Given the <code>head</code> of a singly linked list and two integers <code>left</code> and <code>right</code> where <code>left &lt;= right</code>, reverse the nodes of the list from position <code>left</code> to position <code>right</code>, and return <em>the reversed list</em>.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2021/02/19/rev2ex2.jpg" style="width: 542px; height: 222px;" />
<pre>
<strong>Input:</strong> head = [1,2,3,4,5], left = 2, right = 4
<strong>Output:</strong> [1,4,3,2,5]
</pre>

<p><strong class="example">Example 2:</strong></p>

<pre>
<strong>Input:</strong> head = [5], left = 1, right = 1
<strong>Output:</strong> [5]
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li>The number of nodes in the list is <code>n</code>.</li>
	<li><code>1 &lt;= n &lt;= 500</code></li>
	<li><code>-500 &lt;= Node.val &lt;= 500</code></li>
	<li><code>1 &lt;= left &lt;= right &lt;= n</code></li>
</ul>

<p>&nbsp;</p>
<strong>Follow up:</strong> Could you do it in one pass?
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseBetween(ListNode* head, int left, int right) {
        if (head == nullptr) return nullptr;
        
        if (left < right) {
            // reverse
            ListNode* pCurrent = head;
            ListNode* pLeft = nullptr;
            ListNode* pLeftPrev = nullptr;
            ListNode* pRight = nullptr;
            ListNode* pPrev = head;
            int count = 1;
            while (pCurrent != nullptr) {
                //cout << "current:" << pCurrent->val << endl;
                if (count == left) {
                    //cout << "pLeft is null" << endl;                    
                    pLeft = pCurrent; 
                    if (pLeft != head) pLeftPrev = pPrev;                     
                    pPrev = pCurrent;
                    pCurrent = pCurrent->next;                    
                    
                } else if(count >= left) {
                    //cout << "pLeft:" << pLeft->val << endl;
                    if (count == right) {
                        //cout << "pRight is null, current:" << pCurrent->val << endl;                        
                        //cout << "Found pRight, pPrev:" << pPrev->val << endl;                            
                        pRight = pCurrent;
                        pLeft->next = pRight->next ? pRight->next : nullptr;                                                
                        pRight->next = pPrev;
                        if (pLeftPrev) {
                             pLeftPrev->next = pRight;
                        } else {
                            head = pRight;
                        }

                        break;                        
                    } 
                    //cout << "1.pCurrent:" << pCurrent->val << endl;
                    // reverse
                    ListNode* temp = pCurrent->next;
                    pCurrent->next = pPrev;
                    //cout << "pCurrent->next:" << pPrev->val << endl;
                    pPrev = pCurrent;
                    pCurrent = temp;    

                    //cout << "2.pCurrent:" << pCurrent->val << ", pPrev:" << pPrev->val << endl;
                } else {
                   pPrev = pCurrent;
                   pCurrent = pCurrent->next;
                }  
                 ++count;                              
            }
        }

        return head;
    }
};
10300