编辑代码

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

//------------------------------------------汉诺塔---------------------------------------
void exchange(int a, int b, int* c)
{
    //a，b为c中要交换元素的下标
    int spam = 0;
    spam = c[a];
    c[a] = c[b];
    c[b] = spam;
    return;
}

void hanNuo(int p, int q, int r, int* c)
{
    //p、q、r都存储塔上的圆环数，c顺序存储pqr所在塔的编号
    //p是圆环最初所在的塔，q是辅助塔，r为目标塔。
    //判断p的值，若为1，则直接将圆环移动到目标塔；
    //若大于1，则先将p-1个圆环移动到辅助塔，再将最后1个圆环移到目标塔，最后将p-1个圆环从辅助塔移动到目标塔。
    if (p == 1){
        printf("%d --> %d\n",c[0], c[2]);
        return;
    }
    else{
        exchange(1,2,c);
        hanNuo(p-1, r, q, c);
        exchange(1,2,c);
        q=p-1,p=1;
        printf("%d --> %d\n",c[0], c[2]);
        p-=1,r+=1;
        exchange(0,1,c);
        hanNuo(q, p, r, c);
        exchange(0,1,c);
        return;
    }
}

//------------------------------------------进制转换---------------------------------------------
typedef struct{
    //用于进制转换函数binaryChange
    int* base;
    int* top;
    int length;
}stackInt;
#define INITIAL_LEN_ST_INT 100
#define INCREASE_LEN_ST_INT 10
#define OVERFLOW 0
#define ERROR -1

void create_STINT(stackInt &s){
    //用于stackINT的初始化
    s.base = (int*)malloc(sizeof(int) * INITIAL_LEN_ST_INT);
    if (!s.base) exit(OVERFLOW);
    s.top = s.base;
    s.length = INITIAL_LEN_ST_INT;
}
void destroy_STINT(stackInt &s){
    if(!s.base) return;
    free(s.base);
    s.base = nullptr, s.top = nullptr;
}
int len_STINT(stackInt s){
    return s.top - s.base;
}
void insert_STINT(stackInt &s, int val){
    if(len_STINT(s) >= s.length){
        //若栈已满，则扩容。
        s.base = (int*)realloc(s.base, (s.length+INCREASE_LEN_ST_INT)*sizeof(int));
        if (!s.base) exit(OVERFLOW);
        s.top = s.base + s.length;
        s.length += INCREASE_LEN_ST_INT;
    }
    *s.top = val;
    s.top++;
    return;
}
void pop_STINT(stackInt &s, int& val){
    //删除栈顶元素，并用val返回其值
    if(s.top == s.base){
        //检测为空栈
        exit(ERROR);
    }
    s.top--;
    val = *s.top;
    return;
}


void binaryChange(int p, int num)
{
    //此函数利用栈来转换进制。
    //用p表示要转换的目标进制，num为待转换的十进制数
    stackInt s;
    create_STINT(s);
    while(num != 0){
        insert_STINT(s, num%p);
        num = num/p;
    }
    int n = len_STINT(s), e = 0;
    while(--n>=0){
        pop_STINT(s,e);
        printf("%d", e);
    }
    printf("\n");
}


//-------------------------------------迷宫----------------------------------------
typedef struct{
    //迷宫坐标
    int x;
    int y;
}pos;
typedef struct{
    //迷宫节点数据类型
    pos p;
    int exploring;
}elemMaze;
typedef struct{
    //用于保存迷宫地点的栈
    elemMaze* base;
    elemMaze* top;
    int stackSize;
}stackMaze;
typedef struct{
    //迷宫地图
    int** m;
    int size;
}mazeMap;
#define INIT_LEN_STMZ 100
#define INCREA_LEN_STMZ 10

void init_STMZ(stackMaze& m){
    //初始化迷宫栈
    m.base = (elemMaze*)malloc(sizeof(elemMaze)*INIT_LEN_STMZ);
    if(!m.base) exit(OVERFLOW);
    m.top = m.base;
    m.stackSize = INIT_LEN_STMZ;
}
int len_STMZ(stackMaze m){
    //返回迷宫栈中元素的个数
    return m.top-m.base;
}
void push_STMZ(stackMaze& m, elemMaze e){
    //在迷宫栈中插入新元素e
    if (len_STMZ(m) >= m.stackSize){
        m.base = (elemMaze*)realloc(m.base, sizeof(elemMaze)*(m.stackSize+INCREA_LEN_STMZ));
        if(!m.base) exit(OVERFLOW);
        m.top = m.base + m.stackSize;
        m.stackSize += INCREA_LEN_STMZ;
    }
    *m.top = e;
    m.top++;
}
void pop_STMZ(stackMaze& m, elemMaze& e){
    //删除栈顶元素，并用e返回其值
    if (len_STMZ(m) == 0){
        exit(ERROR);
    }
    m.top-=1;
    e = *m.top;
}
void get_STMZ(stackMaze m, elemMaze& e){
    //用e返回栈顶元素
    if (len_STMZ(m) == 0){
        exit(ERROR);
    }
    e = *(m.top-1);
}
void destroy_STMZ(stackMaze& m){
    free(m.base);
    m.top = nullptr;
}

void copy_Pos(pos& p1, pos p2){
    //将p2的值复制给p1
    p1.x = p2.x, p1.y = p2.y;
}
bool equal_Pos(pos p1, pos p2){
    //判断p1，p2是否相等
    return p1.x == p2.x && p1.y == p2.y;
}
void mark_Maze(mazeMap& m, pos p){
    m.m[p.y][p.x] = 2;
}
bool couldGo(mazeMap m, pos p){
    return m.m[p.y][p.x] == 0;
}
pos next_pos(pos p, int ex_point){
    switch(ex_point){
        case 1:
            p.x+=1;
            return p;
        case 2:
            p.y+=1;
            return p;
        case 3:
            p.x-=1;
            return p;
        case 4:
            p.y-=1;
            return p;
        default:
            p.x = -1, p.y = -1;
            return p;
    }
}
void show_Maze(mazeMap m)
{
    //m为表示迷宫的二维数组，n1，n2分别表示x轴，y轴的长度
    for (int i=0;i < m.size;i++){
        for (int j=0;j<m.size;j++){
            printf("%d ", m.m[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}
void create_Maze(mazeMap& m)
{
    m.size = 5;
    m.m = (int**)malloc(sizeof(int*)*m.size);
    if(!m.m) exit(OVERFLOW);
    for (int i=0;i<m.size;i++){
        m.m[i] = (int*)malloc(sizeof(int)*m.size);
    }
    for(int i=0;i<m.size;i++){
        for(int j=0;j<m.size;j++){
            m.m[i][j] = 1;
        }
    }
    m.m[1][1] = 0, m.m[1][2] = 0, m.m[2][2] = 0;
    m.m[2][3] = 0, m.m[3][3] = 0, m.m[2][1] = 0;
    show_Maze(m);
}
void destroy_Maze(mazeMap& m)
{
    for(int i=0;i<m.size;i++){
        free(m.m[i]);
    }
    free(m.m);
}
bool mazePath(pos start, pos end, mazeMap& m)
{
    //表示迷宫地图的二维数组，值为1表示当前坐标不可达，值为0表示当前坐标可达;
    //修改迷宫某个坐标状态为已抵达，函数mark_Maze();
    //记录某个坐标及其对周围的探索度，栈stackMaze;
    //根据某个坐标的探索度，确定下一个坐标，函数next_pos();
    //输出迷宫状态，函数show_Maze();
    //判断某个坐标是否可达，函数couldGo();
    pos cur;
    copy_Pos(cur, start);
    stackMaze sm;
    elemMaze e;
    init_STMZ(sm);
    while(!equal_Pos(cur, end))
    {
        if (couldGo(m, cur)){
            copy_Pos(e.p, cur);
            e.exploring = 1;
            push_STMZ(sm, e);
            mark_Maze(m, cur);
            cur = next_pos(e.p, e.exploring);
        }
        else{
            while (len_STMZ(sm) != 0)
            {
                pop_STMZ(sm, e);
                while(e.exploring <= 4 && !couldGo(m, next_pos(e.p, e.exploring))){
                    e.exploring += 1;
                }
                if (e.exploring <= 4){
                    copy_Pos(cur,next_pos(e.p, e.exploring));
                    push_STMZ(sm, e);
                    break;
                }
            }
            if (len_STMZ(sm) == 0){
                return false;
            }
        }
    }
    destroy_STMZ(sm);
    return true;
}

int main () {
    //JSRUN引擎2.0，支持多达30种语言在线运行，全仿真在线交互输入输出。 
    printf("Hello world!     - c.jsrun.net.\n");
    mazeMap m;
    pos start, end;
    start.x = 1, start.y = 1;
    end.x = 3, end.y=3;
    create_Maze(m);
    if (mazePath(start, end, m)){
        show_Maze(m);
    }
    destroy_Maze(m);
    /*stackMaze sm;
    init_STMZ(sm);
    elemMaze e;
    for (int i=0;i<10;i++)
    {
        e.p.x = i+3, e.p.y = (i+1)*2l;
        e.exploring = i;
        push_STMZ(sm, e);
    }
    while(len_STMZ(sm) != 0){
        pop_STMZ(sm, e);
        printf("%d %d %d\n", e.p.x, e.p.y, e.exploring);
    }
    destroy_STMZ(sm);*/
    return 0;
}