⑴ c語言解線性方程組的編程題 【做的好會多給分】
以下演算法的適用條件：A的各階主子式不為零
另外還可以採用
直接法：
消元法：Gauss-Jordan消元法，
分解法：Dolittle分解 （我用的是Courant分解法），追趕法，對稱正定矩陣的LDL『分解
----------
迭代法：
Jacobi迭代
Gauss-Seidel迭代
鬆弛迭代
-----------------
你上網可以搜索一下，或者看看數值計算方面的書
OK, 你看看這個, 另外還加了注釋 ：
Courant分解演算法：
aX = b, 作 A=LU, L是下三角矩陣， U是上三角矩陣
即L =
| L11
| L21 L22
| L31 L32 L33
| ..............
| Ln1 Ln2 ........Lnn
U =
| 1 U12 ..... U1n
| 空格 1 ..... U2n
| 空格 空格 ........
| 空格 空格 空格 空格 空格1
---------------------------------------------------
aX = b -----> LUX = b
記 UX = y,
由Ly = b得到
因為無法輸出數學符號，以下採用[i, j]Ai 表示對Ai從i到j求和
yi = (bi - [j=1, i-1]Lij yj) / Lii i = 1, 2, ..., n
由UX = y得到
xi = yi - [j=i+1, n]uij xj j = n, n-1, ..., 2, 1
你在紙上驗證一下就明白了
--------------------------------------------------------------
以下採用Courant分解 解 aX = b, 經檢查，程序運行正確
這是運行結果：
--------------------------------------------------------------
Input n value(dim of Ax=b): 3
Now input the matrix a(i, j), i, j = 0, ..., 2:
1 2 1 -2 -1 -5 0 -1 6
Now input the matrix b(i), i = 0, ..., 2:
24 -63 50
Solve...x_i =
7.000000
4.000000
9.000000
--------------------------------------------------------------
#include "stdafx.h"
#include <stdio.h>
#include <math.h>
#define MAX_N 20
int main(int argc, char* argv[])
{
int n; // 未知數個數
int i, j, k;
static double a[MAX_N][MAX_N], b[MAX_N], x[MAX_N], y[MAX_N];
static double l[MAX_N][MAX_N], u[MAX_N][MAX_N];
printf("\nInput n value(dim of Ax=b): ");
scanf("%d", &n);
if(n >MAX_N)
{
printf("The input n is larger than MAX_N, please redefine the MAX_N.\n");
return 1;
}
if(n <= 0)
{
printf("Please input a number between 1 and %d.\n", MAX_N);
return 1;
}
// {{ 程序輸入
printf("Now input the matrix a(i, j), i, j = 0, ..., %d:\n", n-1);
for (i=0; i<n; i++)
for (j=0; j<n; j++)
scanf("%lf", &a[i][j]);
printf("Now input the matrix b(i), i = 0, ..., %d:\n", n-1);
for(i=0; i<n; i++)
scanf("%lf", &b[i]);
// }} 程序輸入
for(i=0; i<n; i++)
u[i][i] = 1; //
for(k=0; k<n; k++)
{
for(i=k; i<n; i++) // 計算L的第k列元素
{
l[i][k] = a[i][k];
for(j=0; j<=k-1; j++)
l[i][k] -= (l[i][j]*u[j][k]);
}
for(j=k+1; j<n; j++) //計算U的第k行元素
{
u[k][j] = a[k][j];
for(i=0; i<=k-1; i++)
u[k][j] -= (l[k][i]*u[i][j]);
u[k][j] /= l[k][k];
}
}
for(i=0; i<n; i++) // 解Ly = b
{
y[i] = b[i];
for(j=0; j<=i-1; j++)
y[i] -= (l[i][j]*y[j]);
y[i] /= l[i][i];
}
for(i=n-1; i>=0; i--) // 解UX = Y
{
x[i]=y[i];
for(j=i+1; j<n; j++)
x[i] -= (u[i][j]*x[j]);
}
printf("Solve...x_i = \n"); // 輸出結果
for(i=0; i<n; i++)
printf("%f\n", x[i]);
return 0;
}
⑵ C語言創建一個線性表，然後輸出線性表，如何編寫程序
#include<stdio.h>
#include<iostream.h>
#include<stdlib.h>
#defineOVERFLOW -2
#define OK 1
#define ERROR 0
#defineLIST_INIT_SIZE 100
#defineLISTINCREMENT 10
typedef intElemType;
typedef intStatus;
//定義順序存儲結構
typedef struct
{
ElemType *elem;
int length;
int listsize;
}SqList;
//初始化順序表
StatusInitList_Sq(SqList &L)
{
L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));
if(!L.elem ) exit(ERROR);
L.length =0;
L.listsize =LIST_INIT_SIZE;
return OK;
}
//自定義創建順序表
voidCreate_SqList(SqList &L)
{
int c,i=0;
int *newBase;
printf("請輸入順序表元素：\n");
while((scanf("%d",&c))!=EOF)
{
if(i>=L.listsize) //自定義順序表大小超過初始化大小
{
newBase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType));
//為初始順序表以LISTINCREMENT大小重新增加存儲空間
if(!newBase)exit(OVERFLOW);
L.elem=newBase;
L.listsize+=LISTINCREMENT;
}
L.elem[i++]=c;
}
L.length=i;
printf("輸入的順序表元素：\n");
for(i=0;i<L.length;i++)
printf("%d ",L.elem[i]);
printf("\n");
}
//在指定位置插入元素
StatusListInsert(SqList &L,int i,ElemType e)
{
ElemType *p,*q,*newbase;
if(i<1||i>L.length+1)
{
printf("插入位置錯誤\n");
return(ERROR);
}
if(L.length>=L.listsize)
{
newbase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType));
if(!newbase) exit(OVERFLOW);
L.elem=newbase;
L.listsize+=LISTINCREMENT;
}
if(i==L.length) L.elem[i+1]=e;
q=&(L.elem[i-1]);
for(p=&(L.elem[L.length-1]);p>=q;--p)*(p+1)=*p;
*q=e;
++L.length;
return OK;
}
//在指定位置刪除元素
StatusListDelete_Sq(SqList &L,int i,ElemType *e)
{
ElemType *p,*q;
if(i<1||i>L.length+1)
return ERROR;
p=&(L.elem[i-1]);
*e=*p;
q=L.elem+L.length-1;
for(++p;p<=q;++p)
*(p-1)=*p;
--L.length ;
return OK;
}
void main()
{
SqList L;
int m,n;
int location,element;
if(!InitList_Sq(L))
{
printf("初始化順序表失敗！\n");
exit(ERROR);
}
Create_SqList(L);
for(m=0;m<3;m++)
{
printf("輸入插入位置：");
scanf("%d",&location);
while(location>L.length+1||location<1)
{
printf("輸入位置錯誤，請重新輸入！\n");
scanf("%d",&location);
}
printf("插入元素：");
scanf("%d",&element);
if(!ListInsert(L,location,element))
{
printf("順序表插入失敗！\n");
exit(ERROR);
}
printf("插入順序表為：\n");
for(int i=0;i<=L.length -1;i++)
{
printf("%d ",L.elem[i]);
}
printf("\n新順序表一共有%d個元素。\n",L.length);
}
for(n=0;n<3;n++)
{
printf("輸入刪除位置：");
scanf("%d",&location);
while(location>L.length||location<1)
{
printf("輸入位置錯誤，請重新輸入！\n");
scanf("%d",&location);
}
if(!ListDelete_Sq(L,location,&element))
{
printf("刪除錯誤！\n");
exit(ERROR);
}
printf("被刪除的元素為：%d \n",element);
printf("被刪除後的順序表為：\n");
for(int j=0;j<=L.length-1;j++)
{
printf("%d ",L.elem[j]);
}
printf("\n新順序表一共有%d個元素。\n",L.length);
}
}
這個是我最近編寫的 順序表也是線性表的
這里還有鏈表的程序 用的話再傳給你
⑶ 關於c語言的編程問題，關於線性鏈表的
SqListCreat()
{
SqListL;
intn;
printf("請輸入鏈表長度：");
scanf("%d",&n);
printf("請輸入鏈表元素： ");
for(inti=0;i<n;++i)
scanf("%d",&L.data[i]);
L.length=n;
returnL;
}
⑷ 用c語言編程求線性方程組的解
#include "stdlib.h"
#include "math.h"
#include "stdio.h"
int rgauss(n,a,b)
int n;
double a[],b[];
{ int *js,l,k,i,j,is,p,q;
double d,t;
js=malloc(n*sizeof(int));
l=1;
for (k=0;k<=n-2;k++)
{ d=0.0;
for (i=k;i<=n-1;i++)
for (j=k;j<=n-1;j++)
{ t=fabs(a[i*n+j]);
if (t>d) { d=t; js[k]=j; is=i;}
}
if (d+1.0==1.0) l=0;
else
{ if (js[k]!=k)
for (i=0;i<=n-1;i++)
{ p=i*n+k; q=i*n+js[k];
t=a[p]; a[p]=a[q]; a[q]=t;
}
if (is!=k)
{ for (j=k;j<=n-1;j++)
{ p=k*n+j; q=is*n+j;
t=a[p]; a[p]=a[q]; a[q]=t;
}
t=b[k]; b[k]=b[is]; b[is]=t;
}
}
if (l==0)
{ free(js); printf("fail\n");
return(0);
}
d=a[k*n+k];
for (j=k+1;j<=n-1;j++)
{ p=k*n+j; a[p]=a[p]/d;}
b[k]=b[k]/d;
for (i=k+1;i<=n-1;i++)
{ for (j=k+1;j<=n-1;j++)
{ p=i*n+j;
a[p]=a[p]-a[i*n+k]*a[k*n+j];
}
b[i]=b[i]-a[i*n+k]*b[k];
}
}
d=a[(n-1)*n+n-1];
if (fabs(d)+1.0==1.0)
{ free(js); printf("fail\n");
return(0);
}
b[n-1]=b[n-1]/d;
for (i=n-2;i>=0;i--)
{ t=0.0;
for (j=i+1;j<=n-1;j++)
t=t+a[i*n+j]*b[j];
b[i]=b[i]-t;
}
js[n-1]=n-1;
for (k=n-1;k>=0;k--)
if (js[k]!=k)
{ t=b[k]; b[k]=b[js[k]]; b[js[k]]=t;}
free(js);
return(1);
}
徐世良老師的.原地工作全選主元的高斯消元.用的符號有點詭異,而且將矩陣以線性表輸入的.
我也寫過一個,不過估計你不太喜歡用我的,這個用來解b也是矩陣的.
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
void swap(double *a,double *b){
double temp;
temp=*a;
*a=*b;
*b=temp;
}
void printMatrix(int n,int m,double **a){
int i,j;
for (i=0;i<n;i++){
for (j=0;j<m;j++) printf("%e\t",a[i][j]);
printf("\n");
}
}
int rgauss(int n,int m,double **a,double **b){//,double *det){
int *colex,rowex,s,i,j,k;
double d,t;
// *det=1;
s=0;
colex=malloc(n*sizeof(int));
for (k=0;k<n;k++){
d=0.0;
for (i=k;i<n;i++){
for (j=k;j<n;j++){
t=fabs(a[i][j]);
if (t>d){
d=t;
colex[k]=j;
rowex=i;
}
}
}
if (d+1.0==1.0){
free(colex);
printf("Singular Matrix!\n");
return 0;
}
else{
if (colex[k]!=k){
for (i=0;i<n;i++)
swap(a[i]+colex[k],a[i]+k);
s=s+colex[k]-k;
}
if (rowex!=k){
for (j=0;j<n;j++)
swap(a[rowex]+j,a[k]+j);
for (j=0;j<m;j++)
swap(b[rowex]+j,b[k]+j);
s=s+rowex-k;
}
}
d=a[k][k];
// *det=*det*d;
for (j=k+1;j<n;j++) a[k][j]/=d;
for (j=0;j<m;j++) b[k][j]/=d;
for (i=k+1;i<n;i++){
for (j=k+1;j<n;j++)
a[i][j]-=a[i][k]*a[k][j];
for (j=0;j<m;j++)
b[i][j]-=a[i][k]*b[k][j];
}
}
for (i=n-2;i>-1;i--)
for (j=i+1;j<n;j++)
for (k=0;k<m;k++)
b[i][k]-=a[i][j]*b[j][k];
colex[n-1]=n-1;
for (i=n-1;i>-1;i--)
if (colex[i]!=i)
for (j=0;j<m;j++) swap(b[colex[i]]+j,b[i]+j);
// if (s&1) *det=-*det;
return 1;
}
void main(){
#define N 2
#define M 1
double input_a[]={1,1,1,2};
double input_b[]={1,2};
double *a[N],*b[N];
int i;
for (i=0;i<N;i++){
a[i]=input_a+N*i;
b[i]=input_b+M*i;
}
rgauss(N,M,a,b);
printf("方程解為:\n");
printMatrix(N,M,b);
printf("\n");
}
⑸ C語言線性基本操作表新手求教
你的第一個問題：為什麼返回的是realen，L是一個節點，L->realen就是L節點中的realen。所以自然就是realen。
你的第二個問題： realen數值是從哪兒來的，我大概看了一下，涉及到realen的地方有幾個函數：創建線性表，銷毀線性表，添加元素和刪除元素這四個函數。realen的初始值就0（創建線性表的時候賦值），這幾個函數在運行過程中會改變realen的值。
至於你的第三個和第四個問題的話，你表達不是很清楚，請說明清楚。我會繼續回答。
什麼的返回值是8？省略哪一些代碼？
⑹ 用C語言編寫一個線性插值程序
#include<stdio.h>
doubleLerp(doublex0,doubley0,doublex1,doubley1,doublex)
{
doubledy=y1-y0;
if(dy==0){
printf("除0錯誤！ ");
return0;
}
returnx*(x1-x0)/dy;
}
intmain()
{
doublex0,x1,y1,y0,x,y;
printf("Inptux0y0x1y1x:");
scanf("%lf%lf%lf%lf%lf",&x0,&y0,&x1,&y1,&x);
y=Lerp(x0,y0,x1,y1,x);
printf("y=%lf ",y);
return0;
}
⑺ c語言數據結構順序線性表編程
void
SeqListlong(SeqList
L)//輸出順序線性表的長度
這個是沒有返回值的
改成INT
while(i<=L.last&&L.data[i-1]!=x) i++;應該是i--. for(j=L.last-1;j>=i-1;j--) L.data[j+1]=L.data[j];既然是倒敘
又怎麼可以往後調換
⑻ 線性表的基本操作c語言實現
代碼如下：
頭文件：
2_1.h
#ifndef _2_1_H
#define _2_1_H
typedef void SeqList;
typedef void SeqListNode;
//創建線性表
SeqList * SeqList_Create(int capacity);
//銷毀線性表
void SeqList_DesTroy(SeqList * list);
void SeqList_Clear(SeqList* list);
int SeqList_Length(SeqList* list);
int SeqList_Capacity(SeqList* list);
int SeqList_Insert(SeqList* list, SeqListNode* node, int pos);
SeqListNode* SeqList_Get(SeqList* list, int pos);
SeqListNode* SeqList_Delete(SeqList* list, int pos);
#endif
源文件：
// 順序線性表.cpp : 定義控制台應用程序的入口點。
//
#include "stdafx.h"
#include <malloc.h>
#include <stdlib.h>
#include "2_1.h"
typedef unsigned int TSeqListNode;
typedef struct {
int len; //長度
int capacity;//總長度
TSeqListNode * node;//每個節點的指針
} TSeqList;
int main()
{
SeqList* list = SeqList_Create(5);//創建線性表
int i = 6;//賦值6個變數，已超過線性表最大值 5
int j = 1;
int k = 2;
int x = 3;
int y = 4;
int z = 5;
int index = 0;
SeqList_Insert(list, &i, 7); //將這6個變數插入線性表中
SeqList_Insert(list, &j, 0);
SeqList_Insert(list, &k, 0);
SeqList_Insert(list, &x, 0);
SeqList_Insert(list, &y, 0);
SeqList_Insert(list, &z, 0);
//遍歷
for(index=0; index<SeqList_Length(list); index++)
{
int* p = (int*)SeqList_Get(list, index);
printf("%d ", *p);
}
printf(" ");
//刪除操作
while( SeqList_Length(list) > 0 )
{
int* p = (int*)SeqList_Delete(list, 0);
printf("刪除了： %d ", *p);
}
SeqList_Clear(list);
SeqList_DesTroy(list);
system("pause");
return 0;
}
//創建線性表
SeqList * SeqList_Create(int capacity)
{
TSeqList* ret = NULL ;
if(capacity >= 0)
{
ret = (TSeqList*)malloc(sizeof(TSeqList) + sizeof(TSeqListNode)*capacity); //為線性表分配空間，包含結 //構體和節點的總大小
}
if(NULL != ret)
{
ret->len = 0;
ret->capacity = capacity;
ret->node = (TSeqListNode*)(ret + 1);//將節點指向上述分配到的空間的後部分
}
return ret;
}
//銷毀
void SeqList_DesTroy(SeqList * list)
{
free(list);
}
//清空
void SeqList_Clear(SeqList* list)
{
TSeqList * ret = (TSeqList*)list;
if(NULL != ret)
{
ret->len = 0;
}
}
//獲得線性表的長度
int SeqList_Length(SeqList* list)
{
TSeqList * ret = (TSeqList*)list;
int len = -1;
if(NULL != ret)
{
len = ret->len;
}
return len;
}
//線性表的總長度
int SeqList_Capacity(SeqList* list)
{
TSeqList * ret = (TSeqList*)list;
int capacity = -1;
if(NULL != ret)
{
ret->capacity = capacity;
}
return capacity;
}
//插入
int SeqList_Insert(SeqList* list, SeqListNode* node, int pos)
{
TSeqList * sList = (TSeqList*)list;
int i,ret = -1;
if((sList != NULL) &&(pos >= 0) && sList->capacity >= sList->len+1)
{
if(pos >= sList->len)
{
pos = sList->len;
}
for(i = sList->len; i > pos; i--)
{
sList->node[i] = sList->node[i-1];
}
sList->node[i] = (TSeqListNode)node;
++sList->len;
ret = 1;
}
return ret;
}
//獲得指定位置的節點
SeqListNode* SeqList_Get(SeqList* list, int pos)
{
TSeqList * sList = (TSeqList*)list;
TSeqListNode* node = NULL;
if(NULL != sList && pos>=0 && pos < sList->len)
{
node = (TSeqListNode*)sList->node[pos];
}
return node;
}
//刪除
SeqListNode* SeqList_Delete(SeqList* list, int pos)
{
TSeqList * sList = (TSeqList*)list;
SeqListNode * node = SeqList_Get( list, pos);
int i;
if(sList != NULL && pos >= 0 && pos< sList->len)
{
for( i=pos+1; i<sList->len; i++)
{
sList->node[i-1] = sList->node[i];
}
sList->len--;
}
return node;
}
演示：
資料拓展：
線性表是最基本、最簡單、也是最常用的一種數據結構。
線性表中數據元素之間的關系是一對一的關系，即除了第一個和最後一個數據元素之外，其它數據元素都是首尾相接的（注意，這句話只適用大部分線性表，而不是全部。比如，循環鏈表邏輯層次上也是一種線性表（存儲層次上屬於鏈式存儲），但是把最後一個數據元素的尾指針指向了首位結點）。
我們說「線性」和「非線性」，只在邏輯層次上討論，而不考慮存儲層次，所以雙向鏈表和循環鏈表依舊是線性表。
在數據結構邏輯層次上細分，線性表可分為一般線性表和受限線性表。一般線性表也就是我們通常所說的「線性表」，可以自由的刪除或添加結點。受限線性表主要包括棧和隊列，受限表示對結點的操作受限制。
線性表的邏輯結構簡單，便於實現和操作。因此，線性表這種數據結構在實際應用中是廣泛採用的一種數據結構。
⑼ 求一用c語言編程的可以運行的線性表的初始化、插入和刪除操作。希望不要與網上雷同，做學慣用。
#include <stdio.h>
#include <malloc.h>
# define MaxSize 50
typedef struct{
ElemType data[MaxSize];//存放順序表元素
int length;//存放順序表長度
}SqList;//順序表類型定義
//建立順序表
void CreateList(SqList *&L,ElemType a[],int n){
int i;
for(i=0;i<n;i++){
L->data [i]=a[i];
}
L->length =n;
}
//順序表基本運算演算法
//初始化線性表InitList（L）
void InitList(SqList *&L){
L=(SqList *)malloc(sizeof(SqList));//分配存放線性表的空間
L->length =0;
}//本演算法的時間復雜度為O(1)
//銷毀線性表
void DestroyList(SqList *&L){
free(L);
}//本演算法的時間復雜度為O(1)
//判斷線性表是否為空
int ListEmpty(SqList *L){
return (L->length ==0);
}//本演算法的時間復雜度為O(1)
//求線性表的長度
int ListLength(SqList *L){
return (L->length);
}//本演算法的時間復雜度為O(1)
//輸出線性表
void DispList(SqList *L)
{
int i;
if(ListEmpty(L)) return;
for(i=0;i<L->length;i++){
printf(nn,L->data[i]);
}
printf("\n");
}//本演算法的時間復雜度為O(L->length)
//求線性表中某個數據的元素值
int GetElem(SqList *L,int i,ElemType &e)
{
if(i<1||i>L->length)
return 0;
e=L->data[i-1];//這兒體現了數組的優點，可以直接通過下標訪問
return 1;
}//本演算法的時間復雜度為O(1)
//按元素的值查找
int LocateElem(SqList *L,ElemType e){
int i=0;
while(i<L->length && L->data[i]!=e)i++;
if(i>=L->length)
return 0;
else
return i+1;
}//本演算法中基本運算為while循環中的i++語句，故時間復雜度為O(L->length)
//插入數據元素
int ListInsert(SqList *&L,int i,ElemType e){
int j;
if(i<1 || i>L->length+1)
return 0;//參數錯誤，返回0
i--;//將順序邏輯位序變為物理位序
for(j=L->length;j>i;j--){
L->data[j]=L->data[j-1];//將data[i]及後面的元素後移一個位置
}
L->data[i]=e;//插入元素e
L->length++;//增加長度
return 1;
}//本演算法的平均時間復雜度為O(n)
//刪除數據元素
int ListDelete(SqList *&L,int i,ElemType &e){
int j;
if(i<1 || i>L->length)
return 0;
i--;//將順序邏輯位序變為物理位序
e=L->data[i];
for(j=i;j<L->length-1;j++){
L->data[j]=L->data[j+1];//將data[i]之後的元素前移一個位置，這就是數組中的刪除思想
}
L->length--;
return 1;
}//本演算法的平均時間復雜度為O(n)