数据结构（栈和队列）

//特殊的线性表栈和列队

//栈插入和删除受到一定限制的线性表

// 只能从一端插入删除特点先进后出

//栈的插入操作入栈\压栈

//栈的删除操作出栈\弹栈

//插入和删除的一端是栈顶另一端是栈底

#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->base $psq-\>top$ = val;

// 3. 栈顶指针先上移一位

psq->top++;

// 4. 入栈成功

return true;

/* assert(psq != NULL);

if (psq->top == psq->stacksize)

Increase(psq);

psq->base $psq-\>top$ = val;

psq->top++;

return true;*/

/* assert(psq != NULL);

if (psq->top == psq->stacksize)

Increase(psq);

psq->base $psq-\>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->base $psq-\>top-1$ ;

/* assert(psq != NULL);

if (psq->stacksize == NULL)

return false;

return psq->base $psq-\>top - 1$ ;*/

/* assert(psq != NULL);

if (psq->stacksize == NULL)

return false;

return psq->base $psq-\>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->base $i$ );

}

printf("\n");

/*assert(psq != NULL);

for (int i = 0; i < psq->stacksize; i++)

{

printf("%d", psq->base $i$ );

}

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;

}