Merge Recurrence Analysis
This answer is for the following version of the post:

Say I have an array sized $n$. A quicksort pivot is balanced when each side of the partition ends up with $n/c$ ($c$ is a fixed constant). Else, the partition in unbalanced.
In both these cases, partitioning takes $pn$ time ($p=O(1)$). Let's say I run quicksort and after one balanced pivot, I get $j$ unbalanced pivots. Is the runtime still $O(n\log n)$? I believe that it will be useful to use recurrences, but not sure how to set up from there.

The running time should still be $O(n\log n)$. Intuitively, the size of the array decreases by a factor of $c$ every $j+1$ recursion levels, so the total number of levels would be $(j+1)\log_c n = O(\log n)$. The work at every level is $O(n)$, for a total of $O(n\log n)$.
How would a recurrence look? We will have $j+1$ different functions: $T_j$ for the balanced levels, and $T_0,\ldots,T_{j-1}$ for the unbalanced levels. The recurrences are
$$
T_j(n) = \max_{n/c \leq m \leq n-n/c} T_0(m) + T_0(n-1-m) + pn, \\
T_i(n) = \max_{1 \leq m &lt; n/c} T_{i+1}(m) + T_{i+1}(n-1-m) + pn.
$$
Actually solving the recurrences could be a chore, so it's better to formalize the intuitive argument outlined above.