栈的定义
栈—-定义:一种可以实现‘先进后出’的存储结构
栈类似于箱子
—-分类:
静态栈:
动态栈:
—-算法:
压栈(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;
}