C语言实现汉诺塔游戏_C 语言

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

stackfunc.c

#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

#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

#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语言实现、des加密算法c语言实现、算法 c语言实现，以便于您获取更多的相关知识。

时间： 2024-09-07 08:14:39

C语言实现汉诺塔游戏_C 语言的相关文章

VC++实现模拟汉诺塔效果_C 语言

先上效果图 再附上源代码: 汉诺塔: 复制代码 代码如下: #include "stdio.h" #include "math.h" int arrA[15], arrB[15], arrC[15];   // 分别为A.B.C int length; int lenA, lenB, lenC; char plate[32]; // Make void makeplate(int n) {     int i;     if (n == length + 1)   

初学者c语言动态汉诺塔帮忙注释

问题描述 初学者c语言动态汉诺塔帮忙注释 #include #include #define N 1000 void gotoxy(int x, int y); // 声明gotoxy函数 void colorxy(int x, int y); //声明colorxy函数 void hanoi(int n,char a,char b,char c); //声明hanoi函数 void move(int n,char a,char b); //声明move函数 void Print(); //声明

Go语言实现汉诺塔算法_Golang

hano.go package main import ( "bufio" "fmt" "os" "strconv" ) func main() { fmt.Print("输入要移动的盘子数:") reader := bufio.NewReader(os.Stdin) lool: data, _, _ := reader.ReadLine() n, err := strconv.Atoi(string(da

汉诺塔游戏的设计

汉诺塔问题是最经典的递归问题,笔者就该问题设计了这个游戏,由用户交互 游戏和自动演示两部分组成,支持撤销功能.选关.自动完成等功能. 首先 建立了类CMap,该类主要实现用户每一步的操作和画图显示功能,记录的时候只 须记录每组盘子的个数和盘子的矩形.代码和注释如下: //记录 每一步的盘子的情况 class CMap { public: //每组 盘子的个数 int iCount[3]; //3组盘子里面,每个盘子的位 置,用矩形表示 RECT *Rect[3]; //构造函数 CMap() {

汉诺塔的C语言实现以及冒泡排序

汉诺塔绝对是一个经典的算法题目,虽然当年也讲过,程序也不长,但是一直以来总觉得理解的不清楚,看程序也能明白什么意思,过一段时间程序忘了,想不起来的时候,就怎么都想不明白了,虽然说好像是那么回事,就是高不明白.借着前两天做八皇后的东风,顺便来理一下这个汉诺塔.园盘从上到下编号1, 2, --, n,杆子从左至右A,B,C,A是from,C是to.我还是看了以前的java程序然后自己理解一下写的C程序,几乎没有差别,当然写的时候也忘了不少,第一遍出来错误的答案.程序如下: #include <std

C++实现汉诺塔算法经典实例_C 语言

本文所述为汉诺塔算法的C++代码的经典实现方法. 汉诺塔问题描述:3个柱为a.b.c,圆盘最初在a柱,借助b柱移到c柱.需要你指定圆盘数. 具体实现代码如下: #include <iostream> using namespace std; int times = 0; //全局变量,搬动次数 //第n个圆盘从x柱搬到z柱 void move(int n, char x, char z) { cout << "第" << ++times <&l

C语言递归实现汉诺塔算法

汉诺塔的递归实现算法,将A中的圆盘借助B圆盘完全移动到C圆盘上, 每次只能移动一个圆盘,并且每次移动时大盘不能放在小盘上面 递归函数的伪算法为如下: if(n == 1) 直接将A柱子上的圆盘从A移动到C else 先将A柱子上的n-1个圆盘借助C柱子移动到B柱子上 直接将A柱子上的第n个圆盘移动到C柱子上 最后将B柱子上的n-1个圆盘借助A柱子移动到C柱子上 该递归算法的时间复杂度为O(2的n次方),当有n个圆盘时,需要移动圆盘2的n次方-1次 操作系统:ubuntu 编译软件:gcc 结果截

c语言汉诺塔-汉诺塔可以用递归吗 不找规律的话

问题描述 汉诺塔可以用递归吗 不找规律的话 汉诺塔可以用递归吗 不找规律的话 求大神指点 递归应该怎么用才能解决汉诺塔 谢谢了 解决方案 汉诺塔本来就应该用递归,不用递归反倒麻烦,需要用堆栈模拟.http://blog.csdn.net/kkkkkxiaofei/article/details/8333644 解决方案二: #include<stdio.h> void move(int n,char a,char b,char c) { if(n==1) printf("t%c-&g

用栈来求解汉诺塔变形问题

package stackAndQueue; import java.util.Stack; /** * 用栈来求解汉诺塔问题:HanoiStack[3] * * [问题描述]:将汉诺塔游戏(小压大)规则修改,不能从左(右)侧的塔直接移到右(左)侧,而是必须经过中间塔. * * 求当塔有N层时,打印最优移动过程和最优移动步数.如N=2,记上层塔为1,下层为2.则打印:1:left->mid;1 * * 由于必须经过中间,实际动作只有4个:左L->中M,中->左,中->右R,右-&g