C++学习（三十七）（C语言部分）之 链式栈（推箱子实现）

用链表实现栈
一开始在表头插入，就要一直在表头插入
一开始在表尾插入，就要一直在表头插尾
表头当栈底 也可以把表尾当栈底

实现的测试代码笔记如下：

 #include<stdio.h>
 #include<stdlib.h>
 #include<string.h>

 //节点的结构体
 typedef struct Node
 {
     char *name;
     struct Node *pNext;
 }LIST, *PLIST;

 //1.创建“火车头”  创建一个表头
 void CreateListHead(PLIST *p_list)  //传入头结点指针 给他分配内存
 {
     //一级指针 形参和实参结合时
     //PLIST p_list = p_head;  形参和实参结合时候的赋值
     //p_list 改变 是不影响到p_head  就好像是A给B发送了一个文件 B对文件进行了修改，是不会影响A手中的文件

     //要改变一级指针的实参 函数要传入一级指针的地址 保存一级指针的地址 要使用二级指针
     *p_list = (PLIST)malloc(sizeof(LIST));
     (*p_list)->pNext = NULL;

 }

 //实现一个栈
 //2.写入栈函数
 void Push_Stack(PLIST p_list, char *name)
 {
     //头插法
     PLIST node = (PLIST)malloc(sizeof(LIST));
     //node->name - name;  可以这么写 但是如果存入得扇区内存，会被释放掉 就会出错
     node->name = (char *)malloc(sizeof(char)*strlen(name) + );
     strcpy(node->name, name);
     node->pNext = p_list->pNext;
     p_list->pNext = node;
 }

 //3.获取栈顶元素
 char * GetStackTop(PLIST p_list)
 {
     //如果不是空 就返回头结点的下一个节点的name
     PLIST p_Temp = p_list->pNext;
     if (p_Temp != NULL)
     {
         return p_Temp->name;
     }
     return NULL;  //说明栈是空
 }

 //4.出栈
 void Pop_Stack(PLIST p_list)
 {
     //相当于删除结点  之前是头插法  那么最后一个在最前面
     PLIST p_Temp = p_list->pNext;
     if (p_Temp != NULL)
     {
         //p_remp保存第一个节点的地址
         p_Temp = p_list->pNext;
         //让头结点的pnext连接到第二个节点
         p_list->pNext = p_Temp->pNext;
     }
     free(p_Temp);  //释放内存  释放掉第一个节点 是释放p_temp里面所保存的内存 而不是释放指针变量
 }

 //5.判断栈是否为空
 int isEmpty(PLIST p_list)
 {
     //如果栈为空 返回1
     return p_list->pNext == NULL;
 }

 int main()
 {
     PLIST p_head = NULL;  //作为链表的标记
     CreateListHead(&p_head);
     /*if (NULL == p_head)
     {
         printf("内存分配失败！\n");
     }
     else
     {
         printf("内存分配成功！\n");
     }*/

     Push_Stack(p_head, "力");
     Push_Stack(p_head, "努");
     Push_Stack(p_head, "的");
     Push_Stack(p_head, "人");
     Push_Stack(p_head, "何");
     Push_Stack(p_head, "任");
     Push_Stack(p_head, "于");
     Push_Stack(p_head, "亚");
     Push_Stack(p_head, "不");
     Push_Stack(p_head, "的");
     Push_Stack(p_head, "出");
     Push_Stack(p_head, "付");
     while (!isEmpty(p_head))
     {
         printf("%s", GetStackTop(p_head));
         Pop_Stack(p_head);
     }

     getchar();
     return ;
 }

附：

推箱子实现，代码笔记如下所示：

 、main.cpp文件

 //推箱子
 //操作说明 WASD表示上下左右移动 空格键可以退回到上一步
 #if 1
 #include<graphics.h>
 #include<stdio.h>
 #include <conio.h>

 #include "Stack.h"
 //地图
 int Map[][] = {
     , , , , , , , ,
     , , , , , , , ,
     , , , , , , , ,
     , , , , , , , ,
     , , , , , , , ,
     , , , , , , , ,
     , , , , , , , ,
     , , , , , , , ,
     , , , , , , ,
 };

 //实现退回操作
 void Retrogress(PLIST p_list)
 {
     //1.获取栈顶数据
     PLIST p_Temp = GetStackTop(p_list);
     if (NULL == p_Temp)
     {
         return;
     }
     for (int i = ; i < ; i++)
     {
         for (int j = ; j < ; j++)
         {
             Map[i][j] = p_Temp->p[i][j];
         }
     }
     Pop_Stack(p_list);  //出栈
 }

 //对于一个游戏1.初始化  加载图片
 IMAGE g_box, g_dbox, g_people, g_point, g_wall, g_blank;
 void Init_Game()
 {
     loadimage(&g_box, L"./source/box.jpg");  //相对路径
     loadimage(&g_dbox, L"./source/dbox.jpg");
     loadimage(&g_people, L"./source/people.jpg");
     loadimage(&g_point, L"./source/point.jpg");
     loadimage(&g_wall, L"./source/wall.jpg");
     loadimage(&g_blank, L"./source/blank.jpg");
 }

 //2.加载图片
 void Paint_Game()
 {
     for (int i = ; i < ; i++)
     {
         for (int j = ; j < ; j++)
         {
             switch (Map[i][j])
             {
             case : //0表示空地
                 putimage(j * , i * , &g_blank);
                 break;
             case : // 1表示墙壁
                 putimage(j * , i * , &g_wall);
                 break;
             case : // 3表示目的地
                 putimage(j * , i * , &g_point);
                 break;
             case : // 4表示箱子
                 putimage(j * , i * , &g_box);
                 break;
             case : // 5表示人
                 putimage(j * , i * , &g_people);
                 break;
             case : // 7表示箱子在目的地   4+3
                 putimage(j * , i * , &g_dbox);
                 break;
             case : // 8表示人在目的地   5+3
                 putimage(j * , i * , &g_people);
                 break;
             }
         }
     }
 }

 //3.实现人物移动
 void MovePeople(PLIST p_list)
 {
     int i, j;
     for (i = ; i < ; i++)
     {
         for (j = ; j < ; j++)
         {
             //找到人的位置
             if (Map[i][j] ==  || Map[i][j] == )
             {
                 //if成立说明找到人
                 break;
             }
         }
         if (Map[i][j] ==  || Map[i][j] == )
         {
             //if成立说明找到人
             break;
         }
     }
     switch (getch())
     {
 //表示往左边移动
     case 'a':
         //人的左边是空地 或者 是目的
         if (Map[i][j - ] ==  || Map[i][j - ] == )
         {
             Map[i][j - ] += ;  //人往左边移动
             Map[i][j] -= ;  //人离开了当前位置
         }//人的左边是箱子或者是箱子在目的
         else if (Map[i][j - ] ==  || Map[i][j - ] == )
         {
             if (Map[i][j - ] ==  || Map[i][j - ] == )
             {
                 Map[i][j - ] += ;
                 Map[i][j - ] += ;
                 Map[i][j] -= ;
             }
         }
         //每次移动都要入栈
         Push_Stack(p_list, Map);
         break;

 //表示往右边
     case 'd':
         //人的右边是空地 或者 是目的
         if (Map[i][j + ] ==  || Map[i][j + ] == )
         {
             Map[i][j + ] += ;  //人往左边移动
             Map[i][j] -= ;  //人离开了当前位置
         }//人的右边是箱子或者是箱子在目的
         else if (Map[i][j + ] ==  || Map[i][j + ] == )
         {
             if (Map[i][j + ] ==  || Map[i][j + ] == )
             {
                 Map[i][j + ] += ;
                 Map[i][j + ] += ;
                 Map[i][j] -= ;
             }
         }
         //每次移动都要入栈
         Push_Stack(p_list, Map);
         break;

 //表示往上边移动
     case 'w':
         //人的上边是空地 或者 是目的
         if (Map[i - ][j] ==  || Map[i - ][j] == )
         {
             Map[i - ][j] += ;  //人往上边移动
             Map[i][j] -= ;  //人离开了当前位置
         }//人的上边是箱子或者是箱子在目的
         else if (Map[i - ][j] ==  || Map[i - ][j] == )
         {
             if (Map[i - ][j] ==  || Map[i - ][j] == )
             {
                 Map[i - ][j] += ;
                 Map[i - ][j] += ;
                 Map[i][j] -= ;
             }
         }
         //每次移动都要入栈
         Push_Stack(p_list, Map);
         break;

 //表示什么往下边移动
     case 's':
         //人的下边是空地 或者 是目的
         if (Map[i + ][j] ==  || Map[i + ][j] == )
         {
             Map[i + ][j] += ;  //人往左边移动
             Map[i][j] -= ;  //人离开了当前位置
         }//人的下边是箱子或者是箱子在目的
         else if (Map[i + ][j] ==  || Map[i + ][j] == )
         {
             if (Map[i + ][j] ==  || Map[i + ][j] == )
             {
                 Map[i + ][j] += ;
                 Map[i + ][j] += ;
                 Map[i][j] -= ;
             }
         }
         //每次移动都要入栈
         Push_Stack(p_list, Map);
         break;
     case VK_SPACE: //空格
         if (!isEmpty(p_list))
         {
             Retrogress(p_list);
             Paint_Game();
         }
     }
 }

 //4.判断游戏是否结束
 int  isWin()
 {
     for (int i = ; i < ; i++)
     {
         for (int j = ; j < ; j++)
         {
             if (Map[i][j] == )
             {
                 return ;
             }
         }
     }
     return ;
 }

 int main()
 {
     initgraph(, );  //初始化图形界面
     Init_Game();
     PLIST p_head = NULL;
     CreateListHead(&p_head);
     Paint_Game();
     while (!isWin())
     {
         Paint_Game();
         MovePeople(p_head);
     }
     Paint_Game();
     getchar();//防止运行到closegraph() 直接退出 看不到效果
     closegraph(); //关闭图形界面

     return ;
 }

 *********************分割线************************

 、Stack.h文件
 #include <stdlib.h>
 #include <stdio.h>
 /*
 以后  头文件是用来声明函数 或者类
 */
 typedef struct Node
 {
     //char *name;   //前面是不是讲过动态分配二维数组
     //通过指针数组来实现
     int **p;  //目的：分配二维数组用来保存我的地图信息
     struct Node * pNext;
 }LIST, *PLIST;

 void CreateListHead(PLIST *p_list);

 void Push_Stack(PLIST p_list, int(*pArr)[]);

 //返回整个结点的内容
 PLIST  GetStackTop(PLIST p_list);  

 void Pop_Stack(PLIST p_list);

 int isEmpty(PLIST p_list);

 *********************分割线************************

 、Stack.cpp文件
 #include "Stack.h"

 void Push_Stack(PLIST p_list, int(*pArr)[])
 {
     PLIST node = (PLIST)malloc(sizeof(LIST));
     //先给二级指针申请内存
     node->p = (int **)malloc(sizeof(int)* ); // p就相当于是一个  指针数组  int *p[9]
     for (int i = ; i < ; i++)
     {
         //通过这个就能够分配一个二维数组
         node->p[i] = (int*)malloc(sizeof(int)* );
     }
     for (int i = ; i < ; i++)
     {
         for (int j = ; j < ; j++)
         {
             node->p[i][j] = pArr[i][j];
         }
         //代码  提升写代码能  语法有关
         //思路  实现功能 首先你要有思路
         //逻辑   你的方法的逻辑性是否可以
         // 栈  链表
     }
     //连接指针
     node->pNext = p_list->pNext;
     p_list->pNext = node;
     // int a[5]
     // int *a[5]  a二级指针
 }

 PLIST  GetStackTop(PLIST p_list)
 {
     if (p_list->pNext != NULL)
     {
         return p_list->pNext;
     }
     return NULL;
 }

 void Pop_Stack(PLIST p_list)
 {
     PLIST p_Temp = NULL;
     if (p_list->pNext != NULL)
     {
         //p_temp保存第一节点的地址
         p_Temp = p_list->pNext;

         //让头节点的pnext连接到第二个结点
         p_list->pNext = p_Temp->pNext;
     }
     //释放掉第一个结点
     free(p_Temp);  //会释放p_temp里面所保存的内存 而不是释放指针变量
 }

 int isEmpty(PLIST p_list)
 {
     return p_list->pNext == NULL;
 }

 void CreateListHead(PLIST *p_list) //传入头节点指针 给它分配内存
 {
     *p_list = (PLIST)malloc(sizeof(LIST));
     (*p_list)->pNext = NULL;
 }

最后实现效果如下所示;

2019-04-01  21:33:15