个人中心
gpt4 book ai didi

C语言实现汉诺塔游戏

转载 作者：qq735679552 更新时间：2022-09-27 22:32:09 27 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章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语言实现汉诺塔游戏的文章就讲到这里了,如果你想了解更多关于C语言实现汉诺塔游戏的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

27 4 0
文章推荐： 站长之路:从零开始重拾我的个人站长之路
文章推荐： SEO优化 网站首页设计优化时SEO应注意的六点基本操作
文章推荐： 如何规避网站网页相似风险？提升网站质量水平
文章推荐： 如何为你的网站挑选适宜的Web开发框架？
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
全站热门文章
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com