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) + 1);
    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("内存分配失败！
");
    }
    else
    {
        printf("内存分配成功！
");
    }*/

    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 0;
}

附：

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

1、main.cpp文件

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

#include "Stack.h"
//地图
int Map[9][8] = {
    0, 0, 1, 1, 1, 1, 1, 0,
    1, 1, 1, 0, 0, 0, 1, 0,
    1, 3, 5, 4, 0, 0, 1, 0,
    1, 1, 1, 0, 4, 3, 1, 0,
    1, 3, 1, 1, 4, 0, 1, 0,
    1, 0, 1, 0, 3, 0, 1, 1,
    1, 4, 0, 7, 4, 4, 3, 1,
    1, 0, 0, 0, 3, 0, 0, 1,
    1, 1, 1, 1, 1, 1, 1, 1
};

//实现退回操作
void Retrogress(PLIST p_list)
{
    //1.获取栈顶数据
    PLIST p_Temp = GetStackTop(p_list);
    if (NULL == p_Temp)
    {
        return;
    }
    for (int i = 0; i < 9; i++)
    {
        for (int j = 0; j < 8; 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 = 0; i < 9; i++)
    {
        for (int j = 0; j < 8; j++)
        {
            switch (Map[i][j])
            {
            case 0: //0表示空地
                putimage(j * 45, i * 45, &g_blank);
                break;
            case 1: // 1表示墙壁
                putimage(j * 45, i * 45, &g_wall);
                break;
            case 3: // 3表示目的地
                putimage(j * 45, i * 45, &g_point);
                break;
            case 4: // 4表示箱子
                putimage(j * 45, i * 45, &g_box);
                break;
            case 5: // 5表示人
                putimage(j * 45, i * 45, &g_people);
                break;
            case 7: // 7表示箱子在目的地   4+3
                putimage(j * 45, i * 45, &g_dbox);
                break;
            case 8: // 8表示人在目的地   5+3
                putimage(j * 45, i * 45, &g_people);
                break;
            }
        }
    }
}

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

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

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

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

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

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

    return 0;
}


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


2、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)[8]);

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

void Pop_Stack(PLIST p_list);

int isEmpty(PLIST p_list);


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


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

void Push_Stack(PLIST p_list, int(*pArr)[8])
{
    PLIST node = (PLIST)malloc(sizeof(LIST));
    //先给二级指针申请内存   
    node->p = (int **)malloc(sizeof(int)* 9); // p就相当于是一个  指针数组  int *p[9]
    for (int i = 0; i < 9; i++)
    {
        //通过这个就能够分配一个二维数组
        node->p[i] = (int*)malloc(sizeof(int)* 8);
    }
    for (int i = 0; i < 9; i++)
    {
        for (int j = 0; j < 8; 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