C语言用顺序栈求解迷宫问题

2019年3月24日 262次阅读来源: 迷宫问题

//头文件

stack.h

#ifndef STACK_H_INCLUDED
#define STACK_H_INCLUDED

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

#define STACK_INIT_SIZE 30
#define STACK_INCR_SIZE 5

typedef struct
{
int x ;
int y ;
} PosType ;

typedef struct
{
PosType position ;
int direction ;
} ElemType ;

typedef struct Sqstack
{
ElemType* Sbase ;
ElemType* Stop ;
int StackSize ;
} Sqstack ;

int InitStack( Sqstack* s ) ;
int DestroyStack( Sqstack* s ) ;
int GetTop( Sqstack* s , ElemType* e ) ;
int GetLength( Sqstack* s ) ;
int Push( Sqstack* s , ElemType e ) ;
int Pop( Sqstack* s , ElemType* e ) ;
int IsEmpty( Sqstack* s ) ;
int ClearStack( Sqstack* s ) ;
int TraveserStack( Sqstack* s ) ;

#endif // STACK_H_INCLUDED

maze.h

#ifndef MAZE_H_INCLUDED
#define MAZE_H_INCLUDED
#include “stack.h”
int MazePath(Sqstack* s ) ;
ElemType NextPos( ElemType CurrPos ) ;

#endif // MAZE_H_INCLUDED

//函数实现

maze.c

#include “maze.h”

#define ROW 10
#define COL 10

int maze[ROW][COL]=
{
{ 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 } ,
{ 1 , 1 , 1 , 1 , 1 , 1 , 1 , 0 , 0 , 0 } ,
{ 0 , 0 , 0 , 0 , 0 , 0 , 1 , 1 , 0 , 0 } ,
{ 0 , 1 , 1 , 1 , 1 , 1 , 1 , 0 , 1 , 0 } ,
{ 0 , 1 , 1 , 0 , 1 , 0 , 0 , 1 , 1 , 0 } ,
{ 0 , 1 , 1 , 1 , 0 , 1 , 1 , 1 , 1 , 0 } ,
{ 0 , 1 , 1 , 1 , 0 , 1 , 0 , 0 , 1 , 0 } ,
{ 0 , 1 , 1 , 0 , 0 , 1 , 0 , 1 , 1 , 0 } ,
{ 0 , 1 , 1 , 1 , 1 , 1 , 1 , 0 , 1 , 1 } ,
{ 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 }
} ;

PosType start = { 1 , 0 } ;//入口
PosType end = { 8 , 9 } ;//出口

int MazePath( Sqstack* s )
{

ElemType currpos ;//当前位置的信息
ElemType e ;//中间变量
currpos.position = start ;
currpos.direction = 0 ;
do
{
if( maze[currpos.position.x][currpos.position.y] == 1 )
{
maze[currpos.position.x][currpos.position.y] = 2 ;
e.position.x = currpos.position.x ;
e.position.y = currpos.position.y ;
e.direction = 0 ;
Push( s , e ) ;
// TraveserStack( s ) ;
if( ( currpos.position.x == end.x ) && ( currpos.position.y == end.y ) )
{
printf( “success to find the export!\n” ) ;
return 0 ;
}
else
{
currpos = NextPos( currpos ) ;
currpos.direction = 0 ;
}
}
else
{
if( !IsEmpty( s ) )
{
Pop( s , &e ) ;
//printf(“[%d , %d ] , %d\n” , e.position.x , e.position.y , e.direction ) ;
while( ( e.direction == 3 ) && ( !IsEmpty( s ) ) )
{
maze[e.position.x][e.position.y] = -1 ;
Pop( s , &e ) ;
// printf(“[%d , %d ] , %d\n” , e.position.x , e.position.y , e.direction ) ;
}
if( e.direction < 3 )
{
e.direction++ ;
Push( s , e ) ;
currpos = NextPos( e ) ;
currpos.direction = 0 ;
// printf(“[%d , %d ]%d\n” ,currpos.position.x , currpos.position.y , e.direction ) ;
}
}
}
}
while( !IsEmpty( s ) ) ;
printf(“fail to find the export!\n”) ;
exit( 1 ) ;
}

ElemType NextPos( ElemType CurrPos )
{
ElemType nepos ;
if( CurrPos.direction == 0 )
{
nepos.position.x = CurrPos.position.x ;
nepos.position.y = CurrPos.position.y + 1 ;
}
else if( CurrPos.direction == 1 )
{
nepos.position.x = CurrPos.position.x + 1 ;
nepos.position.y = CurrPos.position.y ;
}
else if( CurrPos.direction == 2 )
{
nepos.position.x = CurrPos.position.x ;
nepos.position.y = CurrPos.position.y -1 ;
}
else if( CurrPos.direction == 3 )
{
nepos.position.x = CurrPos.position.x – 1 ;
nepos.position.y = CurrPos.position.y ;
}
return nepos ;
}

stack.c

#include “stack.h”

int InitStack( Sqstack* s )
{
s->Sbase = ( ElemType* )malloc( STACK_INIT_SIZE * sizeof( ElemType ) ) ;
if( !s->Sbase )
{
printf( ” OVERFLOW !\n” ) ;
exit( 1 ) ;
}
memset( s->Sbase , 0 , STACK_INIT_SIZE * sizeof( ElemType ) ) ;
s->Stop = s->Sbase ;
s->StackSize = STACK_INIT_SIZE ;
return 0 ;
}

int DestroyStack( Sqstack* s )
{
ElemType* p = –s->Stop ;
while( s->Stop != s->Sbase )
{
s->Stop– ;
free( p– ) ;
}
free( s->Sbase ) ;
free( p ) ;
return 0 ;
}

int Push( Sqstack* s , ElemType e )
{
if( s->Stop – s->Sbase >= s->StackSize )
{
s->Sbase = ( ElemType* )realloc( s->Sbase , ( s->StackSize + STACK_INCR_SIZE ) * sizeof( ElemType ) ) ;
if( !s->Sbase )
{
printf( ” OVERFLOW !\n” ) ;
exit( 1 ) ;
}
s->Stop = s->Sbase + STACK_INIT_SIZE ;
s->StackSize += STACK_INCR_SIZE ;
}
*s->Stop++ = e ;
return 0 ;
}

int GetLength( Sqstack* s )
{
return s->Stop – s->Sbase ;
}

int GetTop( Sqstack* s , ElemType* e )
{
if( s->Sbase == s->Stop )
{
printf( “ERROR!\n”) ;
exit( 1 ) ;
}
*e = * ( s->Stop – 1 ) ;//为什么改成 e = –s->Stop ; 不行？
// printf( “(%d , %d)\t%d\n” , e->position.x , e->position.y , e->direction ) ;
return 0 ;
}
int Pop( Sqstack* s , ElemType* e )
{
if( s->Sbase == s->Stop )
{
printf( “the stack is empty !\n” ) ;
exit( 1 ) ;
}
*e = *–s->Stop ;
return 0 ;
}

int IsEmpty( Sqstack* s )
{
if( s->Sbase == s->Stop )
{
return 1 ;
}
return 0 ;
}

int ClearStack( Sqstack* s )
{
memset( s->Sbase , 0 , s->StackSize * sizeof( ElemType ) ) ;
s->Stop = s->Sbase ;
return 0 ;
}

int TraveserStack( Sqstack* s )
{
if( s->Stop == s->Sbase )
{
printf( “the stack is empty !\n” ) ;
exit( 1 ) ;
}
ElemType* p = s->Sbase ;
while( p != s->Stop )
{
printf( “( %d , %d ) %d\n” , p->position.x , p->position.y , p->direction ) ;
p++ ;
}
printf( “\n” ) ;
return 0 ;
}

主函数

#include “maze.h”
#include “stack.h”
#include <stdio.h>
#include <stdlib.h>

int main( void )
{
Sqstack s ;
InitStack( &s ) ;
MazePath( &s ) ;
TraveserStack( &s ) ;
return 0 ;
}

    原文作者：迷宫问题
    原文地址: https://blog.csdn.net/llcomeon1_/article/details/7751039
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。