c++复习

using namespace std;

class MyClass{

public:

MyClass(int i=0)

{cout<<1;}

MyClass(const MyClass&x)

{cout<<2;}

MyClass& operator=(const MyClass&x)

{cout<<3; return*this;}

~MyClass(){cout<<4;}

};

int main(){

MyClass obj1(1),obj2(2),obj3(obj1);

return 0;

}问输出结果:1 1 2 4 4 4

2、#include

#include

using namespace std;

class MyString{

public:

char str[80];

MyString(const char*s) {strcpy(str,s);}

MyString&operator+=(MyString a){

strcat(str,a.str);

return*this; }

};

ostream&operator<<(ostream&s,const MyString&z)

{ return s << z.str; }

int main(){

MyString x("abc"),y("cde");

cout<<(x+=y)<

return 0;}问输出结果:abccde

3、有类定义如下：

#include "iostream.h"

class Type {

public:

Type (int i=0);

Type operator-(int);

friend Type operator +(Type, Type);

private:

int val;};

若有对象定义Type cl;则下列语句序列中，错误的是 c

A）Type（3）+c1； B） c1+Type（3）； C） 3-c1； D） c1-3；

using namespace std;

class Book{

public:

Book(char* t=""){strcpy(title,t)};

----virtual _char *Category()const=0;----- private:

char title[40];

};

class Novel:public Book{

public:

Novel(char *t=""):Book(t){}

char *Category()const

{ return "文学" ; }

};

int main(){

Book *pb;

pb=new Novel();

cout<Category();

return 0;

5．有如下程序:

#include

using namespace std;

class Media{

public:

void Name();

void Show();

protected:

int page;

};

class Book:private Media{

public:

void Print()

{ cout<

void Show()

{ Media::Show(); } //①

};

int main(){

Book Bible;

https://www.wendangku.net/doc/a811520582.html,(); //②

Bible.Print(); //③

Bible.Show(); //④

return 0;

} 编译不正确的是：(2)

6、有如下程序段

int i =0, j=1;

int &r=i ; // ①

r =j; //②

int*p=&i ; //③

*p=&r ; //④ // 将*去掉或者将&去掉

其中编译正确的语句是123

7、下面程序的语句1-4有误，找出不正确的语句并修改

有如下程序：

#include

using namespace std;

class MyClass{

public:

MyClass(int x):val(x){}

void Set(int x){ val=x; }

void Print() const

{ cout<<"val="<

private:

int val;

};

Int main(){

const MyClass obj1(10);---

MyClass obj2(20);

obj1.Print(); //语句 1

obj2.Print(); //语句 2

obj1.Set(20); //语句 3 // 将此句删除 obj1为常量

obj2.Set(30); //语句 4

return 0;

8、有如下程序：

#include

using namespace std;

class Toy{

public:

Toy(char* _n)

{ strcpy (name,_n); count++;}

~Toy(){ count--; }

char* GetName(){ return name; }

static int getCount(){ return count; } 静态成员属于类private:

char name[10];

static int count;};

int Toy::count=0;

int main(){

Toy t1("Snoopy"),t2("Mickey"),t3("Barbie");

cout<

return 0;}//输出3

9、如果不使用多态机制，那么通过基类的指针虽然可以指向派生类对象，但是只能访问从基类继承的成员，有如下程序，没有使用多态机制。

#include

using namespace std;

class Base{

int a,b;

public:

Base(int x ,int y) { a=x; b=y;}

void show(){ cout<

};

class Derived:public Base {

int c ,d;

public:

Derived(int x,int y,int z,int m):Base(x,y){c=z; d=m;}

void show(){ cout<

};

int main(){

Base B1(50,50),*pb;

Derived D1(10,20,30,40);

pb=&D1;

pb->show();

return 0;// 输出 10 20

10.若有如下类声明

#include "iostream.h"

class MyClass {

public:

MyClass() {cout<<1;}

}; 执行下列语句

MyClass a,b[2],*p[2]; 以后，程序的输出结果 1 1 1

11、下列语句中不正确的是（AC)。

A）const int a; B）const int a=10;

C）const int*point=10; D）const int*point=new int(10);

12、在C++中既可以用于文件输入又可以用于文件输出的流类是 A

A）fstream B）ifstream C）ofstream D）iostream

13、有如下程序：

#include

using namespace std;

class A{

public:

A(){cout<<'A';}

~A(){cout<<'C';}

};

class B:public A{

public:

B( ){cout<<'G';}

~B( ){cout<<'T';}

};

int main(){

B obj;

return 0;

}运行这个程序的输出结果是 AGTC

14、有如下程序:

#include

using namespace std;

class Boat；

class Car{

public:

Car(int i):weight(i){ }

friend int Total(const Car &c，const Boat &b); //①

private:

int weight;

};

class Boat{

public:

Boat(int i):weight(i){ }

friend int Total(const Car &c,const Boat &b);

private:

int weight;

};

int Total(const Car &c,const Boat &b){ //②

return c.weight+b.weight;

}

int main(){

Car c(10);

Boat b(8);

cout<<"The total weight is"<

return 0;

}

15．若需要为XV类重载乘法运算符,运算结果为XV类型,在将其声明为类的成员函数时,下列原型声明正确的是 D

A)XV operator *(XV,XV); B)XV *(XV);

C)operator *(XV); D)XV operator *(XV);

16．有如下程序：

#include

using namespace std；

class Instrument｛

public：

virtual void Display（）=0；

｝；

class Piano：public Instrument｛

public：

void Display（）｛/*函数体程序略*/｝

｝；

int main（）｛

Instrument s；

Instrument *p=0；

//．．．；

return 0；｝下列叙述中正确的是 B

A）语句“Insturment *p=0；”编译时出错

B）语句“Instrument s；”编译时出错

C）类Piano中的Display函数不是虚函数

D）类Instrumen类是一个虚基类

17、已知类IMS中两个成员函数的声明为"void listen() const;"与"void speak();",另有两个对象的定义为"IMS obj1;"与"const IMS obj2;",则下列语句中,产生编译错误的是 B

A)obj1.listen(); B)obj1.speak();

C)obj2.listen(); D)obj2.speak();

17、若在表达式y/x中，“／”是作为成员函数重载的运算符，则该表达式还可以表示为C

A）x.Operator/（y）B）operator/（x,y）

C）y.operator/（x）D）operator/（y,x）

18、有函数模板声明和一些变量定义如下：

template T1 sum（T2，T3）；

double d1，d2；

则下列调用中，错误的是 D

A）sum

B）sum（d1，d2）；

C）sum（d1，d2）；

D）sum（d1，d2）；// 没有参数指明T1的类型

19、有如下类定义

class A {

char *a;

public:

A():a(0) { }

A(char *aa){ //把aa所指字符串拷贝到a所指向的存储空间

a= _ new char[strlen(aa)+1];__________________ ;

strcpy(a,aa);

}

~A() { delete []a;}

}; 横线处应填写的表达式是

20、有如下程序：

#include

using namespace std;

class test {

private:

int a;

public:

test ( ){ cout<<"constructor"<

test(int a){cout<

test(const test &_test){

a=_test.a;

cout<<"copy constructor"<

}

~test() { cout<<"destructor"<

};

int main(){

test A(3);

return 0;

} 运行时输出的结果是3 destructor

21、下列运算符重载函数中，属于类Value 的成员函数的是（ACD）。A）Value operator+(Value);

B）Value operator-(Value, Value);

C）Value operator*(int);

D）Value operator/(Value);

22、下列函数模板的定义中，不合法的是CD

A）template T abs（T x）{return x <0 ? -x: x;}

B）template T abs（T x）{return x<0 ?-x:x;}

C）template T abs（T x）{return x<0 ?-x:x;}

D）template T abs（T x）{returm x<0 ?-x:x;}

23、有如下程序：

#include

using namespace std;

class point {

public:

static int number;

public:

point() { number++; }

~point() { number--; }

};

int point::number=0;

void main(){

point *ptr;

point A,B;

{

point *ptr_point=new point[3];

ptr=ptr_point;

}

point C;

cout<

delete[]ptr;

}运行时输出的结果是6

24、下列函数原型声明中，正确的是ABD

A）int fnction（int m，int n）；

B）int function（int，int）；

C）int function（int m=3，int n）；

D）int function（int &m，int &n）；

25、若有函数模板mySwap和一些变量定义如下:

template

void mySwap(T X,T Y);

double d1,d2; int i1,i2;

下列对mySwap的调用中,正确的是ABD

A)mySwap(i1,i2) B)mySwap(d1,d2)

C)mySwap(i1,d1) D)mySwap(i2,d2)

26、下列程序的输出是3，请填充程序中的空缺，使该行形成一个运算符重载函数的定义。

#include

using namespace std;

class MyNumber{

int n;

public:

MyNumber(int k):n(k){}

----operator---- int( )const {return n;}

};

int main(){

MyNumber num1(3);

cout<

return 0;

}

27、有如下程序：// 没有错误

#include

#include

using std::cout;

class Point{

public:

friend double distance(const Point &p); //p距原点的距离

Point(int xx=0,int yy=0):x (xx),Y(yy){} //①改为point(int xx,int yy):x(XX),y(YY) private:

int x,Y;

};

double distance(const Point &p) { //②

return sqrt(p.x*p.x+p.Y*p.Y);

}

int main(){

Point p1(3,4);

cout<

return 0;

}

28、若已定义了类Vehicle，则下列派生类定义中，正确的是a c d

A）class Car：Vehicle｛/*类体略*/｝，

B）class Car：public Car｛/*类体略*/｝；

C）class Car：public Vehicle｛/*类体略*/｝；

D）class Car：virtual public Vehicle｛/*类体略*/｝；

29、使用VC6打开工程test4_1，此工程包含一个源程序文件test4_1.cpp，但该程序运行有问题，请改正程序中的错误，使程序的输出结果如下：

Constructor2

Constructor1

i=0

i=10

Destructor

源程序文件test4_1.cpp清单如下：

#include＜iostream.h＞

class CSample {

int i;

public;

CSample( ){ cout＜＜"Constructorl"＜＜endl; i=0;｝

CSample(int val) { cout＜＜"Constructor2"＜＜endl;i=val; }

～CSample( )｛cout＜＜"Destructor"＜＜endl; }

void disp( );

};

／**********found(1)********／

void disp() { // void CSample::disp() 声明错了

cout＜＜"i=”＜＜i＜＜endl;

}

void main() {

CSample *a,b(10);

／**********found(2)*********／指向不明CSample c；a=&c；a->disp();

a-＞disp();

／**********found(3)*********／

b-＞disp(); 普通对象 b.disp();

}

30、请将下列模板类Data补充完整。

template

class Data

{

public:

void put (T v)

{ val=v; }

_T__ get() //返回数据成员val的值，返回类型不加转换

{ return val; }

private:

T val;

};

31、根据程序中的注释将下列缺失部分补充完整。

#include "iostream.h"

class Point{

int x, y; //点的x和y坐标

public:

Point(int xx=0,int yy=0):x(xx),y(yy) { }

};

class Circle{

Point center; //圆心位置

Int radius; //半径

public: //利用cx和cy分别初始化圆心的x和y坐标----Circle(int cx,int cy,int r):center(cx,cy)-----,radius(r){ }

void area() { cout<<3.14159*radius*radius<

};

32、下列程序的输出结果是__`___0 4 2_____________。

#include

using namespace std;

class Test {

public:

Test() { cnt++; }

~Test() {cnt--; }

static int Count() { return cnt;}

private:

static int cnt;

};

int Test::cnt = 0;

int main(){

cout <

Test tl, t2;

Test* pT3 = new Test;

Test* pT4 = new Test;

cout << Test::Count()<<' ';

delete pT4;

delete pT3;

cout << Test::Count() << endl;

return 0;

}

33、使用VC6打开工程test4_2。此工程包含一个源程序文件test4_2.cpp，其对一个学校的教师和考生情况进行了描述。由于教师和考生之间有相同的信息，如姓名、年龄等，所以可抽象出一个基类person，考生类student和教师类teacher作为person类的派生类。请按要求完成下列操作，将程序中的类定义补充完整。

(1)定义基类person的私有数据成员name和age，分别用于表示姓名和年龄，name 为字符指针，age为血型的数据。请在注释“//**1**”之后添加适当的语句。(2分)

(2)完成基类person的重载构造函数person(char *n,int a)的定义，把数据成员name，age分别初始化为参数n，a的值，请在注释“//**2**”之后添加适当的语句。(2分)

(3)根据主函数main中对s1的声明，定义派生类student的构造函数。在注释“//**3**”之后添加适当的语句。(3分)

(4)完成派生类teacher成员函数void setinf(ehar *n,int a,char *d,char *1)的定义，其功能为记录教师的姓名、年龄、院，系与职称信息。请在注释“//**4**”之后添加适当的语句。（2分）

输出结果如下：刘雷(45)destructor 蒋军(23)destructor

#include＜iostream.h＞

#include

class person{

//*********************1************************

// private: char *name; char age;

public：

person(){ }

person(char *n，int a){

//********************2***********************

name=new char[strlen(n)+1];

stcopy(name,n);

age=a;}

void setname(char *n) { name=n;}

void setage(int a) { age=a; }

～person( ) { cout＜＜name＜＜"("＜＜age＜＜")destructor"＜＜endl;}

};

class student : public person{

char *department;

int code;

public：

//**********************3***********************

// student(char *n,int a,char *d,int c):person(char *n,int a)

{department=d;

code=c; }

};

class teacher：public person {

char *department;

char *level;

public：

teacher( ) { }

void setinf (char *n，int a，char *d，char *l){

//*****************4**********************

// name=new char[strlen(n)+1];

// stcopy(name,n);

// age=a;

department=d;

level=1;

}

};

void main(){

student s1("蒋军"，23，"计算机学院"，2);

teacher t1;

t1.setinf("刘雷"，45，"计算机学院"，"教授");

}

34．打开工程test6_1，此工程包含一个源程序文件test6_1.cpp，其中定义了用于表示雇员的类Employee，但类Employee的定义并不完整。

请按要求完成下列操作，将类Employee的定义补充完整。

(1)补充类Employee的构造函数，请使用字符串函数将数据成员name，address，city，province和zipcode分别初始化为参数

*nm，*addr，*city，*prov和*zip的值。请在注释“//**1**”之后添加适当的语句；

(2)完成类Employee的成员函数ChangeName(char * newName)的定义，将newName 指向的内容赋值给数据成员name，

请在注释“//**2**”之后添加适当的语句；

(3)完成类Employee的成员函数Display()的定义，先使用指针buffer动态申请一个char 型的200单位大小的空间，

然后使用字符串函数将数据成员name和address依次复制其中，最后返回该指针buffer，将请在注释“//**3**”之后添加适当的语句。输出结果如下：

王东建国路大街105号

注意：除在指定位置添加语句之外，请不要改动程序中的其他内容。

源程序文件test6_1.cpp清单如下：

#include ＜iostream.h＞

#include ＜string.h＞

class Employee{

protected:

char name[20];

char address[100];

char city[20];

char province[20];

char zipcode[10];

public:

Employee(char *nm, char *addr，char *city, char *prov, char *zip);

void ChangeName(char *newName);

char *Display();

};

Employee::Employee(char *nm, char *adr, char *cit, char *prov, char *zip){

strcpy(name,nm);

strcpy(address,adr);

strcpy(city, cit);

strcpy(province,prov);

strcpy(zipcode,zip);

}

void Employee::ChangeName(char * newName) {

strcpy(name,newname); }

char *Employee::Display() {

char*buffer;

buffer=newchar[200];

strcpy(buffer,this->name);________________________

strcat(buffer, address);

return buffer;

}

void main() {

Employee emp("李华","建国路大街105号"，"石家庄"，"河北"，"103400");

emp. ChangeName ("王东");

cout＜＜emp.Display()＜＜end1;

34．虚函数支持多态调用，一个基类的指针可以指向派生类的对象，而且通过这样的指针调用虚函数时，，被调用的是指针所指的实际对象的虚函数，而非虚函数不支持多态调用。有如下程序：

#include

using namespace std;

class Base{

public:

virtual void f( ){ cout<<"f0+"; }

void g( ) { cout<<"g0+"; }

};

class Derived:public Base{

public:

void f() { cout<<"f+"; }

void g() { cout<<"g+"; }

};

int main(){

Derived d;

Base*p=&d;

p->f();

p->g();

return 0;

} 运行时输出的结果是C

A）f+g+ B）f0+g+ C）f+g0+ D）f0+g0+

35．下面程序中对一维坐标点类Point进行运算符重载

#include

using namespace std;

class point {

public:

point (int val) { x=val; }

point& operator++(){ x++; return *this;}

point operator++(int) { point old=*this; ++(*this); return old; } int GetX( ) const {return x;}

private:

int x;};

int main(){

point a(10);

cout<<(++a).GetX();

cout<

return 0;

} 编译和运行情况是B

A）运行时输出1011 B）运行时输出1111 C）运行时输出1112 D）编译有错

36、下列运算符中，不能被重载的是C

A）&& B）!= C）. D）++

37、有如下程序：

#include

using namespace std;

class A{

public:

static int a;

void init(){a=1;}

A(int a=2) { init(); a++; }

};

int A::a=0;

A obj;

int main(){

cout<

return 0;

}运行时输出的结果是B

A）0 B）1 C）2 D）3

38、有如下函数定义：

void func（int a,int＆b）{a++; b++;}

若执行代码段：

int x=0 ,y=1;

func（x,y）;

则变量x和y值分别是

39、在类中重载赋值运算符时,应将其声明为类的

A)静态函数B)友元函数C)成员函数D)构造函数

40、有如下程序:

#include

using namespace std;

class XA{

int a;

public:

static int b;

XA(int aa):a(aa){ b++; }

int getA( ){ return a; }

};

int XA::b=0;

int main(){

XA d1(4),d2(5);

cout<

return 0;

}

41、有如下类定义：

class MyClass{

int b; char a; double c;

public:

MyClass():c(0.0),b(0),a(','){ }

}; 创建这个类的对象时，数据成员的初始化顺序是

A）a,b,c B）c,b,a C）b,a,c D）c,a,b

42、在一个派生类的成员函数中，试图调用其基类的成员函数“void f();”，但无法通过编译。这说明（）。

A）f()是基类的私有成员C）派生类的继承方式为私有

B）f()是基类的保护成员D）派生类的继承方式为保护

43、有如下程序：

#include

#include

using namespace std;

int main(){

cout<

return 0;

}

44、若下列程序的输出结果是20，请将横线处缺失部分补充完整。

#include

using namespace std;

class MyClass{

public:

MyClass(int x=10):value(x){}

void SetValue(int x) { value=x; cout<

private:

int value;

};

int main(){

MyClass*ptr=new MyClass;

--------------------------------- //通过对象指针ptr调用SetValue函数

delete ptr;

return 0;

}

45、类Base、Component和Derived的定义如下,请将横线处缺失部分补充完整。

class Base{

double data;

public:

Base(double d):data( d ){ }

};

class Component{

int data;

public:

Component(int d):data(d){ }

};

class Derived:public Base{

Component com;

char character;

public:

Derived(double a,int b,char c):

//使用参数a初始化基类成员,使用参数b初始化成员对象com

___【5】___,character(c){ }

};

46、下面程序的输出结果是____________

#include

using namespace std;

class Base{

int x;

public:

Base(int b):x(b){ }

virtual void display(){cout<

};

class Derived:public Base{

int y;

public:

Derived(int d):Base(d),y(d){ }

void display() {cout<

};

int main(){

Base b(1);

Derived d(2);

Base *p=&d;

b.display( ); d.display( );p->display( );

return 0;

}

47、工程test4_1中包含一个源程序文件test4_1.cpp，但该程序在类的定义中存在问题，请改正类定义中的错误，错误位于注释行的下方,使程序的输出结果如下：

a=3 b=13

a=5 b=13

注意：请勿修改主函数main中的任何内容。

源程序文件test4_1.cpp清单如下：

#include＜iostream.h＞

class T{

public:

／*********************found(1)******************／

T(int x) { a=x; b+=x; }// T(int x):a(x ){ b+=x; }

／********************found(2)*******************／

void display(T c)

{ cout＜＜"a="＜＜c.a＜＜"\t"＜＜"b="＜＜c.b＜＜endl; }

private：

const int a;

static int b;

};

／**********************found(3)**********************／

int b=5;// int T::b=5;

void main() {

T A(3)，B(5);

T::display(A);

T::display(B);

}

48 #include

using namespace std;

class Pet

{char name[10];

public:

Pet(char*name) { strcpy(this->name, name); }

const char*getName( ) const { return name; }

virtual void call( )const=0;

};

class Dog: public Pet

{

public:

Dog(char*name):Pet(name){}

void call( )const{cout<<"汪汪叫";}

};

class Cat:public Pet{

public:

Cat(char*name):Pet(name){ }

void call( )const { cout<<"喵喵叫";}

};

int main(){

Pet *pet1=new Dog("哈克"),

*pet2=new Cat("吉米");

cout<getName();

pet1->call();

cout<

cout<getName();

pet2->call();

cout<

return 0;

}

49、有如下复数类的声明，请补充完整：

class complex{

double real; //实部

double imag; //虚部

public:

Complex(double x,double y){

real=x;

image=y;

}

Complex operator+(complex c){ //重载加法运算符“+”

return complex(_this.real+c.real,this.imag.real+c.imag____________________________);

}

};

50.已知基类Employees只有一个构造函数，其定义如下：

Employee::Employee(int n): id(n){}

Manager是Employees的派生类，则下列对Manager的构造函数的定义中，正确的是C A）Manager::Manager(int n):id(n){}

B）Manager::Manager(int n){id=n;}

C）Manager::Manager(int n):Employee(n){}

D）Manager::Manager(int n){Employee(n);}

51、下列关于虚基类的描述中，正确的是 B

A）使用虚基类可以消除由多重继承产生的二义性

B）构造派生类对象时，虚基类的构造函数只被调用一次

C）声明“class B : virtual public A”说明类B为虚基类

D）建立派生类对象时，首先调用虚基类的构造函数

52、请将下列栈类stack补充完整:

class stack{

private:

int plist[100]; //int 数组，用于存放栈的元素

int top; //栈顶元素（数组下标）

public:

stack():top(0){}

void push(const int &item); //新元素item压入栈

int pop(void); //将栈顶元素弹出栈

};

void stack::push(const int &item){

if (top ==99) //如果栈满，程序结束exit(1);

top++; //栈顶指针增1

//plist[top]=item;

}

int stack::pop( ) {

if (top<0) //如果栈空，程序结束

exit(1);

return plist[top--];

}

c算法大全

一、数论算法 1．求两数的最大公约数 function gcd(a,b:integer):intege r; begin if b=0 then gcd:=a else gcd:=gcd (b,a mod b); end ; 2．求两数的最小公倍数 function lcm(a,b:intege r):integer; begin if a0 do inc(lcm,a); end; 3．素数的求法 A.小范围内判断一个数是否为质数：function prime (n: intege r): Boolean; v ar I: integer; begin for I:=2 to trunc(sqrt(n)) do if n mod I=0 then begin prime:=false; exit;

end; prime:=true; end; B.判断longint范围内的数是否为素数（包含求50000以内的素数表）：procedure getprime; v ar i,j:longint; p:array[1..50000] of boolean; begin fillchar(p,sizeof(p),true); p[1]:=false; i:=2; w hile i<50000 do begin if p[i] then begin j:=i*2; w hile j<50000 do begin p[j]:=false; inc(j,i); end; end; inc(i); end; l:=0; for i:=1 to 50000 do

快速幂算法C语言版(超详细)

快速幂取模算法 在网站上一直没有找到有关于快速幂算法的一个详细的描述和解释，这里，我给出快速幂算法的完整解释，用的是C 语言，不同语言的读者只好换个位啦，毕竟读C 的人较多~ 所谓的快速幂，实际上是快速幂取模的缩写，简单的说，就是快速的求一个幂式的模(余)。在程序设计过程中，经常要去求一些大数对于某个数的余数，为了得到更快、计算范围更大的算法，产生了快速幂取模算法。我们先从简单的例子入手：求c a b mod = 几。 算法1.首先直接地来设计这个算法： int ans = 1; for (int i = 1;i<=b;i++) { ans = ans * a; } ans = ans % c; 这个算法的时间复杂度体现在for 循环中，为O （b ）.这个算法存在着明显的问题，如果a 和b 过大，很容易就会溢出。 那么，我们先来看看第一个改进方案：在讲这个方案之前，要先有这样一个公式： c c a c a b b mod )mod (mod =.这个公式大家在离散数学或者数论当中应该学过，不过这里为了方便大家的阅读，还是给出证明： 引理1： c c b c a c de c de c dk te tkc c e kc d tc c ab e kc b e c b d tc a d c a c c b c a c ab mo d )]mod ()mod [(mod mod ))((mod ))((mod mod mod mod )]mod ()mod [(mod )(:2?==+++=++=+=?=+=?=?=证明： 公式 上面公式为下面公式的引理，即积的取余等于取余的积的取余。 c a c c a c c c a c c a c c a c a b b b b b b mo d mod ])mod [() (mod ])mod )mod [((mod ])mod [(mod )mod (mod ===由上面公式的迭代证明：公式： 证明了以上的公式以后，我们可以先让a 关于c 取余，这样可以大大减少a 的大小， 于是不用思考的进行了改进： 算法2： int ans = 1; a = a % c; //加上这一句 for (int i = 1;i<=b;i++) {

常用数学算法C语言实现

一、基本算法 1．交换（两量交换借助第三者） 例1、任意读入两个整数，将二者的值交换后输出。 main() {int a,b,t; scanf("%d%d",&a,&b); printf("%d,%d\n",a,b); t=a; a=b; b=t; printf("%d,%d\n",a,b);} 【解析】程序中加粗部分为算法的核心，如同交换两个杯子里的饮料，必须借助第三个空杯子。 假设输入的值分别为3、7，则第一行输出为3，7；第二行输出为7，3。 其中t为中间变量，起到“空杯子”的作用。 注意：三句赋值语句赋值号左右的各量之间的关系！ 【应用】 例2、任意读入三个整数，然后按从小到大的顺序输出。 main() {int a,b,c,t; scanf("%d%d%d",&a,&b,&c); /*以下两个if语句使得a中存放的数最小*/ if(a>b){ t=a; a=b; b=t; } if(a>c){ t=a; a=c; c=t; } /*以下if语句使得b中存放的数次小*/ if(b>c) { t=b; b=c; c=t; } printf("%d,%d,%d\n",a,b,c);} 2．累加 累加算法的要领是形如“s=s+A”的累加式，此式必须出现在循环中才能被反复执行，从而实现累加功能。“A”通常是有规律变化的表达式，s在进入循环前必须获得合适的初值，通常为0。例1、求1+2+3+……+100的和。 main() {int i,s; s=0; i=1; while(i<=100) {s=s+i; /*累加式*/ i=i+1; /*特殊的累加式*/ } printf("1+2+3+...+100=%d\n",s);} 【解析】程序中加粗部分为累加式的典型形式，赋值号左右都出现的变量称为累加器，其中“i = i + 1”为特殊的累加式，每次累加的值为1，这样的累加器又称为计数器。

蚁群算法c语言

蚁群算法（C语言实现） https://www.wendangku.net/doc/a811520582.html,/s/blog_6bb1b4b001016pt0.html\ 这是我2012年第一个学期的期末大作业。 不得不说这段代码参考了网络上的一些代码，以及书本上的一些相关数据。 但是无论是网络上还是书上难免总是有很多C++的影子，这是我自己理解之后用C编写的蚁群算法的代码。 这几个城市的相关测试数据在CSDN上可以找到。 //蚁群算法关于简单的TSP问题求解// #include #include #include #include #include #define M 13 //蚂蚁的数量 #define N 144 //城市的数量 #define R 1000 //迭代次数 #define IN 1 //初始化的信息素的量 #define MAX 0x7fffffff //定义最大值 struct coordinate{ char city[15]; //城市名 int x; //城市相对横坐标

int y; //城市相对纵坐标 }coords[N]; double graph[N][N]; //储存城市之间的距离的邻接矩阵,自己到自己记作MAX double phe[N][N]; //每条路径上的信息素的量 double add[N][N]; //代表相应路径上的信息素的增量 double yita[N][N]; //启发函数,yita[i][j]=1/graph[i][j] int vis[M][N]; //标记已经走过的城市 int map[M][N]; //map[K][N]记录第K只蚂蚁走的路线 double solution[M]; //记录某次循环中每只蚂蚁走的路线的距离 int bestway[N]; //记录最近的那条路线 double bestsolution=MAX; int NcMax; //代表迭代次数,理论上迭代次数越多所求的解更接近最优解,最具有说服力double alpha,betra,rou,Q; void Initialize(); //信息初始化 void Inputcoords(FILE *fp); //将文件中的坐标信息读入 void GreateGraph(); //根据坐标信息建图 double Distance(int *p); //计算蚂蚁所走的路线的总长度 void Result(); //将结果保存到out.txt中 void Initialize() {

Dijkstra算法C代码

#include "stdio.h" #include "stdlib.h" #define M 10000 int dist[M] = {0},fa[M] = {0},visit[M] = {0}; int g[M][M] = {0}; int n,start,end; int findmin(){ int i,flag; int min = 987654321; for( i = 1 ; i<= n ; i++ ) if( visit[i] == 0 && dist[i] < min && dist[i] != 0){ min = dist[i]; flag = i; } return flag; } int Dijkstra(){ int i,j,pos; for( i = 1 ; i <= n ; i++ ){ dist[i] = g[start][i]; if( dist[i] == 123456789 ) fa[i] = i;

else fa[i] = start; } visit[start] = 1; for( i = 1 ; i <= n ; i++ ){ pos = 0; pos = findmin(); if(pos == 0) break; visit[pos] = 1; for( j = 1 ; j <= n ; j++ ) if( visit[j] == 0 && dist[j] > dist[pos] + g[pos][j] ){ dist[j] = dist[pos] + g[pos][j]; fa[j] = pos; } } } int main(){ int i,j; int p; scanf("%d%d%d",&n,&start,&end); for( i = 1 ; i <= n ; i++ )

遗传算法C语言代码

// GA.cpp : Defines the entry point for the console application. // /* 这是一个非常简单的遗传算法源代码，是由Denis Cormier (North Carolina State University)开发的， Sita S.Raghavan (University of North Carolina at Charlotte)修正。 代码保证尽可能少，实际上也不必查错。 对一特定的应用修正此代码，用户只需改变常数的定义并且定义“评价函数”即可。 注意代码的设计是求最大值，其中的目标函数只能取正值；且函数值和个体的适应值之间没有区别。 该系统使用比率选择、精华模型、单点杂交和均匀变异。如果用Gaussian变异替换均匀变异，可能得到更好的效果。 代码没有任何图形，甚至也没有屏幕输出，主要是保证在平台之间的高可移植性。 读者可以从https://www.wendangku.net/doc/a811520582.html,, 目录coe/evol中的文件prog.c中获得。 要求输入的文件应该命名为‘gadata.txt’；系统产生的输出文件为‘galog.txt’。 输入的文件由几行组成：数目对应于变量数。且每一行提供次序——对应于变量的上下界。如第一行为第一个变量提供上下界，第二行为第二个变量提供上下界，等等。 */ #include #include #include /* Change any of these parameters to match your needs */ //请根据你的需要来修改以下参数 #define POPSIZE 50 /* population size 种群大小*/ #define MAXGENS 1000 /* max. number of generations 最大基因个数*/ const int NVARS = 3; /* no. of problem variables 问题变量的个数*/ #define PXOVER 0.8 /* probability of crossover 杂交概率*/ #define PMUTATION 0.15 /* probability of mutation 变异概率*/ #define TRUE 1 #define FALSE 0 int generation; /* current generation no. 当前基因个数*/ int cur_best; /* best individual 最优个体*/ FILE *galog; /* an output file 输出文件指针*/ struct genotype /* genotype (GT), a member of the population 种群的一个基因的结构体类型*/ { double gene[NVARS]; /* a string of variables 变量*/

C算法提高训练题

C提高题二 题1：高精度加法 在C/C++语言中，整型所能表示的范围一般为-231到231（大约21亿）,即使long long型，一般也只能表示到-263到263。要想计算更加规模的数，就要用软件来扩展了，比如用数组或字符串来模拟更多规模的数及共运算。 现在输入两个整数，请输出它们的和。 输入格式 两行，每行一个整数，每个整数不超过1000位 输出格式 一行，两个整数的和。 样例输入 15464315464465465 482321654151 样例输出 15464797786119616 数据规模和约定 每个整数不超过1000位 题2：6-9删除数组中的0元素 编写函数CompactIntegers，删除数组中所有值为0的元素，其后元素向数组首端移动。注意，CompactIntegers函数需要接收数组及其元素个数作为参数，函数返回值应为删除操作执行后数组的新元素个数。 输入时首先读入数组长度，再依次读入每个元素。 将调用此函数后得到的数组和函数返回值输出。 样例输入 7 2 0 4 3 0 0 5 样例输出 2 4 3 5 4 题3：3-2字符串输入输出函数

编写函数GetReal和GetString，在main函数中分别调用这两个函数。在读入一个实数和一个字符串后，将读入的结果依次用printf输出。 两次输入前要输出的提示信息分别是"please input a number:\n”和"please input a string:\n" 样例输入 9.56 hello 样例输出 please input a number: please input a string: 9.56 hello 题4：进制转换 程序提示用户输入三个字符，每个字符取值范围是0-9，A-F。然后程序会把这三个字符转化为相应的十六进制整数，并分别以十六进制，十进制，八进制输出。 输入格式：输入只有一行，即三个字符。 输出格式：输出只有一行，包括三个整数，中间用空格隔开。 输入输出样例 样例输入 FFF 样例输出 FFF 4095 7777 题5：c++_ch06_02 编写并测试如下函数： void Add (int a[], int m, int b[], int n); 该函数将数组b的前n个元素追加到数组a的前m个元素后，假定数组a具有至少存放m+n个元素的空间。例如，如果数组a为{22,33,44,55,66,77,88,99}，数组b为{20,30,40,50,60,70,80,90}，则调用Add(a,5,b,3)后，将把数组a变为{22,33,44,55,66,20,30,40}。注意数组b并没有改变，而且数组a中只需改变n个元素。 测试 输入：4行。第一行为两个整数：m，n，并以空格隔开，分别表示将要输入的数组a和数组b的元素的个数。第二行为m个整数，为数组a的元素；第三行为n个整数，为数组b的元素。第四行为两个整数m1，n1，表示把数组b的前n1个元素追加到数组a的前m1个元素后。 输出：1行。第一行为最后数组a中的元素，两个元素之间以逗号隔开。最后一个元素输出后，输出一个空行。 参考程序

数值分析 算法C语言程序

一、拉格朗日插值 #include #include #include void Lagrange(float s) { double x[5]={0.2,0.4,0.6,0.8,1.0},y[5]={0.98,0.92,0.81,0.64,0.38},f,L=0; int i,j; for (i=0;i<5;i++) { f=1; for (j=0;j<5;j++) if(j!=i) f=(s-x[j])/(x[i]-x[j])*f; L+=f*y[i]; } printf("输出：%f\n",L); } void main() { float x; printf("输入插值点："); scanf("%f",&x); Lagrange(x); } 二、牛顿插值 #include #include #include int ND(float s) { double x[5]={0.2,0.4,0.6,0.8,1.0},y[5]={0.98,0.92,0.81,0.64,0.38},p=0,g,f; int i,j,k; for (i=0;i<5;i++) { for (j=4;j>i;j--) { f=x[j]-x[j-i-1];y[j]=(y[j]-y[j-1])/f;} g=y[i+1]; for (k=0;k<=i;k++) g=g*(s-x[k]); p=p+g; } printf("输出插值点函数值：%f\n",p+y[0]); return 1; }

FFT算法C语言程序代码

DIT-基2FFT的浮点C语言程序： 1、生成旋转因子，复数结构,旋转因子Wn=exp(-j*2*pi/N) //twiFactor——指向旋转因子矩阵的指针 //wLen——FFT的长度 Struct complexData{ //定义一个复数结构 float re; float im; }; Void gen_w_r2(struct complexData *twiFactor,int wLen) { int iFactor; float stepFactor; stepFactor=2.0*pi/wLen; for(iFactor=0;iFactor<(wLen>>1);iFactor++) { twiFactor[iFactor].re=cos(stepFactor*iFactor); twiFactor[iFactor].im=sin(stepFactor*iFactor); //W[n]=exp(j*2*pi*n/N),n=0,1,…,(N/2-1) } } 2、在运行FFT之前，对输入序列进行倒序变换，代码如下：//bitRevData——指向位变换序列的指针 //revLen——FFT长度 Void bit_rev(struct complexData *bitRevData,int revLen) { struct complexData tempRev; int iRev,jRev,kRev,halfLen; halfLen=revLen>>1;jRev=0; for(iRev=0;iRev<(revLen-1);iRev++) { If(iRev>1; } } }

C语言算法训练题

C训练题一 题1：未名湖边的烦恼 每年冬天，北大未名湖上都是滑冰的好地方。北大体育组准备了许多冰鞋，可是人太多了，每天下午收工后，常常一双冰鞋都不剩。 每天早上，租鞋窗口都会排起长龙，假设有还鞋的m个，有需要租鞋的n个。现在的问题是，这些人有多少种排法，可以避免出现体育组没有冰鞋可租的尴尬场面。（两个同样需求的人（比如都是租鞋或都是还鞋）交换位置是同一种排法） 输入格式 两个整数，表示m和n 输出格式 一个整数，表示队伍的排法的方案数。 样例输入 3 2 样例输出 5 数据规模和约定 m,n∈［0,18］ 问题分析 题2：最大的算式 题目很简单，给出N个数字，不改变它们的相对位置，在中间加入K个乘号和N-K-1个加号，（括号随便加）使最终结果尽量大。因为乘号和加号一共就是N-1个了，所以恰好每两个相邻数字之间都有一个符号。例如： N=5，K=2，5个数字分别为1、2、3、4、5，可以加成： 1*2*(3+4+5)=24 1*(2+3)*(4+5)=45 (1*2+3)*(4+5)=45 …… 输入格式 输入文件共有二行，第一行为两个有空格隔开的整数，表示N和K，其中（2<=N<=15, 0<=K<=N-1）。第二行为 N个用空格隔开的数字（每个数字在0到9之间）。 输出格式 输出文件仅一行包含一个整数，表示要求的最大的结果 样例输入

5 2 1 2 3 4 5 样例输出 120 样例说明 (1+2+3)*4*5=120 题3：图形显示 编写一个程序，首先输入一个整数，例如5，然后在屏幕上显示如下的图形（5表示行数）：* * * * * * * * * * * * * * * 题4：排序 编写一个程序，输入3个整数，然后程序将对这三个整数按照从大到小进行排列。 输入格式：输入只有一行，即三个整数，中间用空格隔开。 输出格式：输出只有一行，即排序后的结果。 输入输出样例 样例输入 9 2 30 样例输出 30 9 2 题5：2的次幂表示 任何一个正整数都可以用2进制表示，例如：137的2进制表示为10001001。 将这种2进制表示写成2的次幂的和的形式，令次幂高的排在前面，可得到如下表达式：137=2^7+2^3+2^0 现在约定幂次用括号来表示，即a^b表示为a（b） 此时，137可表示为：2（7）+2（3）+2（0） 进一步：7=2^2+2+2^0 （2^1用2表示） 3=2+2^0 所以最后137可表示为：2（2（2）+2+2（0））+2（2+2（0））+2（0） 又如：1315=2^10+2^8+2^5+2+1 所以1315最后可表示为： 2（2（2+2（0））+2）+2（2（2+2（0）））+2（2（2）+2（0））+2+2（0） 输入格式 正整数（1<=n<=20000）

C语言十大滤波算法

十大滤波算法程序大全(精心整理版)(转自网络) 1 推荐 1、限幅滤波法*************************************************** *函数名称：AmplitudeLimiterFilter()-限幅滤波法 *优点：能有效克服因偶然因素引起的脉冲干扰 *缺点：无法抑制那种周期性的干扰，且平滑度差 *说明： 1、调用函数 GetAD(),该函数用来取得当前值 2、变量说明 Value:最近一次有效采样的值，该变量为全局变量 NewValue:当前采样的值 ReturnValue:返回值 3、常量说明 A:两次采样的最大误差值，该值需要使用者根据实际情况设置*入口：Value,上一次有效的采样值，在主程序里赋值 *出口：ReturnValue,返回值，本次滤波结果 ****************************************************/ #define A 10 unsigned char Value unsigned char AmplitudeLimiterFilter() { unsigned char NewValue; unsigned char ReturnValue; NewValue=GatAD(); if(((NewValue-Value)>A))||((Value-NewValue)>A))) ReturnValue=Value; else ReturnValue=NewValue; return(ReturnValue); } 2、中位值滤波法 /**************************************************** *函数名称：MiddlevalueFilter()-中位值滤波法 *优点：能有效克服因偶然因素引起的波动干扰；对温度、液 位等变化缓慢的被测参数有良好的滤波效果 *缺点：对流量，速度等快速变化的参数不宜 *说明： 1、调用函数 GetAD(),该函数用来取得当前值 Delay(),基本延时函数

模糊控制算法c程序

由于项目需要，需要模糊控制算法，之前此类知识为0，经过半个多月的研究，终于有的小进展。开始想从强大的互联网上搜点c代码来研究下，结果搜遍所有搜索引擎都搜不到，以下本人从修改的模糊控制代码，经过自己修改后可在vc6.0，运行！输入e表示输出误差，ec表示误差变化率，经过测试具有很好的控制效果，对于非线性系统和数学模型难以建立的系统来说有更好的控制效果！现将其公开供大家学习研究！ #include #include"math.h" #define PMAX 100 #define PMIN -100 #define DMAX 100 #define DMIN -100 #define FMAX 100 /*语言值的满幅值*/ int PFF[4]={0,12,24,48}; /*输入量D语言值特征点*/ int DFF[4]={0,16,32,64}; /*输出量U语言值特征点*/ int UFF[7]={0,15,30,45,60,75,90}; /*采用了调整因子的规则表,大误差时偏重误差,小误差时偏重误差变化*/ /*a0=0.3,a1=0.55,a2=0.74,a3=0.89 */ int rule[7][7]={ //误差变化率 -3,-2,-1, 0, 1, 2, 3 // 误差 {-6,-6,-6,-5,-5,-5,-4,}, // -3 {-5,-4,-4,-3,-2,-2,-1,}, // -2 {-4,-3,-2,-1, 0, 1, 2,}, // -1 {-4,-3,-1, 0, 1, 3, 4,}, // 0 {-2,-1, 0, 1, 2, 3, 4,}, // 1 { 1, 2, 2, 3, 4, 4, 5,}, // 2 { 4, 5, 5, 5, 6, 6, 6}}; // 3 /**********************************************************/ int Fuzzy(int P,int D) /*模糊运算引擎*/ { int U; /*偏差,偏差微分以及输出值的精确量*/ unsigned int PF[2],DF[2],UF[4]; /*偏差,偏差微分以及输出值的隶属度*/ int Pn,Dn,Un[4]; long temp1,temp2; /*隶属度的确定*/ /*根据PD的指定语言值获得有效隶属度*/

卡尔曼滤波算法C语言实现

卡尔曼滤波算法及C 语言实现 摘要：本文着重讨论了卡尔曼滤波器的原理，典型算法以及应用领域。清晰地阐述了kalman filter 在信息估计方面的最优性能。着重介绍简单kalman filter algorithm 的编程，使用kalman filter 的经典5个体现最优化递归公式来编程。通过c 语言编写程序实现kalman filter 的最优估计能力。 关键词：kalman filter ；最优估计；C 语言 1 引言 Kalman Filter 是一个高效的递归滤波器，它可以实现从一系列的噪声测量中，估计动态系统的状态。起源于Rudolf Emil Kalman 在1960年的博士论文和发表的论文《A New Approach to Linear Eiltering and Prediction Problems 》（《线性滤波与预测问题的新方法》）。并且最先在阿波罗登月计划轨迹预测上应用成功，此后kalman filter 取得重大发展和完善。它的广泛应用已经超过30年，包括机器人导航，控制。传感器数据融合甚至在军事方面的雷达系统以及导弹追踪等等，近年来更被广泛应用于计算机图像处理，例如头脸识别，图像分割，图像边缘检测等等。 2 kalman filter 最优化递归估计 Kalman filter 是一个“optimal recursive data processing algorithm （最优化递归数据处理方法）”。对于解决很大部分的问题，他是最优，效率最高甚至是最有用的方法。而kalman filter 最为核心的内容是体现它最优化估计和递归特点的5条公式。举一个例子来详细说明5条公式的物理意义。 假设我们要研究的对象是某一个房间的温度信号。对于室温来说，一分钟内或一小段时间内的值是基本上不变的或者变化范围很小。也就是说1t 时刻的温度1T 和2t 时刻的温度2T 基本不变，即12T T =。在这个过程中，因为毕竟温度还是有所改变的，设有几度的偏差。我们把这几度的偏差看成是高斯白噪声)(t w ，也就是说0)]([=t w E ，2)]([σ=t w D 。除此之外我们在用一个温度计来实时测量房间的温度值Z ，但由于量具本身的误差，所测得的温度值也是不准确的，也会和实际值偏差几度，把这几度的偏差看成是测量噪声)(t v 。即满足0)]([=t v E ，21)]([σ=t v D 。 此时我们对于这个房间的温度就得到了两个数据。一个是你根据经验得到的经验值12T T =，一个是从温度计上得到的测量值Z ，以及各自引入的高斯白噪声。下面就具体讲

c语言算法

什么是程序？程序= 数据结构+ 算法。 对于面向对象程序设计，强调的是数据结构，而对于面向过程的程序设计语言如C、P a s c a l、F O RT R A N等语言，主要关注的是算法。掌握算法，也是为面向对象程序设计打下一个扎实的基础。那么，什么是算法呢？ 人们使用计算机，就是要利用计算机处理各种不同的问题，而要做到这一点，人们就必须事先对各类问题进行分析，确定解决问题的具体方法和步骤，再编制好一组让计算机执行的指令即程序，交给计算机，让计算机按人们指定的步骤有效地工作。这些具体的方法和步骤，其实就是解决一个问题的算法。根据算法，依据某种规则编写计算机执行的命令序列，就是编制程序，而书写时所应遵守的规则，即为某种语言的语法。 由此可见，程序设计的关键之一，是解题的方法与步骤，是算法。学习高级语言的重点，就是掌握分析问题、解决问题的方法，就是锻炼分析、分解，最终归纳整理出算法的能力。与之相对应，具体语言，如C语言的语法是工具，是算法的一个具体实现。所以在高级语言的学习中，一方面应熟练掌握该语言的语法，因为它是算法实现的基础，另一方面必须认识到算法的重要性，加强思维训练，以写出高质量的程序。 下面通过例子来介绍如何设计一个算法： [例1-4] 输入三个数，然后输出其中最大的数。 首先，得先有个地方装这三个数，我们定义三个变量A、B、C，将三个数依次输入到Ａ、B、C中，另外，再准备一个M A X装最大数。由于计算机一次只能比较两个数，我们首先把A 与B比，大的数放入M A X中，再把M A X 与C比，又把大的数放入M A X中。最后，把M A X输出，此时M A X中装的就是Ａ、Ｂ、C三数中最大的一个数。算法可以表 示如下： 1) 输入A、B、C。 2) A与B中大的一个放入M A X中。 3) 把C与M A X中大的一个放入M A X中。 4) 输出M A X，M A X即为最大数。 其中的2 )、3 )两步仍不明确，无法直接转化为程序语句，可以继续细化： 2) 把A与B中大的一个放入M A X中，若A > B，则MAX ←A；否则MAX ←B。 3) 把C与M A X中大的一个放入M A X中，若C > M A X，则M A X←C。 于是算法最后可以写成：

(整理)C语言常用算法集合.

1.定积分近似计算： /*梯形法*/ double integral(double a,double b,long n) { long i;double s,h,x; h=(b-a)/n; s=h*(f(a)+f(b))/2; x=a; for(i=1;i

} 3.素数的判断： /*方法一*/ for (t=1,i=2;i0;n/=10) k=10*k+n%10; return k; } /*求回文数*/ int f(long n) { long k,m=n; for(k=0;n>0;n/=10) k=10*k+n%10; if(m==k) return 1; return 0; } /*求整数位数*/ int f(long n) { int count; for(count=0;n>0;n/=10) count++; return count; }

解微分方程算法C语言程序(精心整理版)

解微分方程算法C语言程序（精心整理版）#include #include #include #include float k1,k2,k3,k4,m1,m2,m3,m4,n1,n2,n3,n4; float t,ts,tf,h; float x[1001],y[1001],z[1001],x_axis[1001]; int count; void initial( ) { x[0] = 1.0 ; y[0] = -1.0; z[0] = 0.0; ts = 0.0; tf = 20.0; count = 500; } void runge( ) { int i = 0; h = (tf - ts)/count; for(i = 1;i <= count;i++)

{ t = ts + (i-1)*h; k1 = -x[i-1] + 2*y[i-1] + 6*z[i-1]; m1 = -y[i-1] + 3*z[i-1] + 2*sin(t); n1 = -z[i-1] + sqrt(t)*exp(-t) + cos(t); k2 = -(x[i-1] + k1*(h/2.0)) + 2*(y[i-1] + m1*(h/2.0)) + 6*(z[i-1] + n1*(h/2.0)); m2 = -(y[i-1] + m1*(h/2.0)) + 3*(z[i-1] + n1*(h/2.0)) + 2*sin(t + h/2.0); n2 = -(z[i-1] + n1*(h/2.0)) + sqrt(t + h/2.0)*exp(-(t + h/2.0)) + cos(t + h/2.0); k3 = -(x[i-1] + k2*(h/2.0)) + 2*(y[i-1] + m2*(h/2.0)) + 6*(z[i-1] + n2*(h/2.0)); m3 = -(y[i-1] + m2*(h/2.0)) + 3*(z[i-1] + n2*(h/2.0)) + 2*sin(t + h/2.0); n3 = -(z[i-1] + n2*(h/2.0)) + sqrt(t + h/2.0)*exp(-(t + h/2.0)) + cos(t + h/2.0); k4 = -(x[i-1] + k3*(h/2.0)) + 2*(y[i-1] + m3*(h/2.0)) + 6*(z[i-1] + n3*(h/2.0)); m4 = -(y[i-1] + m3*(h/2.0)) + 3*(z[i-1] + n3*(h/2.0)) + 2*sin(t + h/2.0); n4 = -(z[i-1] + n3*(h/2.0)) + sqrt(t + h/2.0)*exp(-(t + h/2.0)) + cos(t + h/2.0); x[i] = x[i-1] + h*(k1 + 2*k2 + 2*k3 + k4)/6.0;

C语言常用算法归纳

C语言常用算法归纳 应当掌握的一般算法 一、基本算法： 交换、累加、累乘 二、非数值计算常用经典算法： 穷举、排序（冒泡，选择）、查找（顺序即线性） 三、数值计算常用经典算法： 级数计算（直接、简接即递推）、一元非线性方程求根（牛顿迭代法、二分法）、定积分计算（矩形法、梯形法） 四、其他： 迭代、进制转换、矩阵转置、字符处理（统计、数字串、字母大小写转换、加密等）、整数各数位上数字的获取、辗转相除法求最大公约数（最小公倍数）、求最值、判断素数（各种变形）、数组元素的插入（删除）、二维数组的其他典型问题（方阵的特点、杨辉三角形） 详细讲解 一、基本算法 1．交换（两量交换借助第三者） 例1、任意读入两个整数，将二者的值交换后输出。 main() { int a,b,t;

scanf("%d%d",&a,&b); printf("%d,%d\n",a,b); t=a; a=b; b=t; printf("%d,%d\n",a,b); } 【解析】程序中加粗部分为算法的核心，如同交换两个杯子里的饮料，必须借助第三个空杯子。 假设输入的值分别为3、7，则第一行输出为3，7；第二行输出为7，3。 其中t为中间变量，起到“空杯子”的作用。 注意：三句赋值语句赋值号左右的各量之间的关系！ 【应用】 例2、任意读入三个整数，然后按从小到大的顺序输出。 main() { int a,b,c,t; scanf("%d%d%d",&a,&b,&c); /*以下两个if语句使得a中存放的数最小*/ if(a>b){ t=a; a=b; b=t; } if(a>c){ t=a; a=c; c=t; } /*以下if语句使得b中存放的数次小*/ if(b>c) { t=b; b=c; c=t; } printf("%d,%d,%d\n",a,b,c); } 2．累加 累加算法的要领是形如“s=s+A”的累加式，此式必须出现在循环中才能被反复执行，从而实现累加功能。“A”通常是有规律变化的表达式，s在进入循环前必须获得合适的初值，通常为0。 例1、求1+2+3+……+100的和。 main() { int i,s; s=0; i=1; while(i<=100) { s=s+i; /*累加式*/ i=i+1; /*特殊的累加式*/ } printf("1+2+3+...+100=%d\n",s); }

遗传算法c语言代码

遗传算法代码 #include #include #include #include #include #define cities 10 //城市的个数 #define MAXX 100//迭代次数 #define pc 0.8 //交配概率 #define pm 0.05 //变异概率 #define num 10//种群的大小 int bestsolution;//最优染色体 int distance[cities][cities];//城市之间的距离 struct group //染色体的结构 { int city[cities];//城市的顺序 int adapt;//适应度 double p;//在种群中的幸存概率 }group[num],grouptemp[num]; //随机产生10个城市之间的相互距离 void init() { int i,j; memset(distance,0,sizeof(distance)); srand((unsigned)time(NULL)); for(i=0;i