解线性方程组 -- 业余空间-- 编程爱好者博客

/*按规则输入线性方程组的系数（每行N+1个数值，按顺序输入N个系数项，最后一项为常数项，用空格隔开）
，输出该方程组的系数行列式和它的值，最后输出方程组的解*/
/*处理整型数据*/
/*2006-1-7 梁见斌*/

#include <stdio.h>
#include <stdlib.h>
#define N 4 //行列式的行（列）数

typedef struct node
{
int data; //存储元素的值
int x; //存储元素的横坐标
int y; //存储元素的纵坐标
} array;

int sum; //全局变量，存储行列式的值

void Create(int H[][N], int X[]); //构造一个线性方程组
void PrintH(const int H[][N], const int X[]); //输出行列式
void Solve(const int H[][N], array S[], int i, int NiXu); //采用递归方式求行列式的值
bool Judge(const array S[], int line, int len); //判断行列式的元素的纵坐标是否重复

int main(void)
{
array SL[N]; //栈，存储行列式的每一个乘积项的元素（因子）
int H[N][N], CH[N][N]; //存储系数行列式
int B[N]; //存储常数项
int D; //存储系数行列式的值
float X[N];//存储方程组的解
int i, j, k;

Create(H,B); //构造一个行列式
PrintH(H,B); //输出行列式
sum = 0;
Solve(H, SL, 0, 0); //采用递归方式求行列式的值
D = sum;
printf("D = %d\n", D); //输出系数行列式的值
for(k=0; k<N; k++)
{
  for(i=0; i<N; i++) //复制行列式
  {
   for(j=0; j<N; j++)
    CH[i][j] = H[i][j];
   CH[i][k] = B[i]; //把系数行列式D中第k列的元素用方程组右端的常数项代替
  }
  sum = 0;
  Solve(CH, SL, 0, 0); //采用递归方式求行列式的值
  printf("D%d = %d\n", k+1, sum); //输出该行列式的值
  X[k] = sum*1.0 / (D*1.0);
}
for(i=0; i<N; i++)
   printf("X%d = %f\n", i+1, X[i]); //输出该行列式的值
system("pause");
return 0;
}
void Create(int H[][N], int X[])
{
int i, j;

puts("请按标准格式输入行列式：每行N+1个数值，按顺序输入N个系数项，最后一项为常数项，用空格隔开");
for(i=0; i<N; i++)
{
  for(j=0; j<N; j++)
   scanf("%d", &H[i][j]); //输入系数项
  scanf("%d", &X[i]);//输入常数项
  fflush(stdin);
}
}
void PrintH(const int H[][N], const int X[])
{
int i, j;

for(i=0; i<N; i++)
{
  for(j=0; j<N; j++)
   printf("%d ", H[i][j]);
  printf("\t%d", X[i]);
  printf("\n");
}
}
void Solve(const int H[][N], array S[], int i, int NiXu)//采用递归方式求行列式的值
{
array CS[N]; //栈，存储S[]的拷贝
int j, k, top = i;
int mul; //存储每一个乘积项的值
int CNiXu; //累积每一个乘积项的逆序数

for(j=0; j<N; j++)
{
  if(Judge(S, j, top))//如果当前元素的纵坐标不与栈中存储的元素重复，将其入栈
  {
   S[top].x = i;
   S[top].y = j;
   S[top].data = H[i][j];
   CNiXu = NiXu; //把逆序数复制到CNiXu
   for(k=0; k<top; k++)
   {
    if(j < S[k].y) //累积逆序数
     CNiXu++;
   }
   for(k=0; k<=top; k++) //复制栈
    CS[k] = S[k];
   if(i<N-1) //如果未分析到该乘积项的最后一个元素，递归继续分析
    Solve(H, CS, i+1, CNiXu);
   else //否则计算该乘积项的值，并存储到栈中
   {
    for(mul=1, k=0; k<=top; k++)
     mul *= S[k].data;
    if(CNiXu%2==0) //如果逆序数为偶数，该乘积项为正
     sum += mul;
    else //否则为负
     sum -= mul;
   }
  }
}
}
bool Judge(const array S[], int line, int len)
{
int i;

for(i=0; i<len; i++)
  if(line == S[i].y)
   return 0;
return 1;
}
/*按规则输入线性方程组的系数（每行N+1个数值，按顺序输入N个系数项，最后一项为常数项，用空格隔开）
，输出该方程组的系数行列式和它的值，最后输出方程组的解*/
/*处理实型数据*/
/*2006-1-7 梁见斌*/
#include <stdio.h>
#include <stdlib.h>
#define N 4 //行列式的行（列）数

typedef struct node
{
float data; //存储元素的值
int x; //存储元素的横坐标
int y; //存储元素的纵坐标
} array;

float sum; //全局变量，存储行列式的值

void Create(float H[][N], float X[]); //构造一个行列式
void PrintH(const float H[][N], const float X[]); //输出行列式
void Solve(const float H[][N], array S[], int i, int NiXu);//采用递归方式求行列式的值
bool Judge(const array S[], int line, int len); //判断行列式的元素的纵坐标是否重复

int main(void)
{
array SL[N]; //栈，存储行列式的每一个乘积项的元素（因子）
float H[N][N], CH[N][N];//存储系数行列式
float B[N]; //存储常数项
float D, X[N]; //分别存储系数行列式的值和方程组的解
int i, j, k;

Create(H,B); //构造一个行列式
PrintH(H,B); //输出行列式
sum = 0;
Solve(H, SL, 0, 0); //采用递归方式求行列式的值
D = sum;
printf("D = %f\n", D); //输出该行列式的值
for(k=0; k<N; k++)
{
  for(i=0; i<N; i++) //复制行列式
  {
   for(j=0; j<N; j++)
    CH[i][j] = H[i][j];
   CH[i][k] = B[i]; //把系数行列式D中第k列的元素用方程组右端的常数项代替
  }
  sum = 0;
  Solve(CH, SL, 0, 0); //采用递归方式求行列式的值
  printf("D%d = %f\n", k+1, sum); //输出该行列式的值
  X[k] = sum / D;
}
for(i=0; i<N; i++)
   printf("X%d = %f\n", i+1, X[i]); //输出该行列式的值
system("pause");
return 0;
}
void Create(float H[][N], float X[])
{
int i, j;

puts("请按标准格式输入行列式：每行N+1个数值，按顺序输入N个系数项，最后一项为常数项，用空格隔开");
for(i=0; i<N; i++)
{
  for(j=0; j<N; j++)
   scanf("%f", &H[i][j]); //输入系数项
  scanf("%f", &X[i]); //输入常数项
  fflush(stdin);
}
}
void PrintH(const float H[][N], const float X[])
{
int i, j;

for(i=0; i<N; i++)
{
  for(j=0; j<N; j++)
   printf("%f ", H[i][j]);
  printf("\t%f", X[i]);
  printf("\n");
}
}
void Solve(const float H[][N], array S[], int i, int NiXu)//采用递归方式求行列式的值
{
array CS[N]; //栈，存储S[]的拷贝
int j, k, top = i;
float mul; //存储每一个乘积项的值
int CNiXu; //累积每一个乘积项的逆序数

for(j=0; j<N; j++)
{
  if(Judge(S, j, top))//如果当前元素的纵坐标不与栈中存储的元素重复，将其入栈
  {
   S[top].x = i;
   S[top].y = j;
   S[top].data = H[i][j];
   CNiXu = NiXu; //把逆序数复制到CNiXu
   for(k=0; k<top; k++)
   {
    if(j < S[k].y) //累积逆序数
     CNiXu++;
   }
   for(k=0; k<=top; k++) //复制栈
    CS[k] = S[k];
   if(i<N-1) //如果未分析到该乘积项的最后一个元素，递归继续分析
    Solve(H, CS, i+1, CNiXu);
   else //否则计算该乘积项的值，并存储到栈中
   {
    for(mul=1, k=0; k<=top; k++)
     mul *= S[k].data;
    if(CNiXu%2==0) //如果逆序数为偶数，该乘积项为正
     sum += mul;
    else //否则为负
     sum -= mul;
   }
  }
}
}
bool Judge(const array S[], int line, int len)
{
int i;

for(i=0; i<len; i++)
  if(line == S[i].y)
   return 0;
return 1;
}

博客介绍

正文

解线性方程组2006-01-07 12:10:00

评论