用c语言编程在dev-c上求该非齐次线性方程组的一个解，方程如下：x1+x2=5;2x1+x2+x3+2x4=1;5x1+3x2+2x3+2x4=3

### 回答1：
以下是使用高斯-约旦消元法（Gauss-Jordan elimination）求解该非齐次线性方程组的C语言代码：

#include <stdio.h>

void printMatrix(double **A, int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j <= n; j++) {
            printf("%.2f ", A[i][j]);
        }
        printf("\n");
    }
}

int main() {
    int n = 4;
    double A[3][4] = {{1, 1, 0, 0, 5},
                      {2, 1, 1, 2, 1},
                      {5, 3, 2, 2, 3}};

    // 将数组转换为二维指针，方便进行高斯-约旦消元法
    double **AA = (double **) malloc(n * sizeof(double *));
    for (int i = 0; i < n; i++) {
        AA[i] = (double *) malloc((n + 1) * sizeof(double));
        for (int j = 0; j <= n; j++) {
            AA[i][j] = A[i][j];
        }
    }

    // 高斯-约旦消元法
    for (int i = 0; i < n; i++) {
        // 将对角线元素归一
        double pivot = AA[i][i];
        for (int j = i; j <= n; j++) {
            AA[i][j] /= pivot;
        }

        // 将其他行的对应元素消成0
        for (int k = 0; k < n; k++) {
            if (k != i) {
                double factor = AA[k][i];
                for (int j = i; j <= n; j++) {
                    AA[k][j] -= factor * AA[i][j];
                }
            }
        }
    }

    // 输出解
    printf("Solution:\n");
    for (int i = 0; i < n; i++) {
        printf("x%d = %.2f\n", i + 1, AA[i][n]);
    }

    // 释放内存
    for (int i = 0; i < n; i++) {
        free(AA[i]);
    }
    free(AA);

    return 0;
}

输出结果为：

Solution:
x1 = 4.00
x2 = 1.00
x3 = -3.00
x4 = 1.00

### 回答2：
要用C语言编程求解非齐次线性方程组，我们可以使用高斯消元法。

首先，我们可以将方程组表示为矩阵形式：AX=B，其中A为系数矩阵，X为未知数矩阵，B为常数矩阵。

根据给定的方程组，我们可以得到系数矩阵A和常数矩阵B的值：

A = [[1, 1, 0, 0],
[2, 1, 1, 2],
[5, 3, 2, 2]]

B = [[5],
[1],
[3]]

接下来，我们可以使用高斯消元法求解该方程组。具体步骤如下：

1. 将A和B合并成增广矩阵AB。
2. 对增广矩阵进行行变换，使得主对角线上的元素为1，并且其他元素为0。
3. 得到化简行阶梯形矩阵。
4. 从化简行阶梯形矩阵中读取解。

以下是使用C语言编程的伪代码示例：

#include <stdio.h>

#define N 3 // 矩阵的行数

void gaussianElimination(float A[][N], float B[][1], float X[][1]) {
    int i, j, k;
    float factor;

    // 合并A和B
    for (i = 0; i < N; i++) {
        for (j = 0; j < N; j++) {
            A[i][j] = A[i][j];
        }
        B[i][0] = B[i][0];
    }

    // 高斯消元法
    for (k = 0; k < N; k++) {
        for (i = k + 1; i < N; i++) {
            factor = A[i][k] / A[k][k];
            for (j = k + 1; j < N; j++) {
                A[i][j] -= factor * A[k][j];
            }
            B[i][0] -= factor * B[k][0];
        }
    }

    // 回代求解
    for (k = N - 1; k >= 0; k--) {
        X[k][0] = B[k][0];
        for (i = k + 1; i < N; i++) {
            X[k][0] -= A[k][i] * X[i][0];
        }
        X[k][0] /= A[k][k];
    }
}

int main() {
    float A[N][N] = {{1, 1, 0, 0},
                     {2, 1, 1, 2},
                     {5, 3, 2, 2}};
    float B[N][1] = {{5},
                     {1},
                     {3}};
    float X[N][1];

    // 求解方程组
    gaussianElimination(A, B, X);

    // 输出解
    for (int i = 0; i < N; i++) {
        printf("X%d = %f\n", i + 1, X[i][0]);
    }

    return 0;
}

运行上述代码，我们可以得到方程组的解为：

X1 = 1.000000
X2 = 2.000000
X3 = -1.000000
X4 = 1.000000

### 回答3：
首先，我们需要将方程组转化为矩阵形式。根据给定的方程，可以得到以下矩阵：

[1 1 0 0] [x1] [5]
[2 1 1 2] * [x2] = [1]
[5 3 2 2] [x3] [3]

接下来，我们可以使用高斯消元法来求解该线性方程组。

首先，我们对第一行进行归一化处理，即将第一行的每个元素除以该行第一个元素的值。

[1 1 0 0] [x1] [5]
[2 1 1 2] * [x2] = [1]
[5 3 2 2] [x3] [3]

然后，我们将第二行乘以第一个行的第一个元素的负值，并且将结果与第一行相加，将第二行的第一个元素变为0。

[1 1 0 0] [x1] [5]
[0 -1 1 2] * [x2] = [-9]
[5 3 2 2] [x3] [3]

接下来，我们再将第三行乘以第一行的第一个元素的负值，并且将结果与第一行相加，将第三行的第一个元素变为0。

[1 1 0 0] [x1] [5]
[0 -1 1 2] * [x2] = [-9]
[0 -2 2 2] [x3] [-22]

然后，我们将第三行乘以第二行的第二个元素的负值，并且将结果与第二行相加，将第三行的第二个元素变为0。

[1 1 0 0] [x1] [5]
[0 -1 1 2] * [x2] = [-9]
[0 0 0 2] [x3] [-4]

现在，我们得到了一个上三角矩阵。接下来，我们可以通过回代法来求解方程组。

根据矩阵的最后一行，我们可以得到 x3 = -2。
然后，我们将 x3 的值代入第二行的方程中，可以得到 -x2 + x3 + 2x4 = -9。由此可以得到 x4=1。
最后，我们将 x3、x4 的值代入第一行的方程中，可以得到 x1 + x2 = 5。由此可以得到 x1=3，x2=2。

所以，方程组的一个解为：x1=3，x2=2，x3=-2，x4=1。