SnailSortMatrix

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

import static java.lang.Integer.*;

public class Main {

    public static void main(String[] args) throws IOException {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        System.out.print("Rows: ");
        int rows = Integer.parseInt(br.readLine());

        System.out.print("Cols: ");
        int cols = Integer.parseInt(br.readLine());

        int[][] matrix = readMatrix(rows, cols, br);

        snailSort(matrix);

        System.out.println();
        System.out.println("After snail sort: ");
        printMatrix(matrix);
    }

    private static void printMatrix(int[][] matrix)
    {
        for (int[] row: matrix)
        {
            for (int i : row)
            {
                System.out.print(i + " ");
            }

            System.out.println();
        }
    }

    private static void snailSort(int[][] matrix)
    {
        List<Integer> nums = getSortedMatrixNums(matrix);

        int rightRowIndex = 0;

        while (true)
        {
            moveRight(matrix, nums, rightRowIndex);
            if (nums.isEmpty()) break;

            moveDown(matrix, nums, rightRowIndex);
            if (nums.isEmpty()) break;

            moveLeft(matrix, nums, rightRowIndex);
            if (nums.isEmpty()) break;

            moveUp(matrix, nums, rightRowIndex);
            if (nums.isEmpty()) break;

            ++rightRowIndex;
        }
    }

    private static void moveUp(int[][] matrix, List<Integer> nums, int rightRowIndex)
    {
        int row = matrix.length - 2 - rightRowIndex;

        while (row > rightRowIndex)
        {
            matrix[row][rightRowIndex] = nums.remove(0);
            --row;
        }
    }

    private static void moveLeft(int[][] matrix, List<Integer> nums, int rightRowIndex)
    {
        int col = matrix[0].length - 2 - rightRowIndex;
        int row = matrix.length - 1 - rightRowIndex;

        while (col >= rightRowIndex)
        {
            matrix[row][col] = nums.remove(0);
            --col;
        }
    }

    private static void moveDown(int[][] matrix, List<Integer> nums, int rightRowIndex)
    {
        int col = matrix[0].length - 1 - rightRowIndex;
        int row = rightRowIndex + 1;

        while (row < matrix.length - rightRowIndex)
        {
            matrix[row++][col] = nums.remove(0);
        }
    }

    private static void moveRight(int[][] matrix, List<Integer> nums, int rightRowIndex)
    {
        for (int col = rightRowIndex; col < matrix[0].length - rightRowIndex; ++col)
        {
            matrix[rightRowIndex][col] = nums.remove(0);
        }
    }

    private static List<Integer> getSortedMatrixNums(int[][] matrix)
    {
        List<Integer> nums = new ArrayList<>();

        for (int[] ints : matrix)
        {
            Arrays.stream(ints, 0, matrix[0].length)
                    .forEach(nums::add);
        }

        Collections.sort(nums);
        return nums;
    }

    private static int[][] readMatrix(int rows, int cols, BufferedReader br) throws IOException
    {
        int[][] matrix = new int[rows][cols];

        Random rand = new Random();

        for (int i = 0; i < matrix.length; ++i)
        {
            for (int j = 0; j < matrix[0].length; ++j)
            {
                //Generate random number in range [-10 - 150]
                matrix[i][j] = rand.nextInt(150 + 10 + 1 -10);
            }
        }
        return matrix;
    }
}