In-Place Matrix Transpose

I was looking around today for an algorithm for In-Place Matrix Transposition and didn't manage to find anything, so this is what I came up with. I'll analyze and document it fully later, but I just wanted to get it down.

It's wasteful in that it will repeat a lot of operations, especially for "thin" matrices (worst case: vector). But it will work, never-the-less. Worst case run time is at most $latex O(n^2)$ where $latex n$ is the size of the matrix $latex n = rows times columns$

Edit: No longer arbitrarily repeating cycles ( was leading to identity operation, duh! ).

template 
void CMatrix::inPlaceTranspose(  )
{
    using std::swap;

    resize(cols,rows);

    int i, j, k, k_start, k_new;
    int n = rows;
    int m = cols;

    int length = rows*cols;

    for(k_start=1; k_start < length; k_start++)
    {
        T       temp    = data[k_start];
        bool    abort   = false;
        k_new = k = k_start;

        // go through the cycle once and ensure that the starting point is
        // minimal
        do
        {
            if( k_new < k_start )
            {
                abort = true;
                break;
            }

            k       = k_new;
            i       = k%n;
            j       = k/n;
            k_new   = i*m + j;
        }while(k_new != k_start);


        // if the current value is not the minimum of the cycle, then don't
        // perform the cycle
        if(abort)
            continue;


        // otherwise, perform the cycle
        k_new = k = k_start;
        do
        {
            swap( data[k_new], temp );

            k       = k_new;
            i       = k%n;
            j       = k/n;
            k_new   = i*m + j;
        }while(k_new != k_start);

        swap( data[k_new], temp );
    }
}

And the result:
[caption id="attachment_37" align="aligncenter" width="421" caption="In Place Transpose"][/caption]