3.1 栈的定义
栈是限制在表的一端进行插入和删除操作的线性表.允许进行插入,删除操作的一端是栈顶.另一个固定端称为栈底,当表中美柚元素时候称为空栈.是一种后进先出的线性表.
3.2 栈的顺序存储和运算实现
#define MaxSize 100
typedef int DataType;
//栈的顺序存储定义
typedef struct
{
DataType data[MaxSize];
int top;
}Stack;
//栈的初始化
Stack *Init_Stack()
{
Stack *s;
s=new Stack;
if(!s)
return NULL;
else
{
s->top=-1;
return s;
}
}
int isEmpty_Stack(Stack *s)
{
if(s->top==-1)
return 1;
else
return 0;
}
int Push_Stack(Stack *s,int x)
{
if(s->top==MaxSize-1)
return NULL:
else
{
s->top++;
s->data[top]=x;
return 1;
}
}
int Pop_Stack(Stack *s,int *x)
{
if(isEmpty_Stack(s))
return 0;
else
{
*x=s->data[top];
x->top--;
return 1;
}
}
DataType Top_Stack(Stack *s)
{
if(isEmpty_Stack(s))
return 0;
else
return s->data[top];
}
3.3 栈的链式存储和运算
typedef struct Node{
DataType data;
struct Node *next;
}SNode,*LinkStack;
LinkStack *Init_Stack()
{
return NULL;
}
int isEmpty_Stack(LinkStack top)
{
if(top==NULL)
return 1;
else
return 0;
}
LinkStack Push_Stack(LinkStack top,DataType x)
{
SNode *p;
p=new SNode;
s->data=x;
s->next=top;
top=s;
return top;
}
LinkStack Pop_Stack(LinkStack top,DataType *x)
{
SNode *p;
if(top==NULL)
return NULL;
else
{
*x=top->data;
p=top;
top=p->next;
delete p;
return top;
}
}
3.4 栈的应用
typedef int DataType;
void conversion(int N,int r) //进制转化
{
Stack s;
DataType x;
Init_Stack(&s);
while(N)
{
Push_Stack(&s,N%r);
N=N/r;
}
while(!isEmpty_Stack(&s))
{
Pop_Stack(&s,x)
cout<<x;
}
cout<<endl;
}
void conversion(int N,int r)
{
int S[100],top;
int x;
int top=-1;
while(N)
{
s[++top]=N%r;
N=N/r;
}
while(top!=-1)
{
x=s[top-1];
cout<<x;
}
cout<<endl;
}
int Path(int maze[m][n],int move[8]) //迷宫的走法
{
Stack s;
DataType tmp;
int x,y,d,i,j;
tmp.x=1;
tmp.y=1;
tmp.d=-1;
Push_Stack(s,tmp);
while(!isEmpty_Stack(s))
{
Pop_Stack(s,tmp);
x=tmp.x;
y=tmp.y;
d=tmp.d+1;
while(d<8)
{
i=x+move[d].x;
j=y+move[d].y;
if(maze[i][j]==0)
{
temp={x,y,d};
Push_Stack(s,tmp);
x=i;
y=j;
maze[x][y]=-1;
if(x==m&&y==n)
return 1;
else
d=0;
}
else
d++;
}
}
return 0;
}
3.5 队列的定义
队列是一种先进先出的数据结构,即插入操作在表一端进行,而删除操作在表的另一端进行,将这种数据结构称为队或者队列,把允许进行掺入操作的一端叫做队尾.
由于一般的队列,会出现假溢出的现象,我们接下来讨论的一般是循环队列
3.6 循环队列的顺序存储和运算
typedef struct
{
DataType data[MaxSize];
int front,rear;
int num;
}SeQueue;
SeQueue *Init_SeQueue()
{
SeQueue q;
q=new SeQueue;
q->front=q->rear=MaxSize-1;
q->num=0;
return q;
}
int In_SeQueue(SeQueue *q,DataType x)
{
if(q->num==MaxSize-1)
return 0;
else
{
q->rear=(q->rear+1)%MaxSize;
q->data[q->rear]=x;
q->num++;
return 1;
}
}
int Out_SeQueue(SeQueue *q,DataType *x)
{
if(q->num==0)
return 0;
else
{
q->front=(q->front+1)%MaxSize;
*x=q->data[q->front];
q->num--;
return 1;
}
}
int Empty_SeQueue(SeQueue *q)
{
if(q->num==0)
return 1;
else
return 0;
}
3.7 队列的链式存储
#define MaxSize 100
typedef struct {
DataType data[MaxSize];
int rear,front;
int num;
}SeQueue;
SeQueue *Init_SeQueue()
{
SeQueue q;
q=new SeQueue;
q->front=q->rear=MaxSize-1;
q->num=0;
return q;
}
int In_SeQueue(SeQueue *q,DataType x)
{
if(q->num==MaxSize)
return 0;
else
{
q->rear=(q->rear+1)%MaxSize;
q-data[q->rear]=x;
q->num++;
return 1;
}
}
int Out_SeQueue(SeQueue *q,DataType *x)
{
if(q->num==0)
return 0;
else
{
q->front=(q->front+1)%MaxSize;
*x=q->data[front];
q->num--;
return 1;
}
}
int Empty_SeQueue(SeQueue *q)
{
if(q->num==0)
return 1;
else
return 0;
}
typedef struct Node{
DataType data;
struct Node *next;
}QNode;
typedef struct {
QNode *front,*rear;
}LQueue;
LQueue *q;
LQueue *Init_LQueue()
{
LQueue *q;
QNode *p;
q=new LQueue;
p=new QNode;
p->next=NULL;
q->front=q->rear=p;
return q;
}
void In_LQueue(LQueue *q,DataType x)
{
QNode *p;
p=new QNode;
p->data=x;
p->next=NULL;
q->rear->next=p;
q->rear=p;
}
int Out_LQueue(LQueue *q,DataType x)
{
QNode *p;
if(Empty_LQueue(q))
return 0;
else
{
p=q->front->next;
q->front->next=p->next;
x=p->data;
delete p;
if(q->front->next==NULL)
q->rear=q->front;
return 1;
}
}
int Empty_LQueue(LQueue *q)
{
if(q->front==q->rear)
return 1;
else
return 0;
}