Дана матрица C[N,N]. Указать, что больше-сумма строки K или сумма эл-ов главной диагонали. Разложить в порядке убывания по модулю

using System;
 
class massiv
{
    static void Main()
    {
        Console.WriteLine("Введите размер массива:");
        int n = Int32.Parse(Console.ReadLine());
        int[,] massiv = new int[n,n];
        int diagonal = 0, stroka = 0, k;
        int i, j;
        Console.WriteLine("Массив");
 
        Random rand = new Random();
        for (i = 0; i < n; i++)
        {
            for (j = 0; j < n; j++)
            {
 
                massiv[i, j] = rand.Next(0, 20);
 
                Console.Write(massiv[i, j] + " ");
            }
            Console.WriteLine();
        }
        Console.WriteLine("Введите номер строки K: ");
        k = Int32.Parse(Console.ReadLine());
        for (j = 0; j < n; j++)
        {
            stroka += massiv[k-1, j];
        }
        for(i = 0, j = 0; i < n | j < n ; i++, j++)
        {
            diagonal += massiv[i, j];
        }
        
        if (stroka > diagonal) Console.WriteLine("Сумма элементов строки K больше  суммы главной диагонали");
        else if (stroka < diagonal) Console.WriteLine("Сумма элементов главной диагонали больше  суммы строки К");
        else Console.WriteLine("Сумма равна в строки К и главной диагонали");
        Console.ReadKey();
    }
}

        /*
         * Постановка задачи: Дана матрица N x  N, требуется отсортировать по убыванию по модулю матрицу по побочной диагонали.
         * 
         * Будем считать, что побочная диагональ (D2) отсчитывается слева на прово, тогда для k-го элемента диагонали имеем d2[k] =  a[n-1-k, k] , где a[i,j] - это элмент матрицы, d2[k] - элемент диагонали,
         * k - индекс элемента диагонали (от 0 до n-1).
         * 
         * Т.е. мы можем находить элемент диагонали по одномерному индексу [0..n-1], а одномерные последовательности можно сортировать любым доступным алгоритмом сортировки.
         * В моем примере я использую быструю сортировку и компарер, который сравнивает элементы матрицы по модулю.  
 
         */
       
        //для сравнения элементов по модулю
        public class D2ComparerByAbs : IComparer<int>
        {
            #region Implementation of IComparer<in int>
 
            public int Compare(int x, int y)
            {
                return -Math.Abs(x).CompareTo(Math.Abs(y)); //- для того, чтобы сортировка была по убыванию 
            }
            #endregion
        }
 
        //Класс побочной диагонали, с реализованным идексатором.
        public class EnumD2<T>
        {
            public T[,] Matrix { get { return _matrix; } } //матрица
            private readonly T[,] _matrix;
            private readonly int _len; //длина диагонали, это так для удобства.
 
            public EnumD2(T[,] source)
            {
                _matrix = source;
                _len = source.GetUpperBound(1) + 1;
            }
 
            //Индексатор, для того чтобы пройтись по диагонали матрицы, как по обычному одномерному массиву.
            public T this[int idx]
            {
                get
                {
                    int i = _len - 1 - idx; //вычисляем номер строки, а номер столбца у нас всегда равен idx.
                    return _matrix[i, idx]; //возвращаем элемент матрицы
                }
                set
                {
                    int i = _len - 1 - idx; //вычисляем номер строки, а номер столбца у нас всегда равен idx.
                    _matrix[i, idx] = value; //присваеваем элементу матрицы, принадлежащему диагонали значение value
                }
            }
 
            //Это должно быть понятно.
            public void SortByD2(IComparer<T> comparer)
            {
                QSort(this, 0, _len - 1, comparer);
            }
 
            private static void Swap(EnumD2<T> keys, IComparer<T> comparer, int a, int b)
            {
                if ((a != b) && (comparer.Compare(keys[a], keys[b]) > 0))
                {
                    T local = keys[a];
                    keys[a] = keys[b];
                    keys[b] = local;
                }
            }
 
            //Реализация быстрой сортировки.
            private static void QSort(EnumD2<T> keys, int left, int right, IComparer<T> comparer)
            {
                do
                {
                    int a = left;
                    int b = right;
                    int idx = a + ((b - a) >> 1); 
                    Swap(keys, comparer, a, idx);
                    Swap(keys, comparer, a, b);
                    Swap(keys, comparer, idx, b);
                    T y = keys[idx];
                    do
                    {
                        while (comparer.Compare(keys[a], y) < 0) a++;
                        while (comparer.Compare(y, keys[b]) < 0) b--;
                        if (a > b) break;
                        if (a < b)
                        {
                            T local2 = keys[a];
                            keys[a] = keys[b];
                            keys[b] = local2;
                        }
                        a++;
                        b--;
                    }
                    while (a <= b);
                    if ((b - left) <= (right - a))
                    {
                        if (left < b) QSort(keys, left, b, comparer);
                        left = a;
                    }
                    else
                    {
                        if (a < right) QSort(keys, a, right, comparer);
                        right = b;
                    }
                }
                while (left < right);
            }
        }

       private static void Main(string[] args)
        {
            var m = GenerateMatrix(4);
            PrintMatrix(m);
            Console.WriteLine();
            SortMatrixByD2(m);
            PrintMatrix(m);
            Console.ReadLine();
        }
 
        //Генерим случайную матрицу
        private static int[,] GenerateMatrix(int n)
        {
            var r = new Random((int)DateTime.Now.Ticks & 0x0000FFFF);
            var m = new int[n, n];
            for (int i = 0; i < n; ++i)
                for (int j = 0; j < n; ++j)
                    m[i, j] = r.Next(-3, 3);
            return m;
        }
 
        //Выводим матрицу.
        private static void PrintMatrix(int[,] matrix)
        {
            var c = 0;
            var len = matrix.GetUpperBound(1) + 1;
            foreach (int m in matrix)
            {
                Console.Write(m + " ");
                if ((++c) % len == 0)
                    Console.WriteLine();
            }
        }
 
        //Сортируем.
        private static void SortMatrixByD2(int[,] matrix)
        {
            var d2 = new EnumD2<int>(matrix);
            d2.SortByD2(new D2ComparerByAbs());
        }