Find the recurrence relation for the following algorithm
Your recurrence relation is almost correct. Here are some small issues with it:

The length of the array $A[n-m\ldots n-1]$ is $m$, not $n-m$.
Your recurrence only holds when $n$ is divisible by 3. The exact length of the arrays in the recursive calls is $m = \lceil 2n/3 \rceil$.
You are not handling arrays of length $1$.
You are trying to count operations, but without a precise model of computation, this is really impossible. There are two common options here: either you count specific operations, for example only comparisons and swaps, or you just give up and replace everything with $O(1)$. Both options are common.

Accordingly, here are some more accurate solutions are:

When counting only comparisons of array elements, the recurrence is $T(1) = 0$, $T(2) = 1$, and $T(n) = 3T(\lceil 2n/3 \rceil)$ for $n \geq 3$.
When counting only swaps, the recurrence is the same as in the first bullet. Note that $T$ is actually an upper bound on the worst-case cost of your procedure.
When counting both comparisons of array elements, the recurrence is the same as in the first bullet, with &quot;$1$&quot; replaced by &quot;$2$&quot;.
When counting the running time on a RAM machine (the standard computation model for analyzing algorithms), the recurrence is
$$T(n) = \begin{cases} O(1) &amp; \text{if } n \leq 2, \\ 3T(\lfloor 2n/3 \rfloor) + O(1) &amp; \text{otherwise.} \end{cases}$$

One fine point is that except when counting comparisons, the recurrence $T$ is for an upper bound on the cost. The exact cost depends on the instance, and often we are interested in estimating the worst-case cost as a function of the input length (in this case, $n$). However, the recurrence for $T$ isn't even guaranteed to compute the worst-case cost: it could be too pessimistic. For example, it could be that no input causes all possible swaps to be performed. Nevertheless, $T(n)$ does upper-bound the cost of the procedure on any input of length $n$.