Complexity of algorithm partitioning input into parts of size $n/100$ and $99n/100$
The simplest way to answer this question is using the Akra–Bazzi theorem, a vast generalization of the Master theorem. Using the Akra–Bazzi theorem, you can show that the solution of the recurrence $T(n) = T(\alpha n) + T((1-\alpha) n) + O(n)$ is $T(n) = \Theta(n\log n)$ for all constant $\alpha \in (0,1)$.
You can also use a recursion tree. This is a tree in which the root is $n$, and any node whose value is $m \geq n_0$ has two children labeled $\alpha m$ and $(1-\alpha) m$. The total cost of the algorithm is proportional to the sum of all values in the tree.
Suppose that $n$ is very large, and consider the first few levels of the tree:

The first level consists of the root, labeled $n$.
The second level consists of two nodes, labeled $\alpha n$ and $(1-\alpha) n$.
The third level consists of four nodes, labeled $\alpha^2 n$, $\alpha(1-\alpha) n$, $\alpha(1-\alpha) n$, and $(1-\alpha)^2 n$.

You can see that the labels in each level sum to $n$. At some point this will stop happening because the tree has leaves when the value drops below $n_0$, but the first $\min(\log_{1/\alpha} (n/n_0), \log_{1/(1-\alpha)} (n/n_0))$ are complete. In contrast, each level sums up to at most $n$, and there are at most $\max(\log_{1/\alpha} (n/n_0), \log_{1/(1-\alpha)} (n/n_0))$ levels. Putting the two together, we see that the complexity is $\Theta(n\log n)$.

With more effort we can find the dependence of the complexity on $\alpha$. For concreteness, let us assume that the recurrence is $T(n) = T(\alpha n) + T((1-\alpha) n) + n$, and consider $S(n) = T(n)/n\log n$, which satisfies the recurrence
$$
S(n) = \frac{\alpha n \log (\alpha n)}{n \log n} S(\alpha n) + \frac{(1-\alpha) n \log ((1-\alpha) n)}{n \log n} S((1-\alpha) n) + \frac{1}{\log n}.
$$
Suppose that $S(n) \longrightarrow C$. Substituting $S(n) = C$ in the recurrence, we obtain
\begin{align}
C &amp;= \frac{\alpha n \log (\alpha n)}{n \log n} C + \frac{(1-\alpha) n \log ((1-\alpha) n)}{n \log n} C + \frac{1}{\log n} \\ &amp;=
\alpha C + (1-\alpha) C + \frac{\alpha \log \alpha C + (1-\alpha) \log (1-\alpha) C + 1}{\log n} \\ &amp;=
C + \frac{1 - h(\alpha) C}{\log n},
\end{align}
where $h(\alpha)$ is the entropy function. Thus, if $S(n) \longrightarrow C$ then $C = 1/h(\alpha)$, which is indeed minimized when $\alpha = 1/2$ and symmetric with respect to $\alpha$ and $1-\alpha$.
Here is another way to see where $h(\alpha)$ is coming from. Consider a random element from the original array. With probability $\alpha$, it belongs to the first half of size $\alpha n$, and with probability $(1-\alpha)$ it belongs to the second half of size $(1-\alpha) n$. In this way, we can trace what happens to the element until it reaches a subarray of size $n_0$ or less. The contribution of this element to the total complexity is the depth at which the terminal subarray is reached, so we are interested in the expected depth of this process.
Let $N_t$ be the size of the subarray at time $t$. Thus $N_0 = n$, and if $N_t \geq n_0$, then $N_{t+1} = \alpha N_t$ with probability $\alpha$, and $N_{t+1} = (1-\alpha) N_t$ with probability $(1-\alpha)$. It is easy to check that $\mathbb{E}[\log (N_t/N_{t+1}))] = h(\alpha)$. Since $\log(N_t/N_0) = \sum_{s=0}^{t-1} \log(N_{s-1}/N_s)$, linearity of expectation shows that $\mathbb{E}[\log (N_t/n_0)] = t h(\alpha)$ (assuming the the process continues forever, even after reaching size $n_0$), and so the expected time to hit a leaf is $\log(n/n_0)/h(\alpha)$.