您的位置:

a算法解读c语言,算法 c语言

本文目录一览:

C语言算法a(n)=2^n+1过程怎么写!急!

以下程序以n=0的整数为标准。

#include stdio.h

int main(){

int a=1,i=0;

int n;

printf("请输入n的值");

scnaf("%d",n);

for (i=0;in;i++)

{a=a*2;}

printf("a=%d",a);

return 0;}

求A* 算法C语言源程序

#include string.h

#include stdio.h

#include malloc.h

#include time.h

#define NULL 0

const int nmax = 200;

const int nend = 99; /*终点坐标的代表点*/

static char achar[10][10];

static int npayo = 0; /*0 表示空 1为非空*/

static int npayc = 0; /*0 表示空 1为非空*/

static int npay_x = 0; /*起点*/

static int npay_y = 0;

static int nend_x = 9; /*终点*/

static int nend_y = 9;

static int nnewpay_x;

static int nnewpay_y;

static int ndian = 101;

static int nh;

static long i = 10000000L;

struct Spaydian

{

int ng;

int nf; /*路径评分*/

int nmy_x; /*自己位置*/

int nmy_y;

int nfatherx; /*父节点*/

int nfathery;

int nflag; /* 0 wei O; 1 wei @ */

};

static struct Spaydian spaydian[200];

/* open close list 表 */

typedef struct spaylist

{

int n_f;

int n_x;

int n_y;

int nfather_x;

int nfather_y;

struct spaylist *next;

};

static struct spaylist *open_list, *close_list;

static void smline();

static int sjudge(int nx,int ny,int i); /*判断在第nx列ny行向第i个方向走是否可以,可以返回1否则返回0。

i=1表示向右,2表示向下,3表示向左,4表示向上*/

static void spath();

static void spayshow(int nxx,int nyy);

static int sifopen( int nx,int ny); /*判断点是否在 open 表上*/

static int sifclose(int nx,int ny); /*判断点是否在 close 表上*/

static int snewx(int nx,int i);

static int snewy(int ny,int i);

static spaylist *creat(); /*建立链表*/

static spaylist *del(spaylist *head,int num_x,int num_y); /*删除链表的结点*/

static spaylist *snewdianx(spaylist *head);/*新的点*/

static spaylist *snewdiany(spaylist *head);

static spaylist *insert(spaylist *head,int ndian); /* 点插入链表 */

static spaylist *srebirth(spaylist *head,int ndian); /*更新表*/

int main()

{

FILE *fp ;

char ach ;

int ni = 0 ; /*统计个数*/

int nii = 0; /*achar[nii][njj]*/

int njj = 0;

if ((fp=fopen("route.txt","rt")) == NULL) /* 判断打开文件是否为空 */

{

printf("文件为空!~\n");

return 0;

/* exit(1);*/

}

ach = fgetc(fp);

while(ach != EOF)

{

if(ach == 'O' || ach == '@') /*当值为@或O时候*/

{

spaydian[ni].ng = 0;

spaydian[ni].nf = nmax;

spaydian[ni].nmy_x = njj;

spaydian[ni].nmy_y = nii;

spaydian[ni].nfathery = -1;

spaydian[ni].nfatherx = -1;

if(ach == '@')

{

spaydian[ni].nflag = 1;

}

else if(ach == 'O')

{

spaydian[ni].nflag = 0;

}

ni++;

achar[nii][njj] = ach;

njj++;

if(njj == 10)

{

nii++;

njj = 0;

}

} /*end if*/

ach = fgetc(fp);

}/*end while*/

smline(); /* a*算法 */

fp=fopen("answer.txt","w");

for(int i=0;i10;i++ )

{ for(int j=0;j10;j++ )

{

printf("%c",achar[i][j]);

if(j==9)

printf("\n");

fprintf(fp,"%c",achar[i][j]);

if (j==9)

fprintf(fp,"\n");

}

}

fclose(fp);

return 0;

}

/* a* 算法 */

static void smline()

{ close_list = open_list = NULL;

open_list = creat();

while(open_list != NULL) /* 当open 表不为空时 */

{

open_list = del(open_list,npay_x,npay_y); /*删除open 链表的结点*/

if(npay_x == 9 npay_y == 9)

{

achar[9][9] = '=';

spath(); /*寻找并画出路径*/

break;

}

for (int i=1; i=4; i++) /*四个方向逐个行走,i=1向右 2向下 3向左 4向上*/

{

if (sjudge(npay_x,npay_y,i))

{

nnewpay_x = snewx(npay_x,i);

nnewpay_y = snewy(npay_y,i);

if(open_list != NULL)

npayo = sifopen(nnewpay_x,nnewpay_y) ; /*判断点是否在 open 表中*/

else

npayo = 0;

if(close_list != NULL)

npayc = sifclose(nnewpay_x,nnewpay_y) ; /*判断点是否在 close 表中*/

else

npayc = 0;

ndian = 10*nnewpay_x+nnewpay_y ;

if (npayo == 0 npayc == 0 ) /*点不在open表也不在close表中*/

{

spaydian[ndian].ng = spaydian[10*npay_x+npay_y].ng + 1; /*更新点的基本信息*/

nh = (nend - ndian)/10 + (nend - ndian)%10 ;

spaydian[ndian].nf = spaydian[ndian].ng+nh;

spaydian[ndian].nfathery = npay_y;

spaydian[ndian].nfatherx = npay_x;

spaydian[ndian].nmy_y = nnewpay_y;

spaydian[ndian].nmy_x = nnewpay_x;

open_list = insert(open_list,ndian);/*点插入open 表中*/

}

else if (npayo == 1) /*点在open表中*/

{

spaydian[ndian].ng = spaydian[10*npay_x+npay_y].ng + 1;

nh = (nend - ndian)/10 + (nend - ndian)%10 ;

if(spaydian[ndian].nf (spaydian[ndian].ng+nh) spaydian[ndian].nf != nmax)

{

spaydian[ndian].nf = spaydian[ndian].ng+nh;

open_list = srebirth(open_list,ndian); /*点插入open 表中*/

}

}

else if(npayc == 1) /*新生成的点在close表中*/

{

spaydian[ndian].ng = spaydian[10*npay_x+npay_y].ng + 1;

nh = (nend - ndian)/10 + (nend - ndian)%10 ;

if(spaydian[ndian].nf (spaydian[ndian].ng+nh) spaydian[ndian].nf != nmax)

{

spaydian[ndian].nf = spaydian[ndian].ng+nh;

close_list = srebirth(close_list,ndian);

close_list = del(close_list,nnewpay_x,nnewpay_y); /*删除close链表的结点*/

open_list = insert(open_list,ndian);/*点插入open 表中*/

}

}/*end else if*/

}/*end if*/

}/*end for*/

close_list = insert(close_list,(10*npay_x+npay_y));/*点插入close 表中*/

if(open_list != NULL)

{

npay_x = open_list-n_x;

npay_y = open_list-n_y;

}

}/*end while*/

if(open_list == NULL)

{printf("无路可走 \n");}

}

/*建立链表*/

spaylist *creat(void)

{

spaylist *head;

spaylist *p1;

int n=0;

p1=(spaylist*)malloc(sizeof(spaylist));

p1-n_f = 18;

p1-n_x = 0;

p1-n_y = 0;

p1-nfather_x = -1;

p1-nfather_x = -1;

p1-next = NULL;

head = NULL;

head=p1;

return(head);

}

/*删除结点*/

spaylist *del(spaylist *head,int num_x,int num_y)

{

spaylist *p1, *p2;

if(head == NULL)

{

printf("\nlist null!\n");

return (head);

}

p1 = head;

while((num_y != p1-n_y ||num_x != p1-n_x ) p1-next != NULL)

{

p2=p1;

p1=p1-next;

}

if(num_x == p1-n_x num_y == p1-n_y )

{

if(p1==head)

head=p1-next;

else

p2-next=p1-next;

}

return (head);

}

/*输出*/

static void spath()

{

int nxx;

int nyy;

nxx = spaydian[nend].nfatherx;

nyy = spaydian[nend].nfathery;

spayshow(nxx,nyy) ;

}

/*递归*/

void spayshow(int nxx,int nyy)

{ achar[nxx][nyy] = '=';

if( nxx != 0 || nyy != 0 )

{

int nxxyy = 10*nxx+nyy;

nxx = spaydian[nxxyy].nfatherx;

nyy = spaydian[nxxyy].nfathery;

spayshow(nxx,nyy);

}

}

/* 判断周围四个点是否可行 */

static int sjudge(int nx,int ny,int i)

{

if (i==1) /*判断向右可否行走*/

{

if (achar[nx][ny+1]=='O' ny9)

{

return 1;

}

else

return 0;

}

else if (i==2) /*判断向下可否行走*/

{

if (achar[nx+1][ny]=='O' nx9)

{

return 1;

}

else

return 0;

}

else if (i==3)/*判断向左可否行走 */

{

if (ny 0achar[nx][ny-1]=='O')

{

return 1;

}

else

return 0;

}

else if (i==4)/*判断向上可否行走 */

{

if (nx 0achar[nx-1][ny]=='O')

{

return 1;

}

else

return 0;

}

else

return 0;

}

/* 求新的x点 */

static int snewx(int nx,int i)

{

if(i == 1)

nx = nx;

else if(i == 2)

nx = nx+1;

else if(i == 3)

nx = nx;

else if(i == 4)

nx = nx-1;

return nx;

}

/* 求新的y点 */

static int snewy(int ny, int i)

{

if(i == 1)

ny = ny+1;

else if(i == 2)

ny = ny;

else if(i == 3)

ny = ny-1;

else if(i == 4)

ny = ny;

return ny;

}

/*判定点是否在open表中*/

int sifopen(int nx,int ny)

{

spaylist *p1, *p2;

p1 = open_list;

while((ny != p1-n_y || nx != p1-n_x ) p1-next != NULL)

{

p2 = p1;

p1 = p1-next;

}

if(nx == p1-n_x ny == p1-n_y)

return 1;

else

return 0;

}

/*判定点是否在close表中*/

int sifclose(int nx,int ny)

{

spaylist *p1, *p2;

p1 = close_list;

while((ny != p1-n_y ||nx != p1-n_x ) p1-next != NULL)

{

p2=p1;

p1=p1-next;

}

if(nx == p1-n_x ny == p1-n_y)

return 1;

else

return 0;

}

/*插入结点*/

spaylist * insert(spaylist *head,int ndian)

{

spaylist *p0,*p1,*p2;

p1=head;

p0=(spaylist*)malloc(sizeof(spaylist));

p0-n_f = spaydian[ndian].nf;

p0-n_x = spaydian[ndian].nmy_x;

p0-n_y = spaydian[ndian].nmy_y;

p0-nfather_x = spaydian[ndian].nfatherx;

p0-nfather_x = spaydian[ndian].nfathery;

p0-next = NULL;

if(head==NULL)

{

head=p0;

p0-next=NULL;

}

else

{

while((p0-n_f p1-n_f)(p1-next!=NULL))

{

p2=p1;

p1=p1-next;

}

if(p0-n_f = p1-n_f)

{

if(head==p1)

head=p0;

else

p2-next=p0;

p0-next=p1;

}

else

{

p1-next=p0;

p0-next=NULL;

}

}

return (head);

}

/* 更新链表 */

spaylist * srebirth(spaylist *head,int ndian)

{

spaylist *p1, *p2;

p1=head;

while(spaydian[ndian].nmy_x!=p1-n_xspaydian[ndian].nmy_x!=p1-n_xp1-next!=NULL)

{

p2=p1;

p1=p1-next;

}

if(spaydian[ndian].nmy_x==p1-n_xspaydian[ndian].nmy_x==p1-n_x)

{

p1-n_f = spaydian[ndian].nf;

}

return (head);

}

求一个A*算法的C语言或C++代码,小弟不胜感激,谢谢

1#include iostream

2#include queue

3usingnamespace std;

4

5struct knight{

6int x,y,step;

7int g,h,f;

8booloperator (const knight k) const{ //重载比较运算符

9return f k.f;

10 }

11}k;

12bool visited[8][8]; //已访问标记(关闭列表)

13int x1,y1,x2,y2,ans; //起点(x1,y1),终点(x2,y2),最少移动次数ans

14int dirs[8][2]={{-2,-1},{-2,1},{2,-1},{2,1},{-1,-2},{-1,2},{1,-2},{1,2}};//8个移动方向

15priority_queueknight que; //最小优先级队列(开启列表)

16

17boolin(const knight a){ //判断knight是否在棋盘内

18if(a.x0|| a.y0|| a.x=8|| a.y=8)

19returnfalse;

20returntrue;

21}

22int Heuristic(const knight a){ //manhattan估价函数

23return (abs(a.x-x2)+abs(a.y-y2))*10;

24}

25void Astar(){ //A*算法

26 knight t,s;

27while(!que.empty()){

28 t=que.top(),que.pop(),visited[t.x][t.y]=true;

29if(t.x==x2 t.y==y2){

30 ans=t.step;

31break;

32 }

33for(int i=0;i8;i++){

34 s.x=t.x+dirs[i][0],s.y=t.y+dirs[i][1];

35if(in(s) !visited[s.x][s.y]){

36 s.g = t.g +23; //23表示根号5乘以10再取其ceil

37 s.h = Heuristic(s);

38 s.f = s.g + s.h;

39 s.step = t.step +1;

40 que.push(s);

41 }

42 }

43 }

44}

45int main(){

46char line[5];

47while(gets(line)){

48 x1=line[0]-'a',y1=line[1]-'1',x2=line[3]-'a',y2=line[4]-'1';

49 memset(visited,false,sizeof(visited));

50 k.x=x1,k.y=y1,k.g=k.step=0,k.h=Heuristic(k),k.f=k.g+k.h;

51while(!que.empty()) que.pop();

52 que.push(k);

53 Astar();

54 printf("To get from %c%c to %c%c takes %d knight moves.\n",line[0],line[1],line[3],line[4],ans);

55 }

56return0;

57}

58

求8数码A或A*算法(用C语言)

题目地址:

BFS:

#include iostream

using namespace std;

int fac[10]={1,1};

bool tflag[9];

struct bbit{

unsigned int val:4;

};

struct bbbit

{

unsigned int val:2;

};

struct Node

{

bbit s[9],pos;

int step;

bbbit path[21],tag;

int hashval()

{

int ret=0,i,j,tmp;

memset(tflag,false,sizeof(tflag));

for(i=0;i8;i++)

{

tmp=0;

for(j=0;js[i].val;j++)

if(!tflag[j])

tmp++;

ret+=tmp*fac[8-i];

tflag[s[i].val]=true;

}

return ret;

}

bool up()

{

if(pos.val=2)return false;

s[pos.val].val^=s[pos.val-3].val;

s[pos.val-3].val^=s[pos.val].val;

s[pos.val].val^=s[pos.val-3].val;

path[step].val=0;

pos.val-=3;

return true;

}

bool down()

{

if(pos.val=6)return false;

s[pos.val].val^=s[pos.val+3].val;

s[pos.val+3].val^=s[pos.val].val;

s[pos.val].val^=s[pos.val+3].val;

path[step].val=1;

pos.val+=3;

return true;

}

bool left()

{

if(pos.val==0||pos.val==3||pos.val==6)return false;

s[pos.val].val^=s[pos.val-1].val;

s[pos.val-1].val^=s[pos.val].val;

s[pos.val].val^=s[pos.val-1].val;

path[step].val=2;

pos.val--;

return true;

}

bool right()

{

if(pos.val==2||pos.val==5||pos.val==8)return false;

s[pos.val].val^=s[pos.val+1].val;

s[pos.val+1].val^=s[pos.val].val;

s[pos.val].val^=s[pos.val+1].val;

path[step].val=3;

pos.val++;

return true;

}

bool operator==(const Nodex)const

{

int i;

for(i=0;i9;i++)if(s[i].val!=x.s[i].val)return false;

return true;

}

}Q[362880],S,A,tmp,top;

struct Hash

{

bool d1,d2;

Node D;

}hash[362880];

inline void mkfac(){int i;for(i=2;i=9;i++)fac[i]=fac[i-1]*i;}

inline int eval(char c){return c=='x'?0:c-'0';}

void o(Node x,Node y)

{

int i;

for(i=1;i=x.step;i++)

{

switch(x.path[i].val)

{

case 0:putchar('u');break;

case 1:putchar('d');break;

case 2:putchar('l');break;

case 3:putchar('r');break;

}

}

for(i=y.step;i=1;i--)

switch(y.path[i].val){

case 0:putchar('d');break;

case 1:putchar('u');break;

case 2:putchar('r');break;

case 3:putchar('l');break;

}

puts("");

}

int main()

{

char buf[11];

int i,t,l,r;

bool flag;

mkfac();

while(NULL!=gets(buf))

{

t=0;

for(i=0;i=7;i++)A.s[i].val=i+1;A.s[8].val=0;A.pos.val=8;

for(i=0;buf[i];i++)

{

if(buf[i]==' ')continue;

S.s[t].val=eval(buf[i]);

if(S.s[t].val==0)

S.pos.val=t;

t++;

}

l=r=0;

flag=false;

for(i=0;i362880;i++)hash[i].d1=hash[i].d2=false;

S.step=0;S.tag.val=1;

A.step=0;A.tag.val=2;

Q[r++]=S;//tag.val:1

Q[r++]=A;//tag.val:2

while(l=r)

{

top=Q[l++];

top.step++;

tmp=top;

if(tmp.up())

{

if(tmp.tag.val==1)

{

if(!hash[t=tmp.hashval()].d1)

{

hash[t].d1=true;

Q[r++]=tmp;

if(hash[t].d2hash[t].D==tmp)

{

//find ans...

o(tmp,hash[t].D);

goto AA;

}

if(!hash[t].d2)hash[t].D=tmp;

}

}

else

{

if(!hash[t=tmp.hashval()].d2)

{

hash[t].d2=true;

Q[r++]=tmp;

if(hash[t].d1hash[t].D==tmp)

{

//find ans...

o(hash[t].D,tmp);

goto AA;

}

if(!hash[t].d1)hash[t].D=tmp;

}

}

}

tmp=top;

if(tmp.down())

{

if(tmp.tag.val==1)

{

if(!hash[t=tmp.hashval()].d1)

{

hash[t].d1=true;

Q[r++]=tmp;

if(hash[t].d2hash[t].D==tmp)

{

//find ans...

o(tmp,hash[t].D);

goto AA;

}

if(!hash[t].d2)hash[t].D=tmp;

}

}

else

{

if(!hash[t=tmp.hashval()].d2)

{

hash[t].d2=true;

Q[r++]=tmp;

if(hash[t].d1hash[t].D==tmp)

{

//find ans...

o(hash[t].D,tmp);

goto AA;

}

if(!hash[t].d1)hash[t].D=tmp;

}

}

}

tmp=top;

if(tmp.left())

{

if(tmp.tag.val==1)

{

if(!hash[t=tmp.hashval()].d1)

{

hash[t].d1=true;

Q[r++]=tmp;

if(hash[t].d2hash[t].D==tmp)

{

//find ans...

o(tmp,hash[t].D);

goto AA;

}

if(!hash[t].d2)hash[t].D=tmp;

}

}

else

{

if(!hash[t=tmp.hashval()].d2)

{

hash[t].d2=true;

Q[r++]=tmp;

if(hash[t].d1hash[t].D==tmp)

{

//find ans...

o(hash[t].D,tmp);

goto AA;

}

if(!hash[t].d1)hash[t].D=tmp;

}

}

}

tmp=top;

if(tmp.right())

{

if(tmp.tag.val==1)

{

if(!hash[t=tmp.hashval()].d1)

{

hash[t].d1=true;

Q[r++]=tmp;

if(hash[t].d2hash[t].D==tmp)

{

//find ans...

o(tmp,hash[t].D);

goto AA;

}

if(!hash[t].d2)hash[t].D=tmp;

}

}

else

{

if(!hash[t=tmp.hashval()].d2)

{

hash[t].d2=true;

Q[r++]=tmp;

if(hash[t].d1hash[t].D==tmp)

{

//find ans...

o(hash[t].D,tmp);

goto AA;

}

if(!hash[t].d1)hash[t].D=tmp;

}

}

}

}

AA:flag=true;

if(!flag)

puts("unsolvable");

}

return 0;

}

A*:

#include iostream

#include queue

using namespace std;

int fac[10]={1,1};

struct Node

{

int s[9],step,pos;

char path[501];

int hashval()

{

int ret=0,i,j,tmp;

bool flag[9];

memset(flag,false,sizeof(flag));

for(i=0;i8;i++)

{

tmp=0;

for(j=0;js[i];j++)

if(!flag[j])

tmp++;

ret+=tmp*fac[8-i];

flag[s[i]]=true;

}

return ret;

}

bool up()

{

if(pos=2)return false;

s[pos]^=s[pos-3];

s[pos-3]^=s[pos];

s[pos]^=s[pos-3];

path[step]='u';

pos-=3;

return true;

}

bool down()

{

if(pos=6)return false;

s[pos]^=s[pos+3];

s[pos+3]^=s[pos];

s[pos]^=s[pos+3];

path[step]='d';

pos+=3;

return true;

}

bool left()

{

if(pos==0||pos==3||pos==6)return false;

s[pos]^=s[pos-1];

s[pos-1]^=s[pos];

s[pos]^=s[pos-1];

path[step]='l';

pos--;

return true;

}

bool right()

{

if(pos==2||pos==5||pos==8)return false;

s[pos]^=s[pos+1];

s[pos+1]^=s[pos];

s[pos]^=s[pos+1];

path[step]='r';

pos++;

return true;

}

bool operator==(const Nodex)const

{

int i;

for(i=0;i9;i++)if(s[i]!=x.s[i])return false;

return true;

}

void show()

{

int i,j;

for(i=0;i=6;i+=3,coutendl)

for(j=i;j=i+2;j++)

couts[j];

}

bool operator(const Nodex)const

{

int la=0,lb=0,i;

for(i=0;i8;i++)if(s[i]!=i+1)la++;la+=(s[8]!=0);

for(i=0;i8;i++)if(x.s[i]!=i+1)lb++;lb+=(x.s[8]!=0);

return lalb;

}

}S,A,tmp,top;

priority_queueNode Q;

bool hash[362880];

void mkfac(){int i;for(i=2;i=9;i++)fac[i]=fac[i-1]*i;}

int eval(char c){return c=='x'?0:c-'0';}

void output(Node x)

{

int i;

for(i=1;i=x.step;i++)

putchar(x.path[i]);

puts("");

}

int main()

{

char buf[11];

int i,t,l,r;

bool flag;

mkfac();

while(NULL!=gets(buf))

{

t=0;

for(i=0;i=7;i++)A.s[i]=i+1;A.s[8]=0;A.pos=8;

for(i=0;buf[i];i++)

{

if(buf[i]==' ')continue;

S.s[t]=eval(buf[i]);

if(S.s[t]==0)

S.pos=t;

t++;

}

l=r=0;

flag=false;

memset(hash,false,sizeof(hash));

S.step=0;

while(!Q.empty())Q.pop();

Q.push(S);

while(!Q.empty())

{

top=Q.top();

Q.pop();

top.step++;

tmp=top;

if(tmp.up())

{

if(!hash[t=tmp.hashval()])

{

hash[t]=true;

Q.push(tmp);

if(tmp==A)

{

//find ans...

output(tmp);

goto AA;

}

}

}

tmp=top;

if(tmp.down())

{

if(!hash[t=tmp.hashval()])

{

hash[t]=true;

Q.push(tmp);

if(tmp==A)

{

//find ans...

output(tmp);

goto AA;

}

}

}

tmp=top;

if(tmp.left())

{

if(!hash[t=tmp.hashval()])

{

hash[t]=true;

Q.push(tmp);

if(tmp==A)

{

//find ans...

output(tmp);

goto AA;

}

}

}

tmp=top;

if(tmp.right())

{

if(!hash[t=tmp.hashval()])

{

hash[t]=true;

Q.push(tmp);

if(tmp==A)

{

//find ans...

output(tmp);

goto AA;

}

}

}

}

AA:flag=true;

if(!flag)

puts("unsolvable");

}

return 0;

}

详解C语言算法

完整的程序如下:

typedef int status;

#define OK 1

#define ERROR 0

#define TRUE 1

#define FALSE 0

#define MAXSIZE 10

#includestdarg.h

#includeiostream.h

#includestdlib.h

typedef int ElemType;

#define MAXDIM 8

typedef struct{

ElemType * base;

int dim;

int *bounds;

int *constants;

}Array;

status InitArray(Array A,int dim,...)

{va_list ap;

if(dim1||dimMAXDIM) return ERROR;

A.dim=dim;

int i;

int total=1;

A.bounds=(int *)malloc(dim*sizeof(int));

if(!A.bounds) return ERROR;

va_start(ap,dim);

for(i=0;idim;i++)

{A.bounds[i]=va_arg(ap,int);

if(A.bounds[i]0) return ERROR;

total*=A.bounds[i];

}

va_end(ap);

A.base=(ElemType*)malloc(total*sizeof(ElemType));

if(!A.base) return ERROR;

A.constants=(int *)malloc(dim*sizeof(int));

if(!A.constants) return ERROR;

A.constants[dim-1]=1;

for(i=dim-2;i=0;i--)

A.constants[i]=A.constants[i+1]*A.bounds[i+1];

return OK;

}

status DestoryArray(Array A)

{if(!A.base) return ERROR;

free(A.base);

if(!A.bounds) return ERROR;

free(A.bounds);

if(!A.constants) return ERROR;

free(A.constants);

A.dim=0;

return OK;

}

status Locate(Array A,int off,...)

{va_list ap;

va_start(ap,off);

off=0;

int ind;

int i;

for(i=0;iA.dim;i++)

{ind=va_arg(ap,int);

if(indA.bounds[i]||ind0) return ERROR;

off+=ind*A.constants[i];

}

va_end(ap);

return OK;

}

status Value(Array A,ElemType e,...)

{int off;

va_list ap;

va_start(ap,e);

Locate(A,off,ap);

e=A.base[off];

va_end(ap);

return OK;

}

status Assign(Array A,ElemType e,...)

{int off;

va_list ap;

va_start(ap,e);

Locate(A,off,ap);

A.base[off]=e;

va_end(ap);

return OK;

}

int main()

{Array A;

InitArray(A,2,2,5);

int i;

for(i=0;i10;i++)

{ cout"请输入数据"endl;

cinA.base[i];

}

ElemType e;

int off;

Locate(A,off,2,3);

cout"偏移是"offendl;

Value(A,e,2,4);

cout"第二行第四列是"eendl;

cine;

Assign(A,e,2,2);

Value(A,e,2,2);

cout"第二行第二列是"eendl;

DestoryArray(A);

return 0;

}

执行InitArray(A,2,2,5)后

A.bounds[0]=2, A.bounds[1]=5

A.constants[1]=1, A.constants[0]=5

并且为A.base分配了10个ElemType型的元素空间

PS:关键是搞懂省略号参数列表的用法

求大神讲解一下C语言汉诺塔递归算法的简易理解

一开始我接触汉诺塔也是很不解,随着代码量的积累,现在很容易就看懂了,因此楼主主要还是对递归函数的理解不够深刻,建议你多写一些递归程序,熟练了自己就能理解。

圆盘逻辑移动过程+程序递归过程分析

hanoi塔问题, 算法分析如下,设a上有n个盘子,为了便于理解我将n个盘子从上到下编号1-n,标记为盘子1,盘子2......盘子n。

如果n=1,则将“ 圆盘1 ” 从 a 直接移动到 c。

如果n=2,则:

(1)将a上的n-1(等于1)个圆盘移到b上,也就是把盘1移动到b上;

(2)再将a上 “盘2” 移到c上;

(3)最后将b上的n-1(等于1)个圆盘移到c上,也就是第(1)步中放在b上的盘1移动到c上。

注意:在这里由于超过了1个盘子,因此不能直接把盘子从a移动到c上,要借助b,那

么 hanoi(n,one,two,three)的含义就是由n个盘子,从one移动到three,如果n2

那么就进行递归,如果n=1,那么就直接移动。

具体流程:

hanoi(2,a,b,c);由于21因此进入了递归的环节中。

1执行hanoi(1,a,c,b):这里就是刚才的步骤(1),代表借助c柱子,将a柱子上的 1个圆盘(盘1)移动到b柱子,其实由于是n=1,此时c柱子并没被用到,而是直接移动了。

2执行hanoi(1,a,b,c):这是步骤(2),借助b柱子,将a柱子上的一个圆盘(盘2)移动到c柱子上。这里由于也是n=1,也并没有真正借助b柱子,直接移动的。

3执行hanoi(1,b,a,c):这是步骤(3),将b上的一个盘子(盘1)移动到c

函数中由于每次调用hanoi的n值都是1,那么都不会进入递归中,都是直接执行了mov移动函数。

如果n=3,则:(倒着想会想明白)移动的倒数第二部,必然是下面的情况

(1)将a上的n`-1(等于2)个圆盘移到c上,也就是将盘1、盘2 此时都在b柱子上,只有这样才能移动最下面的盘子(盘3)。那么由于现在我们先忽略的最大的盘子(盘3),那么我们现在的目标就是,将两个盘子(盘1、盘2)从a柱子上,借助c柱 子,移动到b柱子上来,这个过程是上面n=2的时候的移动过程,n=2的移动过程是“2 个盘子,从柱子a,借助柱子b,移动到柱子c”。现在是“2个盘子,从柱子a,借助柱子 c,移动到柱子b上”。因此移动过程直接调用n=2的移动过程就能实现。

(2)将a上的一个圆盘(盘3)移到c。

(3)到这一步,由于已经将最大的盘子(盘3)移动到了目的地,此时无论后面怎么移动都不需要在用到最大的那个盘子(盘3),我们就先忽略他,剩下的目标就是将b上面的n-1个盘子(盘1、盘2)移动到c上,由于a上没有盘子了,此时要完成上面的目标,就要借助a盘子。最终达到的目标就是将b上的2个盘子,借助a移动到c上,这个过程就是当n=2时分析的过程了,仅仅是最开始的柱子(b柱子)和被借助的柱子(a柱子)不同了。所以直接调用n=2时候的过程就能股实现了。

具体执行过程:

hanoi(3,a,b,c);由于31因此进入了递归的环节中。

1执行hanoi(2,a,c,b):这里代表刚才的步骤(1),将两个盘子(盘1、盘2)从a移动到b,中间借助c。根据n=2的分析过程,必然是能够达到我们的目的。

2执行hanoi(1,a,b,c):现在a上只有一个盘子(盘3),直接移动到c上面即可。

3执行hanoi(2,b,a,c):此时对应步骤(3),剩下的目标就是将b上的两个盘子,借助a移动到c上。那么同样根据n=2的移动过程,必然能达到目的。

最终实现了3个盘子从a,借助b移动到了c。