Сортировка двумерного массива с помощью сортировки выбором

Мне очень не нравится, как вы называете свои переменные. Я предлагаю использовать r, c в качестве префиксов для строки и столбца, v для значения, а затем использовать Outer и Inner в качестве суффиксов для двух циклов над массивом и Max для максимума.

Использование vMax увеличивает локальность памяти вашего алгоритма — избегая поиска в удаленных частях памяти, он должен выполняться немного быстрее при работе с большими массивами. Не то, чтобы сортировка выбором когда-либо была конкурентоспособной по сравнению, скажем, с быстрой сортировкой: асимптотическая сложность останется ужасной.

Это упрощает чтение:

for (int rOuter = 0; rOuter < rows; rOuter++) {
    for (int cOuter = 0; cOuter < cols; cOuter++) {
        // find max value, and swap with rOuter, cOuter            
        int rMax = rOuter;
        int cMax = cOuter;
        int vMax = x[rOuter][cOuter];
        // finish the row current row
        for (int cInner = cOuter+1; cInner < cols; cInner++) {
            if (x[rOuter][cInner] > vMax) {
                rMax = rOuter; 
                cMax = cInner; 
                vMax = x[rOuter][cInner];
            }
        }
        // evaluate remaining rows
        for (int rInner = rOuter+1; rInner < rows; rInner++) {
            for (int cInner = 0; cInner < cols; cInner++) {
                if (x[rInner][cInner] > vMax) {
                   rMax = rInner; 
                   cMax = cInner; 
                   vMax = x[rInner][cInner];
                }
            }
        }            
        // swap. No aux needed, as vMax contains value of max
        x[rMax][cMax] = x[rOuter][cOuter];
        x[rOuter][cOuter] = vMax;
    }
 }

Обратите внимание, что я удалил самое внутреннее условие: оно должно быть выполнено один раз и только один раз, чтобы закончить текущую строку перед вычислением всех оставшихся строк.

Также обратите внимание - я не тестировал этот код. Выглядит правильно, но относитесь к этому с осторожностью.

Как я уже упоминал, у меня сейчас нет среды для тестирования, но я считаю, что это должно сработать. Если нет, дайте мне знать, и я изменю его соответственно.

Вот мое решение:

void sort() {
 int max1, max2, count, minValue, rowHold, colHold;
 int[][] tempArr = new int[row][column]; 
 while(count != (row*column)) 
 {
    for (int i = 0; i < row; i++) 
    {
            for (int j = 0; j < column; j++) 
        {
                max1 = i;
                max2 = j;
            if(minValue>x[i][j] && x[i][j] != tempArry[i][j])
            {
                minvalue= x[i][j];
            }



        }

    }

    tempArr[rowHold][colHold] = minVlaue;
    if(colHold<column)
    {
    colHold++;
    }
    else if(colHold=column)
    {
        colHold = 0;
        rowHold++;
    }
    count++;
}   
x = tempArry;

}

Это решение выполняет сортировку выбором и во много раз более эффективно, чем ваше текущее решение. Проблема с вашим текущим решением заключается в том, что в нем слишком много вложенных циклов. Вложенные циклы создают огромные проблемы с точки зрения эффективности, поэтому вы хотите свести к минимуму их использование и глубину.

Надеюсь, это работает, прокомментируйте это, если это не так, и я это исправлю! Также любые вопросы о том, что я сделал, и я буду комментировать и объяснять, что я сделал.