数据结构快速回顾——栈

堆栈，也可直接称栈，是一种特殊的串行形式的数据结构，它的特殊之处在于只能允许在链结串行或阵列的一端进行加入资料和输出资料的运算。另外堆栈也可以用一维阵列或连结串行的形式来完成。

#define STACK_INIT_SIZE 100
#define STACKINCREMENT    10

typedef  struct   
{  int* top;   
   int* base;   
   int stacksize;   
}SqStack;

int InitStack(SqStack &S)
{
    S.base = (int*)malloc(sizeof(int)*STACK_INIT_SIZE);
    if(!S.base)exit(1);//分配内存失败
    S.stacksize = STACK_INIT_SIZE;
    S.top = S.base;
    return 1;
}
//栈顶插入
int Push(SqStack &S,int e)   
{
    if(S.top - S.base >= S.stacksize)
    {
        S.base = (int*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(int));
        if(!S.base)exit(1);//分配内存失败
        S.top = S.base+S.stacksize;
        S.stacksize += STACKINCREMENT；
    }
    *S.top++ = e;
    return 1;
}
int Pop(SqStack &S,int &e)   
{
    if(S.top == S.base)
        return 0;
    e = *--S.top;
    return 1;
}

迷宫求解问题实现：

// mazepath.cpp : Defines the entry point for the console application.   
//   
   
#include "stdafx.h"   
#include "stdio.h"   
#include "stack.h"   
#include "malloc.h"   
   
#define RANGE 10    //设置数组的最大长度   
   
   
typedef int DirectType;   
   
typedef struct {   
    int r,c;    //迷宫中r行c列的位置   
}PosType;   
   
typedef struct {   
    int row,col;   
    char arr[RANGE][RANGE];//各位置取值' ','#','@'或'*'   其中#表示墙壁 @表示走不通的节点 *表示走过的节点
}MazeType;   
   
   
typedef struct {   
    int step;           //当前位置在路径上的“序号”   
    PosType seat;       //当前的坐标位置   
    DirectType di;      //往下一坐标位置的方向   
}ElemType;              //栈的元素类型   
   
   
typedef struct NodeType {   
    ElemType data;         
    struct NodeType *next;   
}NodeType,*LinkType;    //结点类型，指针类型   
   
typedef struct {   
    LinkType top;   
    int size;   
}Stack;                 //栈类型   
                       
   
void Initialization(){   
    printf("CreatMaze-c
");   
    printf("MazePsth-c
");   
    printf("PrintMaze-c
");   
}   
   
void MakeNode(LinkType &p,ElemType e){   
    p=(LinkType)malloc(sizeof(NodeType));   
    p->data.step=e.step;   
    p->data.seat.r=e.seat.r;   
    p->data.seat.c=e.seat.c;   
    p->data.di=e.di;   
}   
//标记走过的节点
void FootPrint(MazeType &Maze,PosType curpos){   
    Maze.arr[curpos.r][curpos.c]='*';   
}   
   
int Pass(MazeType &Maze,PosType curpos){   
    if(Maze.arr[curpos.r][curpos.c]=='#'||Maze.arr[curpos.r][curpos.c]=='@')   
        return 0;   
    else return 1;   
}   
           
   
   
void CreateMaze(MazeType &Maze){   
    int i,j;   
    printf("产生迷宫：输入迷宫的大小
");   
    printf("行：
");   
    scanf("%d",&Maze.row);   
    printf("列：
");   
    scanf("%d",&Maze.col);   
    //给迷宫四周加障碍   
    for(i=0;i<=Maze.row+1;i++)   
        for(j=0;j<=Maze.col+1;j++)   
            if(i==0||i==Maze.row+1)Maze.arr[i][j]='#';   
            else if(j==0||j==Maze.col+1)Maze.arr[i][j]='#';   
            else Maze.arr[i][j]=' ';   
    //接收障碍位置   
    printf("如果设置障碍结束，请输入“q”,否则输入障碍所在行
");   
    scanf("%d",&i);   
    while(i!='q'){   
        printf("输入障碍所在列
");   
        scanf("%d",&j);   
        Maze.arr[i][j]='#';   
        printf("如果设置障碍结束，请输入“q”,否则输入障碍所在行
");   
        scanf("%d",&i);   
    }   
}   
//标记四个方向都走不通的节点   
void MakePrint(MazeType &Maze,PosType curpos){   
    Maze.arr[curpos.r][curpos.c]='@';   
}   
   
   
void NextPos(PosType &curpos,DirectType di){   
    switch(di){   
    case 1:curpos.c++;break;   
    case 2:curpos.r++;break;   
    case 3:curpos.c--;break;   
    case 4:curpos.r--;break;   
    }   
}   
   
   
   
void PrintMaze(MazeType Maze){   
    int i,j;   
    for(i=1;i<=Maze.row;i++){   
        for(j=1;j<=Maze.col;j++){   
            printf("%c",Maze.arr[i][j]);   
        }   
        printf("
");   
    }   
   
   
   
int MazePath(MazeType Maze,PosType start,PosType end){   
    PosType curpos;   
    ElemTpye e;   
    int curstep=1,found=0;   
    InitStack(S);   
    curpos=start;   
    do{   
        if(Pass(Maze,curpos)){   
            FootPrint(Maze,curpos);   
            e.step=curstep;   
            e.seat=curpos;   
            e.di=1;   
            Push(S,e);   
            if(curpos==end)found=1;   
            else {   
                curpos=NextPos(curpos,1);   
                curstep++:   
            }//else   
        }//if   
        else    
            if (!StackEmpty(S)){   
                Pop(S,e);   
                while(e.di==4&&!StackEmpty(S)){   
                    MarkPrint(Maze,e.seat);   
                    Pop(S,e);   
                    curstep--;   
                }//while   
                if(e.di<4){   
                    e.di++;   
                    Push(S,e);   
                    curpos=NextPos(e.seat,e.di);   
                }//if   
            }//if   
    }while(!StackEmpty(S)&&!found);   
    return found;   
}//Mazepath