郝斌数据结构（2）----栈和队列

栈的定义
栈—-定义：一种可以实现‘先进后出’的存储结构
栈类似于箱子
—-分类：
静态栈：
动态栈：
—-算法：
压栈（push）：
出栈（pop）：
栈的具体应用
①函数调用
②中断
③表达式求值（两个栈表示 一个栈为加减乘除号 一个栈存储数字）
④内存分配
⑤缓冲处理
⑥迷宫

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

typedef struct Node
{
    int data;
    struct Node * pNext;
}NODE, *PNODE;

typedef struct Stack
{
    PNODE pTop;
    PNODE pBottom;
}STACK, * PSTACK;//PSTACK==struct Stack *

void init(PSTACK);
void push(PSTACK pS, int);
void traverse(PSTACK);
bool pop(PSTACK, int *);

int main()
{
    STACK S; //STACK=struct Stack
    int val;

    init(&S);
    push(&S, 1);
    push(&S, 2);
    push(&S, 34);
    push(&S, 4343);

    if (pop(&S, &val))
    {
        printf("出栈成功，出栈的元素是%d\n", val);
    }
    else
        printf("出栈失败\n");

    traverse(&S);
}

void init(PSTACK pS)
{
    pS->pTop = (PNODE)malloc(sizeof(NODE));
    if (NULL == pS->pTop)
    {
        printf("动态内存分配失败！\n");
        exit(-1);
    }
    else
    {
        pS->pBottom = pS->pTop;
        pS->pTop->pNext = NULL;
    }

}

void push(PSTACK pS, int val)
{
    PNODE pNew = (PNODE)malloc(sizeof(NODE));

    pNew->data = val;
    pNew->pNext = pS->pTop;
    pS->pTop = pNew;
    return;
}

void traverse(PSTACK pS)
{
    PNODE p = pS->pTop;

    while (p != pS->pBottom)
    {
        printf("%d ", p->data);
        p = p->pNext;
    }
    printf("\n");

    return;
}

bool empty(PSTACK pS)
{
    if (pS->pTop == pS->pBottom)
        return true;
    else
        return false;
}

//把pS所指向的栈出栈一次，并把出栈的元素存入pVal形参所指向的变量中，如果出栈失败返回false
bool pop(PSTACK pS, int *pVal)
{
    if (empty(pS))//pS本身存放的就是S栈的地址
    {
        return false;
    }
    else
    {
        PNODE r = pS->pTop;
        *pVal = r->data;
        pS->pTop = r->pNext;
        free(r);
        r = NULL;

        return true;
    }
}

void clear()//
{

}

线性结构应用之二 队列
一种可以实现“先进先出”的存储结构（一端进一端出）
队列的分类：链式队列：用链表实现的，头部删除，尾部添加元素
静态队列：用数组实现的，而且静态队列通常都必须是循环队列。
循环队列的讲解：
1． 静态队列为什么必须是循环队列
2． 循环队列需要几个参数来确定
需要2个参数（front， rear）来确定，2个参数不同场合有不同的含义
1） 队列初始化
front和rear的值都是零
2） 队列非空
front代表的是队列的第一个元素，rear代表的是队列最后一个有效元素的下一个元素
3） 队列空
front和rear的值相等，但不一定是零
3． 循环队列各个参数的含义
4． 循环队列入队（r向上加）伪算法讲解 删除和添加元素的时候r和f都是向上移动
下图队列f指向C，r指向中，此时队列有效元素就C一个，因为r是指向有效元素的下一个元素
1） 将值存放r代表的位置
2） r的位置：r=（r+1）%数组的长度

5． 循环队列出队（f向上加）伪算法讲解
下图队列f指向C，r指向中，此时队列有效元素就C一个，因为r是指向有效元素的下一个元素
1）将值存放f代表的位置
2）f的位置：f=（f+1）%数组的长度

6． 如何判断循环队列是否为空
如果front与rear的值相等，则一定为空

7． 如何判断循环队列是否已满（重点）
预备知识：
Front的值可能比rear大，front的值也完全可能比rear小，也可能完全相等f
两种方式：
1. 多增加一个标识参数
2. 少用一个元素（比如n个元素，则只用n-1个元素）

**伪算法：
if((r+1)%数组长度== f)
已满
else
不满**

**队列算法：
入队
出队
队列的具体应用：
所有和时间有关的操作都有对列的影子**

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

typedef struct Queue
{
    int *pBase;
    int front;
    int rear;

}QUEUE;

void init(QUEUE *);
bool en_queue(QUEUE *, int val);//入队
void traverse_queue(QUEUE *);//遍历
bool full_queue(QUEUE *);//判断是否满队
bool emput_queue(QUEUE *);//判断是否空队
bool out_queue(QUEUE *, int *);//写成* 因为不加*就不能把参数传给主函数了

int main()
{
    QUEUE Q;
    int val;

    init(&Q);//取地址符才能改变实参的值
    en_queue(&Q, 1);
    en_queue(&Q, 2);
    en_queue(&Q, 3);
    en_queue(&Q, 4);
    en_queue(&Q, 5);
    en_queue(&Q, 6);
    en_queue(&Q, 7);
    en_queue(&Q, 8);

    traverse_queue(&Q);

    if (out_queue(&Q, &val))
    {
        printf(" 出队成功,队列出队的元素是: %d\n", val);
    }
    else
    {
        printf(" 出队失败!\n");
    }

    traverse_queue(&Q);
}

void init(QUEUE *pQ)//*pQ==Q pQ==&Q
{
    pQ->pBase = (int *)malloc(sizeof(int)* 6);//pBase相当于已经创建好了的数组
    pQ->front = 0;//初始化的front=rear=0
    pQ->rear = 0;
}

bool full_queue(QUEUE * pQ)
{
    if ((pQ->rear + 1) % 6 == pQ->front)
        return true;
    else
        return false;
}

bool en_queue(QUEUE *pQ, int val)
{
    if (full_queue(pQ))
    {
        return false;
    }
    else
    {
        pQ->pBase[pQ->rear] = val;//rear的下一个位置 因为pBase是数组,所以下标是rear
        pQ->rear = (pQ->rear + 1) % 6;
    }
}

void traverse_queue(QUEUE *pQ)
{
    int i = pQ->front;

    while (i != pQ->rear)
    {
        printf("%d ", pQ->pBase[i]);
        i = (i + 1) % 6;
    }
    printf("\n");

    return;
}

bool emput_queue(QUEUE *pQ)
{
    if (pQ->front == pQ->rear)
        return true;
    else
        return false;
}

bool out_queue(QUEUE *pQ, int *pVal)
{
    if (emput_queue(pQ))
    {
        return false;
    }
    else
    {
        *pVal = pQ->pBase[pQ->front];
        pQ->front = (pQ->front + 1) % 6;
        return true;
    }