数据结构读书笔记第三章 栈和队列

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

３.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;
}