方程求根计算器实验报告一C++版.docx
《方程求根计算器实验报告一C++版.docx》由会员分享，可在线阅读，更多相关《方程求根计算器实验报告一C++版.docx（21页珍藏版）》请在冰豆网上搜索。
方程求根计算器实验报告一C++版
计算方法实验
题目：
班级：
学号：
姓名：
1实验目的
1.通过编程加深二分法、牛顿法和割线法求解多项式方程的理解
2.观察上述三种方法的计算稳定性和求解精度并比较各种方法利弊
2实验步骤
2.1环境配置：
VS2013，C++控制台程序
2.2添加头文件
#include"stdio.h"
#include"stdlib.h"
#include"stdafx.h"
2.3主要模块
程序一共分成三层，最底层是数据结构部分，负责存储数据，第二层是交互部分，即多项式方程部分，负责输入输出获得数据，最上层是核心的算法部分，负责处理已获得的数据。
主函数负责获取方程系数并显示，算法和方程作为后台程序，顺序表作为存储手段。
3代码
3.1主程序部分
//squencelistandlinklist1.cpp:
定义控制台应用程序的入口点。
//
#include"stdio.h"
#include"stdlib.h"
#include"stdafx.h"
#include"squencelist.h"
#include"equation.h"
#include
///////////////////////////////////主程序//////////////////////////////////////
int_tmain（intargc,_TCHAR*argv[]）
{
GetEquation（）;
ShowMenu（）;
return0;
}
3.2多项式方程部分
●方程部分头文件
#ifndef_EQUATION_H
#define_EQUATION_H
#include"squencelist.h"
#include"stdio.h"
#include"stdlib.h"
externinthighestx;
externsequenlist*B;
externsequenlist*D;
doubleFunction（sequenlist*B,doublex）;
voidGetEquation（void）;
voidShowMenu（void）;
voidprintfunction（sequenlist*A）;
sequenlistDerivative（sequenlist*A,inthighestx）;
#endif
●方程部分CPP文件
#include"stdafx.h"
#include"equation.h"
#include"math.h"
#include"algorithm.h"
#include"squencelist.h"
//全局变量
inthighestx=0;
sequenlist*B;
sequenlist*D;
//////////////////////////多项式函数///////////////////////////
doubleFunction（sequenlist*A,doublex）
{
doublef=0.00;
inti;
for（i=1;i<=A->last;i++）
f=f+A->data[i]*pow（x,A->last-i）;
returnf;
}
////////////////////////多项式函数系数/////////////////////////
voidGetEquation（void）
{
intj=0;
intx=0;
B=InitList（）;
cout<<"方程最高项次数（如y=x^3最高项次数为3）：
"<cin>>highestx;
cout<<"输入方程系数,输入00结束（如y=x^2+2x+1输入12100）:
"<cin>>x;
while（x!
=00）
{
for（j=1;j<=highestx+1;j++）
{
if（!
Insert（B,x,j））exit（0）;
cin>>x;
}
}
j=1;
printfunction（B）;
}
//////////////////////////显示交互/////////////////////////////
voidShowMenu（void）
{
intx;
doublea,b,ex,ef,res,x0,x1;
cout<<"选择求解方程根的方法：
"<cout<<"1.二分法求解"<cout<<"2.牛顿迭代法求解"<cout<<"3.割线法求解"<cin>>x;
switch（x）
{
case1:
cout<<"请输入区间上下限（如【a,b】输入ab）：
"<cin>>a>>b;
cout<<"请输入根的容许误差和函数的容许误差（若只有一个误差则另一项为0）：
"<cin>>ex>>ef;
res=Dichotomy（a,b,ex,ef）;
break;
case2:
cout<<"请输入初始值x0：
"<cin>>x0;
cout<<"请输入根的容许误差和函数的容许误差（若只有一个误差则另一项为0）：
"<cin>>ex>>ef;
res=Newtonsmethod（x0,ex,ef）;
break;
case3:
cout<<"请输入初始值x0,x1：
"<cin>>x0>>x1;
cout<<"请输入根的容许误差和函数的容许误差（若只有一个误差则另一项为0）：
"<cin>>ex>>ef;
res=Cutmethod（x0,x1,ex,ef）;
break;
default:
break;
}
}
////////////////////////打印输出函数///////////////////////////
voidprintfunction（sequenlist*A）
{
inti;
cout<<"f=";
for（i=1;ilast;i++）
{
if（A->data[i+1]<0）
cout<data[i]<<"*"<<"x^"<last-i;
elsecout<data[i]<<"*"<<"x^"<last-i<<"+";
}
cout<data[i]<}
//////////////////////////函数微分/////////////////////////////
sequenlistDerivative（sequenlist*A,inthighestx）
{
inti;
D=InitList（）;
for（i=1;i<=A->last;i++）
Insert（D,（A->data[i]*（A->last-i））,i）;
D->last=A->last-1;
return*D;
}
3.3核心算法部分
●算法部分头文件
#ifndef_ALGORITHM_H
#define_ALGORITHM_H
#include"stdio.h"
#include"stdlib.h"
intJudge（doublex1,doublex0,doublee）;
doubleDichotomy（doublexa,doublexb,doubleex,doubleef）;
doubleNewtonsmethod（doublex0,doubleex,doubleef）;
doubleCutmethod（doublex1,doublex0,doubleex,doubleef）;
#endif
●算法部分CPP文件
#include"algorithm.h"
#include"stdafx.h"
#include"squencelist.h"
#include"equation.h"
//////////////////////////误差判别////////////////////////////
inlineintJudge（doublex1,doublex0,doublee）
{
if（e==0）
return0;
if（x1==0）
{
if（fabs（x0）elsereturn0;
}
if（x0==0）
{
if（fabs（x1）elsereturn0;
}
if（fabs（x1-x0）return1;
elsereturn0;
}
//////////////////////////二分法////////////////////////////
doubleDichotomy（doublexa,doublexb,doubleex,doubleef）
{
cout<<"///////////////////二分法///////////////////"<doublexn=0,fn=0,fa=Function（B,xa）,fb=Function（B,xb）;
doublea,b;
intn=1,flag=0;
a=xa;
b=xb;
cout<<"二分次数"<<"\t"<<'x'<<"\t\t"<<"f（x）"<if（fa*fb>0）
{
cout<<"无法使用二分法"<flag=1;
}
while
（1）
{
if（fa==0）
{
xn=xa;
cout<break;
}
if（fb==0）
{
xn=xb;
cout<break;
}
xn=（a+b）/2;
fn=Function（B,xn）;
cout<if（fn==0）break;
if（fn*fa<0）
{
b=xn;
flag=（Judge（a,b,ex）||Judge（fn,0,ef））;
}
elseif（fn*fb<0）
{
a=xn;
flag=（Judge（a,b,ex）||Judge（fn,0,ef））;
}
if（flag）break;
}
returnxn;
}
//////////////////////////牛顿迭代法////////////////////////////
doubleNewtonsmethod（doublex0,doubleex,doubleef）
{
doublexn=0,fn=0,dfn=0;
intn=1,flag=0;
cout<<"///////////////////牛顿迭代法///////////////////"<cout<<"迭代次数"<<"\t"<<"x"<<"\t\t"<<"f（x）"<*D=Derivative（B,highestx）;
fn=Function（B,x0）;
dfn=Function（D,x0）;
if（fabs（fn）while
（1）
{
if（dfn==0）
{
cout<<"导数为零"<break;
}
xn=x0-fn/dfn;
fn=Function（B,x0）;
dfn=Function（D,x0）;
flag=（Judge（xn,x0,ex）||Judge（fn,0,ef））;
if（flag）break;
x0=xn;
cout<if（n>3000）
{
cout<<"迭代失败"<return0;
}
}
returnxn;
}
//////////////////////////割线法////////////////////////////
doubleCutmethod（doublex1,doublex0,doubleex,doubleef）
{
doublexn,fn,f0,f1;
intn=1,flag=0;
cout<<"///////////////////割线法///////////////////"<cout<<"迭代次数"<<"\t"<<"x"<<"\t\t"<<"f（x）"<*D=Derivative（B,highestx）;
f0=Function（B,x0）;
f1=Function（B,x1）;
if（fabs（f0）{
cout<returnx0;
}
if（fabs（f1）{
cout<returnx1;
}
if（Judge（x1,x0,ex））
{
cout<returnx1;
}
while（!
flag）
{
xn=x1-f1*（x1-x0）/（f1-f0）;
fn=Function（B,xn）;
flag=（Judge（xn,x1,ex）||Judge（fn,0,ef））;
cout<x0=x1;
x1=xn;
if（n>3000）
{
cout<<"迭代失败"<return0;
}
}
returnxn;
}
3.4数据结构部分
●数据结构头文件
#ifndef_SQUENCELIST_H
#define_SQUENCELIST_H
#include"stdio.h"
#include"stdlib.h"
#include"stdafx.h"
#include
usingnamespacestd;
#definemaxsize1024
/**
*sequenlist
*/
typedefintdatatype;
typedefstruct
{
datatypedata[maxsize];
intlast;
}sequenlist;
sequenlist*InitList（）;
intLength（sequenlist*）;
intInsert（sequenlist*,datatype,int）;
intDelete（sequenlist*,int）;
intLocate（sequenlist*,datatype）;
voiddel_node（sequenlist*,datatype）;
voidPrintList（sequenlist*）;
intCompare_L（sequenlist*,sequenlist*）;
voidInvert（sequenlist*）;
/**
*linklist
*/
typedefcharlinkdatatype;
typedefstructnode
{
linkdatatypedata;
structnode*next;
}linklist;
linklist*CreateListF（）;
#endif
●数据结构CPP文件
#include"stdafx.h"
#include"squencelist.h"
///////////////////////////////////数据结构部分///////////////////////////////////////////
///////////////////////////////////sequenlist///////////////////////////////////////////
sequenlist*InitList（）
{
sequenlist*L=（sequenlist*）malloc（sizeof（sequenlist））;
L->last=0;
returnL;
//sequenlist*L=newsequenlist;
}
intLength（sequenlist*L）
{
returnL->last;
}
intInsert（sequenlist*L,datatypex,inti）
{
intj;
if（L->last>=maxsize-1）
{
cout<<"表已满"<return0;
}
for（j=L->last;j>=i;j--）
L->data[j+1]=L->data[j];
L->data[i]=x;
L->last++;
return1;
}
intDelete（sequenlist*L,inti）
{
intj;
if（（i<1）||（i>L->last））
{
cout<<"非法删除位置"<return0;
}
for（j=i;j<=L->last;j++）
L->data[j]=L->data[j+1];
L->last--;
return1;
}
intLocate（sequenlist*L,datatypex）
{
inti=1;
while（i<=L->last）
{
if（L->data[i]!
=x）i++;
elsereturni;
}
return0;
}
/*顺序表中删除所有元素为x的结点*/
voiddel_node（sequenlist*L,datatypex）
{
inti=Locate（L,x）;
while（i!
=0）
{
if（!
Delete（L,i））break;
i=Locate（L,x）;
}
}
voidPrintList（sequenlist*L）
{
inti=1;
for（i=1;i<=L->last;i++）
cout<data[i]<<'';
cout<}
intCompare_L（sequenlist*A,sequenlist*B）
{
intj=1;
inti=0;
intn,m;
n=A->last;
m=B->last;
while（（j<=n）&&（j<=m））
{
if（A->data[j]==B->data[j]）i=0;
if（A->data[j]data[j]）
{
i=-1;
break;
}
if（A->data[j]>B->data[j]）
{
i=1;
break;
}
j++;
}
if（i!
=0）returni;
else
{
if（mif（nif（m==n）i=0;
returni;
}
}
voidInvert（sequenlist*L）
{
inti;
inttemp;
for（i=1;i<=L->last/2;i++）
{
temp=L->data[i];
L->data[i]=L->data[L->last+1-i];
L->data[L->last+1-i]=temp;
}
}
///////////////////////////////////linklist///////////////////////////////////////////
linklist*CreateListF（）
{
linklist*head,*p;
charch;
升级会员 