服务器之家

服务器之家 > 正文

C语言实现汉诺塔游戏

时间：2021-02-24 14:34     来源/作者：C语言教程网

操作就是：A B 号码A的塔顶一层放在号码B的塔顶。如1（空格） 3 回车。 话说有人能把我这C的代码添加到QT界面框架上去么？  代码写的不好 ，维护性不够，只能玩8层的，写完以后发现很难拓展，软件工程，设计模式有待提高....
里面提示输入等级的装B用了，没有实现，大家随便输入个个位数就可以玩了。

stackfunc.c

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
#include"STACK.h"
#include<stdio.h>
extern ceng CENG[SIZE];
//数据入栈
void push_stack(stack*p,int number){
  p->arr[p->head]=number;
  p->head++;
}
 
//初始化栈1
void init_stack1(stack*p){
  p->head=0;
  push_stack(p,1);
  push_stack(p,2);
  push_stack(p,3);
  push_stack(p,4);
  push_stack(p,5);
  push_stack(p,6);
  push_stack(p,7);
  push_stack(p,8);
}
//初始化栈2 3
void init_stack2_3(stack* p1,stack* p2){
  p1->head=0;
  p1->arr[p1->head]=0;
  p2->head=0;
  p2->arr[p2->head]=0;
}
//弹出栈顶元素
int pop_stack(stack* p){
  p->head--;
  return p->arr[p->head];
}
//访问栈顶元素
int top_stack(stack* p){
  return p->arr[p->head-1];
}
//比较两个栈顶元素的大小
int sizecmp_stack(stack* p1,stack* p2){
  if(p1->arr[p1->head-1]>p2->arr[p2->head-1])
  return 1;
  else if(p1->arr[p1->head-1]<p2->arr[p2->head-1])
  return -1;
  else return 0;
}
 
//测出栈的高度
int high_stack(stack* p){
  return p->head;
}
 
//是否为空栈
int empty_stack(stack* p){
  return p->head==0;
}
 
//是否栈满
int full_stack(stack* p){
 return p->head==SIZE;
}
 
//初始化层1
void init_ceng1(ceng* p){
  p->number=1;
  p->row=SIZE-1;
  p->col=0;
}
 
//初始化层2
void init_ceng2(ceng* p){
  p->number=2;
  p->row=SIZE-2;
  p->col=0;
}
 
//初始化层3
void init_ceng3(ceng* p){
  p->number=3;
  p->row=SIZE-3;
  p->col=0;
}
 
//初始化层4
void init_ceng4(ceng* p){
  p->number=4;
  p->row=SIZE-4;
  p->col=0;
}
//初始化层5
void init_ceng5(ceng*p){
  p->number=5;
  p->row=SIZE-5;
  p->col=0;
}
//初始化层6
void init_ceng6(ceng*p){
  p->number=6;
  p->row=SIZE-6;
  p->col=0;
  }
//初始化层7
void init_ceng7(ceng*p){
  p->number=7;
  p->row=SIZE-7;
  p->col=0;
}
//初始化层8
void init_ceng8(ceng*p){
  p->number=8;
  p->row=SIZE-8;
  p->col=0;
}
//移动层
void move_ceng(int level,int *nrow,int *ncol,stack*p1,stack* p2,stack* p3,int stdec){
  stack* arr[3];
   arr[0]=p1;
   arr[1]=p2;
   arr[2]=p3;
  *nrow=level-1-high_stack(arr[stdec]);
  *ncol=stdec;
}
 
 //显示图片
void show_map(void){
  int i,j;
  for(i=0;i<SIZE;i++)
  {
    for(j=0;j<3;j++)
    { 
     if(CENG[0].row==i&&CENG[0].col==j)
     {
      printf("  |    1    |  ");
     }else if(CENG[1].row==i&&CENG[1].col==j)
     {
      printf("  |   2   |  ");
     }else if(CENG[2].row==i&&CENG[2].col==j)
     {
      printf("   |   3   |   ");
     }else if(CENG[3].row==i&&CENG[3].col==j)
     {
      printf("   |  4  |   ");
     }else if(CENG[4].row==i&&CENG[4].col==j)
     {
      printf("    |  5  |    ");
     }else if(CENG[5].row==i&&CENG[5].col==j)
     {
      printf("    | 6 |    ");
     }else if(CENG[6].row==i&&CENG[6].col==j){
      printf("     | 7 |     ");
     }else if(CENG[7].row==i&&CENG[7].col==j){
      printf("     |8|     ");
  }else  printf("            ");
    }
    printf("\n");
  }
  printf("=====================================================================\n");
}

main.c

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
#include"STACK.h"
#include<stdio.h>
 
ceng CENG[SIZE];
int main(){
  int res=1,dec=1;
  char con;
  int newrow;
  int newcol;
  int step=0;
  int level=0;
 while(1)
{  if (level==0)
  {
    do{
    printf("请输入游戏等级:\n");
    scanf("%d",&level);
    if(level<=0||level>8)
    printf("等级范围错误，重新输入\n");
    }while(level<=0||level>8);
  }
  level=8;
  newrow=0,newcol=0;
  stack STACK[3];
  //初始化3个栈
  init_stack1(&STACK[0]);
  init_stack2_3(&STACK[1],&STACK[2]);
  //初始化8个层
  init_ceng1(&CENG[0]);
  init_ceng2(&CENG[1]);
  init_ceng3(&CENG[2]);
  init_ceng4(&CENG[3]);
  init_ceng5(&CENG[4]);
  init_ceng6(&CENG[5]);
  init_ceng7(&CENG[6]);
  init_ceng8(&CENG[7]);
while(1)
{ 
  //打印画面
  switch(level){
  case 1:show_map();break;
  case 2:show_map();break;
  case 3:show_map();break;
  case 4:show_map();break;
  case 5:show_map();break;
  case 6:show_map();break;
  case 7:show_map();break;
  case 8:show_map();break;
  }
while(1)
 {
 // printf("游戏等级为:%d\n",level);
// printf("源栈最高层是%d ......\n",top_stack(&STACK[res]));
  printf("   一号的高度%d ",STACK[0].head);
  printf("      二号的高度%d ",STACK[1].head);
  printf("     三号的高度%d\n",STACK[2].head);
  printf("\n已经走的步数为 %d \n",step);
  //选择源 目标
  scanf("%d",&res);
  scanf("%d",&dec);
  res--;
  dec-- ;
  if(!(res>=0&&res<3&&dec>=0&&dec<3))/*||(empty_stack(&STACK[res]))*/
  {  printf("\n\n输入范围超出\n");
  }else if(empty_stack(&STACK[res])==1)
  {
    printf("%d\n",STACK[0].head);
    printf("\n\n源栈空\n");
  }
  else if(sizecmp_stack(&STACK[res],&STACK[dec])<0)
  {  printf("\n\n大块的不能放在小块的上面\n");
  }else
  { 
    if(dec!=res){
    printf("\n\n\n正在移动层块....\n");
    step++;
    move_ceng(level,&newrow,&newcol,&STACK[0],&STACK[1],&STACK[2],dec);
    CENG[top_stack(&STACK[res])-1].row=newrow;
    CENG[top_stack(&STACK[res])-1].col=newcol;
    push_stack(&STACK[dec],pop_stack(&STACK[res]));
    break;
    }else
    {
      printf("\n\n\n放轻松\n");
    }break;
 
  }
  show_map();
 }
   
  if (full_stack(STACK+1)==1||full_stack(STACK+2)==1)
  {
    printf("完成了汉诺塔!\n");
    level++;
    break;
  }
}
  show_map();
  printf("是否继续游戏?继续请输入y,否则按其它键\n");
  scanf("%*[^\n]");
  scanf("%*c");
  scanf("%c",&con);
  if(con!='y')
  break;
}
  return 0;
}

STACK.h

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
#ifndef     __STACK_H__
#define     __STACK_H__
#define     SIZE    8
typedef struct STACK{
  int head;
  int arr[SIZE];
}stack;
 
typedef struct CENG{
  int number;
  int row;
  int col;
}ceng;
 
extern ceng CENG[SIZE];
 
//入栈
void push_stack(stack*,int);
//初始化栈1
void init_stack1(stack*);
//初始化栈2和3
void init_stack2_3(stack*,stack*);
//出栈
int pop_stack(stack*);
//访问栈顶元素
int top_stack(stack*);
//比较栈顶元素大小 -1 1
int sizecmp_stack(stack*,stack*);
//判断栈的高度
int high_stack(stack*);
//判断栈是否为空1 0
int empty_stack(stack*);
//判断栈是否满1 0
int full_stack(stack*);
 
//初始化层1
void init_ceng1(ceng*);
//初始化层2
void init_ceng2(ceng*);
//初始化层3
void init_ceng3(ceng*);
//初始化层4
void init_ceng4(ceng*);
//初始化层5
void init_ceng5(ceng*);
//初始化层6
void init_ceng6(ceng*);
//初始化层7
void init_ceng7(ceng*);
//初始化层8
void init_ceng8(ceng*);
//移动层块
void move_ceng(int ,int * a,int *b,stack*,stack*,stack*,int k );
//打印画面
void show_map();
#endif

演示图片

C语言实现汉诺塔游戏

C语言实现汉诺塔游戏

以上所述就是本文的全部内容了，希望能够对大家学习C语言的递归算法有所帮助

标签：
C语言 游戏 汉诺塔 

相关文章

热门资讯

2020微信伤感网名听哭了 让对方看到心疼的伤感网名大全
2020微信伤感网名听哭了 让对方看到心疼的伤感网名大全 2019-12-26
yue是什么意思 网络流行语yue了是什么梗
yue是什么意思 网络流行语yue了是什么梗 2020-10-11
Intellij idea2020永久破解，亲测可用！！！
Intellij idea2020永久破解，亲测可用！！！ 2020-07-29
背刺什么意思 网络词语背刺是什么梗
背刺什么意思 网络词语背刺是什么梗 2020-05-22
苹果12mini价格表官网报价 iPhone12mini全版本价格汇总
苹果12mini价格表官网报价 iPhone12mini全版本价格汇总 2020-11-13
返回顶部