栈（stack）和队列（queue）

栈的定义（特点：FILO）

是一种只能在一端进行插入或删除操作的线性表。

其中允许进行插入或删除操作的一端称为栈顶（Top），栈顶由一个称为栈顶指针的位置指示器（对于顺序栈，就是记录栈顶元素所在数组位置标号的一个整型变量；对于链式栈，就是记录栈顶元素所在结点地址的指针）来指示，它是动态变化的。表的另一端称为栈底，是固定不变的。栈的插入和删除操作一般称为入栈和出栈。

栈的数学性质

当n个元素以某种顺序进栈，并且可在任意时刻出栈（在满足先进后出的前提下），所获得的元素排列数目N恰好满足函数Catalan()的计算，即

$N=\frac{1}{n+1}C_{2n}^{n}$

队列的定义（特点：FIFO）

仅允许在表的一端进行插入，在表的另一端进行删除。可进行插入的一段称为队尾（Rear），可进行删除的一端称为队头（Front）。

A.顺序栈（较为重要70%）

/*顺序栈定义*/
typedef struct
{
    int data[maxSize];
    int top;
}SqStack;

几个状态：1）栈空状态st.top==-1；2）栈满状态st.top==maxSize-1；3）非法状态（上溢和下溢）

两个操作：1）元素x进栈操作++(st.top);st.data[st.top]=x; 2）元素x出栈操作x=st.data[st.top];--(st.top);

/*初始化栈*/
void initStack(SqStack &st)
{
    st.top=-1;
}

/*判断栈空*/
int isEmpty(SqStack st)
{
    if (st.top==-1)
        return 1;
    else
        return 0;
}

/*进栈*/
int push(SqStack &st,int x)
{
    if (st.top==maxSize-1)
        return 0;
    ++(st.top);
    st.data[st.top]=x;
    return 1;
}

/*出栈*/
int pop(SqStack &st,int &x)
{
    if (st.top==-1)
        return 0;
    x=st.data[st.top];
    --(st.top);
    return 1;
}

/*简写形式*/
int stack[maxSize];
int top=-1;


stack[++top]=x;    //元素x进栈

x=stack[top--];    //元素x出栈

B.链栈（次要30%）

/*链栈结点定义*/
typrdef struct LNode
{
    int data;  //数据域
    struct LNode *next;  //指针域
}LNode;

两个状态：1）栈空 lst->next==NULL 2）栈满不存在栈满的情况

两个操作：1）元素（由p指针所指）进栈 p->next=lst->next; lst->next=p; //头插法建立链表中的插入操作

2）出栈（出栈元素保存在x中）p=lst->next; x=p->data; lst->next=p->next; free(p); //单链表的删除操作

/*链栈的初始化*/
void initStack(LNode *&lst)
{
    lst=(LNode*)malloc(sizeof(LNode));
    lst->next=NULL;
}

/*判空*/
int isEmpty(LNode *lst)
{
    if (lst->next==NULL)
        return 1;
    else
        return 0;
}

/*进栈*/
void push(LNode *lst,int x)
{
    LNode *p;
    p=(LNode*)malloc(sizeof(LNode));
    p->next=NULL;
    /*以下为链表的头插法*/
    p->data=x;
    p->next=lst->next;
    lst->next=p;
}

/*出栈*/
int pop(LNode *lst,int &x)
{
    LNode *p;
    if (lst->next==NULL)
        return 0;
    /*以下为单链表的删除操作*/
    p=lst->next;
    x=p.data;
    lst->next=p->next;
    free(p);
    return 1;
}

顺序队

/*顺序队列定义*/
typedef struct
{
    int data[maxSize];
    int front;  //队首“指针”
    int rear;  //队尾“指针”
}SqQueue;  //顺序队类型定义

循环队列的要素

两个状态：1）队空状态 qu.rear==qu.front 2）队满状态 (qu.rear+1)%maxSize==qu.front

两个操作：

/*元素x进队*/
qu.rear=(qu.rear+1)%maxSize;
qu.data[qu.rear]=x;
/*元素x出队*/
qu.front=(qu.front+1)%maxSize;
x=qu.data[qu.front];

/*初始化队列*/
void initQueue(SqQueue &qu)
{
    qu.front=qu.rear=0;  //队首和队尾指针重合并且指向0
}

/*判空*/
int isQueueEmpty(SqQueue qu)
{
    if (qu.rear==qu.front)  //不论队首、队尾指针指向数组中的哪个位置
        return 1;           //只要两者重合，即为队空
    else
        return 0;
}

/*进队*/
int enQueue(SqQueue &qu,int x)
{
    if ((qu.rear+1)%maxSize==qu.front)  //队满的判断条件
        return 0;
    qu.rear=(qu.rear+1)%maxSize;  //先移动指针
    qu.data[qu.rear]=x;  //再存入元素
    return 1;
}

/*出队*/
int deQueue(SqQueue &qu,int &x)
{
    if (qu.front=qu.rear)  //队空的判断条件
        return 0;
    qu.front=(qu.front+1)%maxSize;  //先移动指针
    x=qu.data[qu.front];  //保存出队元素
    return 1;
}

链队定义

/*1).队结点类型定义*/
typedef struct QNode
{
    int data;
    struct QNode *next;
}QNode;

/*2).链队类型定义*/
typedef struct
{
    QNode *front;  //队头指针
    QNode *rear;   //队尾指针
}LiQueue;  //链队类型定义

栈（stack）和队列（queue）

猜你喜欢