Gauss-Seidal implementation
A word of warning: I am very much a C newbie myself, so it may be good to take my advice with a grain of salt.

Formatting

The only good thing I can say about your formatting is that it's consistent. But a 1-space indent really isn't readable. I recommend 4 spaces instead. Please put some whitespace around your operators: a space after every comma, a space on each side of =, -, +, *, …. Don't cram multiple assignments on one line: I find

int i, j, k;


or

int i = 0;
int j = 0;
int k = 0;


acceptable, but not int i=0,j=0,k=0;.

If you are targetting a C89-compatible environment, this is as far as we can go. I recommend you move on (e.g. to C++ or C99), where we can put the declaration of for-loop variables inside the loop itself:

for (int i = 0; i &lt; whatever; i++)


… and we also don't have to put all declarations at the top of each scope – just declare your variables at the point of first use.

malloc and error handling

Always check the return value of malloc:

float *temp = (float*) malloc(row * sizeof(float));
if (temp == NULL)
{
    /* return some error code */
}


C isn't object oriented, but whatever

You always bundle the three variables mat, row, col. I suggest you put those into a struct, and pass this single struct around instead:

typedef struct {
    float **mat;
    int rows;
    int cols;
} Matrix;


I would then create a Matrix_new function that creates and populates an instance, e.g.

// this code assumes C99. Ignore my more compact brace style.

/**
 * Allocates a new `Matrix` instance. Returns a pointer to the instance on
 * success, a `NULL` pointer on failure.
 *
 * A Matrix must always be freed via `Matrix_destroy(instance)`!
 */

Matrix*
Matrix_new(int rows, int cols) {

    Matrix* matrix = (Matrix*) malloc(sizeof(Matrix));
    if (matrix == NULL) {
        return NULL;
    }

    float** mat = (float**) malloc(rows * sizeof(float*));
    if (mat == NULL) {
        free(matrix);
        return NULL;
    }

    for (int i = 0; i &lt; rows; i++) {
        float* row = (float*) malloc(cols * sizeof(float));
        if (row == NULL) {
            // if a row allocation fails, we have to `free` the previous rows.
            i--;
            for (; i &gt;= 0; i--) {
                free(mat[i]);
            }
            free(mat);
            free(matrix);
            return NULL;
        }

    }

    matrix-&gt;mat  = mat;
    matrix-&gt;rows = rows;
    matrix-&gt;cols = cols;
    return matrix;
}


and of course, a mirroring Matrix_destroy:

/**
 * Safely frees a Matrix instance.
 */

int
Matrix_destroy(Matrix* matrix) {

    if (matrix == NULL) {
        return 0;
    }

    float** mat = matrix-&gt;mat;
    int rows = matrix-&gt;rows;

    for (int i = 0; i &lt; rows; i++) {
        free(mat[i]);
    }

    free(mat);
    free(matrix);

    return 1;
}


Then, you can rewrite your other methods to take advantage of this bundling.

Return values

Very often (e.g. in final_result, create_mat, feed_mat), you return a pointer from your function even when that pointer was an argument to that function. It is generally preferable to return an error code, and to return values via pointers/out-arguments.

For example, final_result could be changed to:

/**
 * Calculates the final result.
 *
 * Returns an error code.
 *
 * After successful execution, the `out_result` pointer will point to the 
 * result, which is a `float*` of `self-&gt;rows` length. The caller owns the
 * result, and is responsible for calling `free(*out_result)`.
 *
 * Example usage:
 *
 *     float *result;
 *     if (! final_result(matrix, &amp;result)) {
 *         // abort with error
 *     }
 *     // do something with `result`:
 *     for (int i = 0; i &lt; matrix-&gt;rows; i++) {
 *         printf("%f\n", result[i]);
 *     }
 *     free(result);
 */

int
final_result(Matrix* self, float** out_result) {
    if (self == NULL) {
        return 0;
    }

    float* temp = (float*) malloc(self-&gt;rows * sizeof(float));
    if (temp == NULL) {
        return 0;
    }

    float* result = (float*) malloc(self-&gt;rows * sizeof(float));
    if (result == NULL) {
        free(temp);
        return 0;
    }

    for (int i = 0; i &lt; self-&gt;rows; i++) {
        temp[i]   = 0;
        result[i] = 0;
    }

    printf("Processing result...\n");

    do {
        for (int i = 0; i &lt; self-&gt;rows; i++) {
            float T = 0;
            for (int j = 0; j &lt; self-&gt;cols - 1; j++) {
                if (i != j) {
                    T += self-&gt;mat[i][j] * temp[j];
                }
            }
            result[i] = (self-&gt;mat[i][self-&gt;cols - 1] - T) / self-&gt;mat[i][i];
            temp[i] = result[i];
        }
    } while (condition(result, temp, self-&gt;rows) == 0);

    free(temp);
    *out_result = result;
    return 1;
}


Miscellaneous Helper Functions

memset

When zeroing all elements in some data structure, you can often use memset from string.h instead:

temp=(float*)malloc((row)*sizeof(float));//Edit: row-1 changed to row
for(i=0;i&lt;row;i++)
{
 temp[i] = 0;
}


becomes

float* temp = (float*) malloc(row * sizeof(float));
if (temp == NULL) {
    // return error code
}
memset(temp, 0, row * sizeof(float));


fabsf

If you are interested in an absolute value of a float, use the fabsf function from math.h. With it, your condition function simplifies to:

int
condition(float* result, float* temp, int row) {
    int flag = 0;

    for (int i = 0; i &lt; row; i++) {
        if (fabsf(temp[i] - result[i]) &lt; chk_end) {
            flag = 1;
        }
        else {
            flag = 0;
            break;
        }
    }

    return flag;
}