//特殊的线性表 栈和列队
//栈 插入和删除受到一定限制的线性表
// 只能从一端插入 删除 特点 先进后出
//栈的插入操作 入栈\压栈
//栈的删除操作 出栈\弹栈
//插入和删除的一端是栈顶 另一端是栈底
#include<stdio.h>
#include<assert.h>
#include "Seqlist.h"
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include "SeqStack.h"
//初始化函数
void Init_SeqStack(SeqStack* psq)
{
assert(psq != NULL);
psq->base =(ELRMTYPE*) malloc(STACK_INIT_SIZE * sizeof(ELRMTYPE));
if (psq->base == NULL)
exit(EXIT_FAILURE);
psq->top = 0;
psq->stacksize = STACK_INIT_SIZE;//STACK_INIT_SIZE 本质是10；
/* assert(psq != NULL);*/
/* psq->base = (ELRMTYPE*)malloc(STACK_INIT_SIZE * sizeof(ELRMTYPE));
if (psq->base == NULL)
exit(EXIT_FAILURE);
psq->top = 0;
psq->stacksize = STACK_INIT_SIZE;*/
/* assert(psq != NULL);
psq->base = (ELRMTYPE*)malloc(STACK_INIT_SIZE * sizeof(ELRMTYPE));
if (psq->base == NULL)
exit(EXIT_FAILURE);
psq->top = 0;
psq->stacksize = STACK_INIT_SIZE;*/
}
//2 入栈
bool Push(SeqStack* psq, ELRMTYPE val)
{
assert(psq != NULL);
// 1. 先判断栈是否已满（栈满不能入栈）
if (psq->top == psq->stacksize )
Increase(psq);
// 2. 把元素存入栈顶
psq->basepsq-\>top = val;
// 3. 栈顶指针先上移一位
psq->top++;
// 4. 入栈成功
return true;
/* assert(psq != NULL);
if (psq->top == psq->stacksize)
Increase(psq);
psq->basepsq-\>top = val;
psq->top++;
return true;*/
/* assert(psq != NULL);
if (psq->top == psq->stacksize)
Increase(psq);
psq->basepsq-\>top = val;
psq->top++;
return true;*/
}
//3 出栈
bool Pop(SeqStack* psq)
{
assert(psq != NULL);
if (psq->top == 0)
return false;
psq->top--;
/* assert(psq!=NULL);
if (psq->top == 0)
return false;
psq->top--;*/
/*assert(psq != NULL);
if (psq->top == 0)
return false;
psq->top--;*/
}
//4 获取栈顶元素值（只瞄一眼栈顶的最新元素是是多少，别动他）
ELRMTYPE Top(const SeqStack* psq)
{
assert(psq != NULL);
if (psq->stacksize == NULL)
return false;
return psq->basepsq-\>top-1;
/* assert(psq != NULL);
if (psq->stacksize == NULL)
return false;
return psq->basepsq-\>top - 1;*/
/* assert(psq != NULL);
if (psq->stacksize == NULL)
return false;
return psq->basepsq-\>top - 1;*/
}
//5 扩容
void Increase(SeqStack* psq)
{
ELRMTYPE* tmp = (ELRMTYPE*)realloc(psq->base, psq->stacksize * sizeof(ELRMTYPE)*2);
psq->base = tmp;
psq->stacksize = psq->stacksize*2;
/* ELRMTYPE* tmp = (ELRMTYPE*)realloc(psq->base, psq->stacksize * sizeof(ELRMTYPE) * 2);
psq->base = tmp;
psq->stacksize = psq->stacksize * 2;*/
}
//6 判空
bool Empty(SeqStack* psq)
{
assert(psq != NULL);
return psq->stacksize == 0;
/* assert(psq != NULL);
return psq->stacksize == 0;*/
}
//7 判满
bool Full(SeqStack* psq)
{
assert(psq != NULL);
psq->top == psq->stacksize ;
/* assert(psq != NULL);
psq->top == psq->stacksize;*/
}
//8 打印
void show(SeqStack* psq)
{
assert(psq != NULL);
for (int i = 0; i < psq->stacksize; i++)
{
printf("%d", psq->basei);
}
printf("\n");
/*assert(psq != NULL);
for (int i = 0; i < psq->stacksize; i++)
{
printf("%d", psq->basei);
}
printf("\n");*/
}
//9 清空
void Clear(SeqStack* psq)
{
assert(!Empty);
psq->top=0;
}
//10 销毁
void Destroy(SeqStack* psq)
{
assert(psq != NULL);
free(psq->base);
psq->base = NULL;
psq->top = 0;
psq->stacksize = 0;
//assert(psq != NULL);
//free(psq->base);
//psq->base = NULL;
//psq->top = 0;
//psq->stacksize = 0;
}
//
#pragma once
//队列 受到限制的线性表
//只不过和栈受到的限制不一样 栈 只能在表尾进行插入和删除 队列只能在一端进行插入 一端进行删除 先进先出
// 入队与出队
//插入数据的一端叫队尾 删除数据的一端叫队首
//链式队列 头插入 尾删除 （用这个）头删除 尾插入
typedef int ELEMTYPE;
//链式队列的有效节点设计
typedef struct LQNode
{
ELEMTYPE data;
struct LQNode* next;
}LQNode;
//链式队列的辅助节点现在发现需要俩个指针 需单独设计
typedef struct Link_Quene
{
LQNode* front;//保存第一个有效节点的地址
LQNode* rear;//保存最后一个有效节点的地址
}Link_Quene;
//1初始化
void Init_Link_Quene(Link_Quene*pls);
//2入队
bool Push(Link_Quene* pls, ELEMTYPE val);
//3出栈
bool Pop(Link_Quene* pls);
//4获取栈顶元素
ELEMTYPE Top(Link_Quene* pls);
//5判空
bool Empty(Link_Quene* pls);
//6打印
void Show(Link_Quene* pls);
//7销毁
void Destroy(Link_Quene* pls);
//8获取队列有效元素的个数
int Get_Size(Link_Quene* pls);
#include<assert.h>
#include "Seqlist.h"
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include "Link_Quene.h"
#include<stdio.h>
//1初始化
void Init_Link_Quene(Link_Quene* pls)
{
pls->front = NULL;
pls->rear = NULL;
//pls->front = NULL;
//pls->rear = NULL;
}
//2入队
bool Push(Link_Quene* pls, ELEMTYPE val)
{
assert(pls != NULL);
LQNode* pnewnode = (LQNode*)malloc(1 * sizeof(LQNode));
pnewnode->data = val;
pnewnode->next = NULL;
if (Empty(pls))
{
pls->front = pls->rear = pnewnode;
return true;
}
LQNode* p = pls->rear;
pnewnode->next = p;
p->next = pnewnode;
//更新队尾节点
pls->rear = pnewnode;
/*assert(pls != NULL);
LQNode* pnewnode=(LQNode*)malloc(1 * sizeof(LQNode));
pnewnode->data = val;
pnewnode->next = NULL;
if (Empty(pls))
{
pls->front = pls->rear = pnewnode;
return true;
}
LQNode* p = pls->rear;
pnewnode->next = p;
p->next = pnewnode;
pls->rear = pnewnode;*/
}
//3出栈
bool Pop(Link_Quene* pls)
{
assert(pls != NULL);
if (Empty(pls))
return false;
LQNode* q = pls->front;
if (q->next==NULL)
{
free(q);
q = NULL;
pls->front = pls->rear = NULL;
return true;
}
else {
pls->front = q->next;
free(q);
q = NULL;
}
return 1;
}
//4获取栈顶元素
ELEMTYPE Top(Link_Quene* pls)
{
assert(pls != NULL);
assert(pls->front != NULL);
if (Empty(pls))
return false;
return pls->front->data;
}
//5判空
bool Empty(Link_Quene* pls)
{
assert(pls != NULL);
return pls->front = NULL;
}
//6打印
void Show(Link_Quene* pls)
{
assert(pls != NULL);
LQNode* p = pls->front;
for(;p!= NULL; p=p->next)
printf("%d\n", p->data);
}
//7销毁
void Destroy(Link_Quene* pls)
{
while (!Empty)
{
Pop(pls);
}
//LQNode* p = pls->front;
//LQNode* q = NULL;
//while (p != pls->rear)
//{
// q = p->next;
// free(p);
// p = q;
//}
}
//8获取队列有效元素的个数
int Get_Size(Link_Quene* pls)
{
assert(pls != NULL);
int num = 0;
LQNode* p = pls->front;
for (; p->next != pls->rear; p = p->next)
num++;
return num;
}