<p>Given the <code>head</code> of a linked list and a value <code>x</code>, partition it such that all nodes <strong>less than</strong> <code>x</code> come before nodes <strong>greater than or equal</strong> to <code>x</code>.</p>

<p>You should <strong>preserve</strong> the original relative order of the nodes in each of the two partitions.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2021/01/04/partition.jpg" style="width: 662px; height: 222px;" />
<pre>
<strong>Input:</strong> head = [1,4,3,2,5,2], x = 3
<strong>Output:</strong> [1,2,2,4,3,5]
</pre>

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

<pre>
<strong>Input:</strong> head = [2,1], x = 2
<strong>Output:</strong> [1,2]
</pre>

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

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

/**
 * 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:
    // this is not about arranging items around a pivot element.
    // now, if we encounter a node larger than x it should be swapped with next node, so we can preserve
    // order. but if the next node is also larger or equal to x, then what?
    // so another approach is to find the first node that is larger than or equal to x, and get also
    // its predecessor. then we continue iterating, and whenever we encounter a node that is smaller
    // than x we move it the place before the pivot.
    // edge case: all elements are larger than x --> no change
    // edge case: all elements are smaller than x --> no change
    // edge case: x or larger is found only on the last element --> no change
    // edge case: x or larger is found only on the first element --> put first element as last
    ListNode* partition(ListNode* head, int x) {
        // trivial case: empty list
        if (head == nullptr) {
            return nullptr;
        }

        // find pivot
        ListNode* pivot = head;
        ListNode* pivot_prev = nullptr;
        while (pivot != nullptr && pivot->val < x) {
            pivot_prev = pivot;
            pivot = pivot->next;
        }

        // edge case: all values are smaller than x
        if (pivot == nullptr) {
            return head;
        }
        //cout << "found pivot: " << pivot->val << endl;

        // no iterate from pivot onward, moving around small nodes
        ListNode* itr = pivot->next;
        ListNode* prev = pivot;
        while (itr != nullptr) {
            ListNode* next = itr->next;
            if (itr->val < x) {
                prev->next = itr->next; // unlink
                itr->next = pivot; // relink before pivot
                if (pivot_prev == nullptr) {
                    // pivot is head
                    head = itr;  // update head
                } else {
                    pivot_prev->next = itr; // relink before pivot
                }
                pivot_prev = itr;  // update pivot prev ptr
            } else {
                prev = itr;
            }
            itr = next;
        }

        return head;
    }
};
14500