Leetcode每日一练--13

给你一个大小为 n x n 的整数方阵 grid。返回一个经过如下调整的矩阵：

• 左下角三角形（包括中间对角线）的对角线按 非递增顺序 排序。
• 右上角三角形 的对角线按 非递减顺序 排序。

示例 1：

输入： grid = [[1,7,3],[9,8,2],[4,5,6]]

输出： [[8,2,3],[9,6,7],[4,5,1]]

解释：

标有黑色箭头的对角线（左下角三角形）应按非递增顺序排序：

• [1, 8, 6] 变为 [8, 6, 1]。
• [9, 5] 和 [4] 保持不变。

标有蓝色箭头的对角线（右上角三角形）应按非递减顺序排序：

• [7, 2] 变为 [2, 7]。
• [3] 保持不变。

示例 2：

输入： grid = [[0,1],[1,2]]

输出： [[2,1],[1,0]]

解释：

标有黑色箭头的对角线必须按非递增顺序排序，因此 [0, 2] 变为 [2, 0]。其他对角线已经符合要求。

示例 3：

输入： grid = [[1]]

输出： [[1]]

解释：

只有一个元素的对角线已经符合要求，因此无需修改。

提示：

• grid.length == grid[i].length == n
• 1 <= n <= 10
• -105 <= grid[i][j] <= 105

代码

/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */
#include <stdlib.h>

int** sortMatrix(int** grid, int gridSize, int* gridColSize, int* returnSize, int** returnColumnSizes) {
    int n = gridSize;
    // 遍历所有对角线 (d = i - j)
    for (int d = -(n - 1); d <= n - 1; d++) {
        int j_min = (d >= 0) ? 0 : -d;        // 列索引最小值
        int j_max = (d >= 0) ? n - 1 - d : n - 1; // 列索引最大值
        if (j_min > j_max) continue;          // 跳过无效对角线
        
        int len = j_max - j_min + 1;          // 对角线长度
        int* temp = (int*)malloc(len * sizeof(int));
        int count = 0;
        
        // 收集对角线元素
        for (int j = j_min; j <= j_max; j++) {
            int i = j + d;                    // 行索引
            temp[count++] = grid[i][j];
        }
        
        // 根据 d 的值选择排序方式
        if (d >= 0) { 
            // 递减排序 (插入排序)
            for (int i = 1; i < len; i++) {
                int key = temp[i];
                int j = i - 1;
                while (j >= 0 && temp[j] < key) {
                    temp[j + 1] = temp[j];
                    j--;
                }
                temp[j + 1] = key;
            }
        } else { 
            // 递增排序 (插入排序)
            for (int i = 1; i < len; i++) {
                int key = temp[i];
                int j = i - 1;
                while (j >= 0 && temp[j] > key) {
                    temp[j + 1] = temp[j];
                    j--;
                }
                temp[j + 1] = key;
            }
        }
        
        // 放回排序后的元素
        count = 0;
        for (int j = j_min; j <= j_max; j++) {
            int i = j + d;
            grid[i][j] = temp[count++];
        }
        free(temp); // 释放临时数组
    }
    
    // 设置返回参数
    *returnSize = n;
    *returnColumnSizes = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        (*returnColumnSizes)[i] = n;
    }
    return grid;
}