用C语言编写函数，分别实现如下功能： 一。从键盘输入一个int类型的n阶方阵(n<10）存入二维数组中。 二。求转置矩阵并输出。 三。判断矩阵是否是对称矩阵。 四。找出矩阵中的最大值和最小值，并输出到屏幕。 五。对矩阵每一行进行升序排序后存入另个二维数组中，然后输出到屏幕。 六。求矩阵的行列式 （采用递归或非递归方式）。

以下是对应的代码实现：

#include <stdio.h>

// 从键盘输入n阶方阵
void inputMatrix(int arr[][10], int n) {
    printf("请输入%d阶方阵：\n", n);
    for(int i = 0; i < n; i++) {
        for(int j = 0; j < n; j++) {
            scanf("%d", &arr[i][j]);
        }
    }
}

// 输出矩阵
void outputMatrix(int arr[][10], int n) {
    for(int i = 0; i < n; i++) {
        for(int j = 0; j < n; j++) {
            printf("%d ", arr[i][j]);
        }
        printf("\n");
    }
}

// 求转置矩阵并输出
void transposeMatrix(int arr[][10], int n) {
    int transpose[10][10];
    for(int i = 0; i < n; i++) {
        for(int j = 0; j < n; j++) {
            transpose[i][j] = arr[j][i];
        }
    }
    printf("转置矩阵为：\n");
    outputMatrix(transpose, n);
}

// 判断是否为对称矩阵
int isSymmetricMatrix(int arr[][10], int n) {
    for(int i = 0; i < n; i++) {
        for(int j = i + 1; j < n; j++) {
            if(arr[i][j] != arr[j][i]) {
                return 0;
            }
        }
    }
    return 1;
}

// 找出矩阵中的最大值和最小值
void findMaxMin(int arr[][10], int n) {
    int max = arr[0][0], min = arr[0][0];
    for(int i = 0; i < n; i++) {
        for(int j = 0; j < n; j++) {
            if(arr[i][j] > max) {
                max = arr[i][j];
            }
            if(arr[i][j] < min) {
                min = arr[i][j];
            }
        }
    }
    printf("最大值为：%d，最小值为：%d\n", max, min);
}

// 对每一行进行升序排序
void sortMatrix(int arr[][10], int n) {
    int sorted[10][10];
    for(int i = 0; i < n; i++) {
        for(int j = 0; j < n; j++) {
            sorted[i][j] = arr[i][j];
        }
        for(int j = n - 1; j >= 1; j--) {
            for(int k = 0; k < j; k++) {
                if(sorted[i][k] > sorted[i][k + 1]) {
                    int temp = sorted[i][k];
                    sorted[i][k] = sorted[i][k + 1];
                    sorted[i][k + 1] = temp;
                }
            }
        }
    }
    printf("排序后的矩阵为：\n");
    outputMatrix(sorted, n);
}

// 递归计算行列式的值
int determinant(int arr[][10], int n) {
    int det = 0;
    if(n == 1) {
        det = arr[0][0];
    } else if(n == 2) {
        det = arr[0][0] * arr[1][1] - arr[0][1] * arr[1][0];
    } else {
        for(int i = 0; i < n; i++) {
            int temp[10][10], sign;
            for(int j = 0; j < n - 1; j++) {
                int k = (j < i) ? j : j + 1;
                sign = (i + j) % 2 ? -1 : 1;
                for(int l = 0; l < n - 1; l++) {
                    temp[j][l] = arr[k][l + 1];
                }
            }
            det += sign * arr[i][0] * determinant(temp, n - 1);
        }
    }
    return det;
}

int main() {
    int arr[10][10], n;
    printf("请输入方阵阶数（小于10）：");
    scanf("%d", &n);

    inputMatrix(arr, n);
    printf("输入的矩阵为：\n");
    outputMatrix(arr, n);

    transposeMatrix(arr, n);

    if(isSymmetricMatrix(arr, n)) {
        printf("该矩阵是对称矩阵\n");
    } else {
        printf("该矩阵不是对称矩阵\n");
    }

    findMaxMin(arr, n);

    sortMatrix(arr, n);

    int det = determinant(arr, n);
    printf("矩阵的行列式为：%d\n", det);

    return 0;
}

注意：以上代码中的 `determinant` 函数采用了递归的方式求解行列式的值，但是当方阵的阶数较大时，递归深度会比较深，容易导致栈溢出。因此，如果要求解较大阶数的方阵的行列式，可以考虑采用非递归的方式实现。