a演算法解讀c語言,演算法 c語言

本文目錄一覽：

1、C語言演算法a(n)=2^n+1過程怎麼寫！急！
2、求A* 演算法C語言源程序
3、求一個A*演算法的C語言或C++代碼，小弟不勝感激，謝謝
4、求8數碼A或A*演算法（用C語言）
5、詳解C語言演算法
6、求大神講解一下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-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;

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; //最小優先順序隊列(開啟列表)

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}

求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。

原創文章，作者：小藍，如若轉載，請註明出處：https://www.506064.com/zh-tw/n/312860.html

a演算法解讀c語言,演算法 c語言

本文目錄一覽：

C語言演算法a(n)=2^n+1過程怎麼寫！急！

求A* 演算法C語言源程序

求一個A*演算法的C語言或C++代碼，小弟不勝感激，謝謝

求8數碼A或A*演算法（用C語言）

詳解C語言演算法

求大神講解一下C語言漢諾塔遞歸演算法的簡易理解

相關推薦

發表回復