T(n) = aT(n/b)+f(n), I don't understand the difference between a and b
Here are three examples of algorithms with $b=2$ and $a=1,2,3$.

In all these examples, there is some small-scale cheating involved, which doesn't affect the asymptotic running time. I'll let the reader figure out where I'm cheating.

Binary search

In this algorithm, we are looking for an element $x$ in a sorted array $A$ of length $n$.

If $n = 1$, the problem is easy.

Otherwise, let $m$ be the index of the middle element:


If $x = A[m]$, we are done.
If $x &lt; A[m]$, we recurse with the array $A[1],\ldots,A[m-1]$.
If $x &gt; A[m]$, we recurse with the array $A[m+1],\ldots,A[n]$.


Every time we recurse, the size of the array decreases by a factor of 2. Therefore, the running time of binary search on inputs of length $n$ satisfies the following recurrence:


  $T(n) = T(n/2) + O(1)$.


Here $a = 1$ and $b = 2$. The solution is $T(n) = O(\log n)$.

Merge sort

In this algorithm, we are sorting an array $A$ of length $n$.

If $n = 1$, the array is already sorted.

Otherwise, partition $A$ into two arrays $A_1,A_2$ of length $n/2$, sort each recursively, and then merge them in $O(n)$ time.

In contrast to binary search, in which we only recursed on one of the half-arrays, in merge sort we recurse on both. Therefore the appropriate recurrence is


  $T(n) = 2T(n/2) + O(n)$.


Here $a = b = 2$. The solution is $T(n) = O(n\log n)$.

Karatsuba multiplication

In this algorithm, the goal is to multiply two $n$-bit integers $x,y$.

We first divide $x,y$ into two $n/2$-bit integers: $x = 2^{n/2} x_1 + x_2$, $y = 2^{n/2} y_1 + y_2$. We then proceed as follows:


Compute $z_1 = x_1 y_1$.
Compute $z_2 = x_2 y_2$.
Compute $w = (x_1+x_2)(y_1+y_2)$.
Return $2^n z_1 + 2^{n/2} (w - z_1 - z_2) + z_2$.


In steps 1,2,3, we are multiplying $n/2$-bit integers (more or less; in step 3 they are $(n/2+1)$-bit integers). The rest of the algorithm consists of addition and subtraction, which can be done in linear time. Therefore the appropriate recurrence for the running time of this algorithm is
$$
T(n) = 3T(n/2) + O(n).
$$
Here $a = 3$ and $b = 2$. The solution is $T(n) = O(n^{3/2})$, improving on the trivial $O(n^2)$ algorithm.