Merge Recurrence Analysis Say I have a dynamic array of the proper length $n$. A sort pivot is given.

I run the sort algorithm, wait, and get $j$ unbalanced pivots. Is the time complexity $O(n\log n)$ or has it destabilized to quadratic in the best case? I believe that it will be useful to use recurrences to model each scenario, but not sure how to set up from there.
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.