栈与队列的应用（C语言）求解

#include "stdio.h"

薛城ssl适用于网站、小程序/APP、API接口等需要进行数据传输应用场景，ssl证书未来市场广阔！成为创新互联的ssl证书销售渠道，可以享受市场价格4-6折优惠！如果有意向欢迎电话联系或者加微信：18982081108（备注：SSL证书合作）期待与您的合作！

#include "malloc.h"

typedef struct node1{

int *data;

int top;

void init(void);

void del(void);

int pop(int);

void push(int);

}s;

void node1::init(){

data=(int*)malloc(sizeof(int)*100);

top=0;

}

void node1::del(){

free(data);

top=0;

}

int node1::pop(int e){

if(top==0)return 0;

e=data[--top];

return 1;

}

void node1::push(int e){

if(top==100)return;

data[top++]=e;

}

typedef struct node2{

int *data;

int top;

int bottom;

void init(void);

void del(void);

int pop(int);

void push(int);

void format(s);

}q;

void node2::init(){

data=(int*)malloc(sizeof(int)*100);

top=bottom=0;

}

void node2::del(){

free(data);

top=bottom=0;

}

int node2::pop(int e){

if(top==bottom)return 0;

e=data[top++];

return 1;

}

void node2::push(int e){

if(bottom==100)return;

data[bottom++]=e;

}

void node2::format(s e){

int a;

while(e.pop(a)){

push(a);

}

}

int main(){

s b;q c;

int a;

b.init();c.init();

printf("输入栈中的数,以0结尾\n");

while(1){

scanf("%d",a);

if(a==0)break;

b.push(a);

}

c.format(b);

while(c.pop(a)){

printf("%d\n",a);

}

b.del();

c.del();

return 0;

}//b为栈,c为队列,c.format(b)为转换函数

c语言堆栈和队列

栈（stack）又名堆栈，它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。

队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。

以上是从数据结构角度来看，从操作系统角度来看，所有的数据结构都是对虚拟内存的操作，堆是堆，栈是栈，栈指的是C语言函数所使用的自动有函数回收的虚拟内存空间，而堆则有操作系统堆管理器来管理的那部分虚拟内存，从C语言角度来看，使用malloc函数动态分配的内存，就是堆内存。

C语言 数据结构 队列和栈问题

给你看下栈的头文件

你自己添加判断是否是回文的方法吧

#ifndef STACK_H

#define STACK_H

#include iostream

using std::ostream;

//template class Type

//class Stack;

//template class Type

//ostream operator (ostream , const StackType );

template class Type

class Stack {

friend ostream operator (ostream , const StackType );

public:

static const int DefaultSize;

Stack(int = DefaultSize); //创建一个最大容量为MaxStackSize的空栈

Stack(Type[], int, int = DefaultSize); //用数组初始化栈

~Stack(){ delete [] stack; }

bool IsFull(); //若元素个数等于栈的最大容量则返回TRUE,否则返回FALSE

void Add(const Type ); //若IsFull()为TRUE,则调用StackFull,否则将item插入栈顶

bool IsEmpty(); //若栈中元素个数等于0则返回TRUE,否则返回FALSE

Type * Delete(Type); //若IsEmpty()为TRUE，则调用StackEmpty并返回0，

//否则删除栈顶元素并返回其指针

void StackFull(); //将栈的最大容量扩大一倍

void StackEmpty(); //输出警告：栈已空， 不能弹出变量

void Empty(); //将栈清空

int GetSize(); //获得栈内元素数目

private:

Type * stack;

int MaxSize;

int top;

};

template class Type

const int StackType::DefaultSize = 10;

template class Type

StackType::Stack(int pMaxSize) {

MaxSize = pMaxSize;

stack = new Type[MaxSize];

top = -1;

}

template class Type

StackType::Stack(Type pArray[], int pLen, int pMaxSize) {

stack = new Type[pMaxSize];

for ( int i = 0; i pLen; i++ )

{

stack[i] = pArray[i];

}

top = pLen - 1;

MaxSize = pMaxSize;

}

template class Type

inline bool StackType::IsFull() {

if (top == MaxSize - 1) return true;

else return false;

}

template class Type

inline bool StackType::IsEmpty() {

if (top == -1) return true;

else return false;

}

template class Type

void StackType::Add(const Type pX) {

if (IsFull())

{

StackFull();

stack[++top] = pX;

}

else stack[++top] = pX;

}

template class Type

Type * StackType::Delete(Type pX) {

if (IsEmpty())

{

StackEmpty();

return 0;

}

pX = stack[top--];

return pX;

}

template class Type

void StackType::StackEmpty() {

cout "栈已空，不能进行弹出操作！" endl;

}

template class Type

void StackType::StackFull() {

Type * nStack = new Type[MaxSize * 2];

for ( int i = 0; i = top; i++ )

{

nStack[i] = stack[i];

}

MaxSize = MaxSize * 2;

delete [] stack;

stack = nStack;

cout "栈已满，栈的自动容量自动扩充为原来的两倍 (" MaxSize ")" endl;

}

template class Type

ostream operator (ostream pOutput, const StackType pS) {

if (pS.top == -1)

{

pOutput "空栈" endl;

return pOutput;

}

for ( int i = 0; i = pS.top; i++ )

{

pOutput pS.stack[i] " ";

}

return pOutput;

}

template class Type

void StackType::Empty() {

top = -1;

}

template class Type

int StackType::GetSize() {

return top + 1;

}

#endif

计算机c语言中 什么是栈和队列

栈(Stack)是仅限制在表的一端进行插入和删除运算的线性表，称插入、删除这一端为栈顶，另一端称为栈底。表中无元素时为空栈。栈 的修改是按后进先出的原则进行的，我们又称栈为LIFO表(Last In First Out)。通常栈有顺序栈和链栈两种存储结构。 栈的基本运算有六种： ·构造空栈：InitStack(S) ·判栈空: StackEmpty(S) ·判栈满： StackFull(S) ·进栈： Push(S,x) ·退栈： Pop(S) ·取栈顶元素：StackTop(S) 在顺序栈中有"上溢"和"下溢"的现象。 ·"上溢"是栈顶指针指出栈的外面是出错状态。 ·"下溢"可以表示栈为空栈,因此用来作为控制转移的条件。 顺序栈中的基本操作有六种：·构造空栈·判栈空·判栈满·进栈·退栈·取栈顶元素 链栈则没有上溢的限制，因此进栈不要判栈满。链栈不需要在头部附加头结点，只要有链表的头指针就可以了。 链栈中的基本操作有五种：·构造空栈·判栈空·进栈·退栈·取栈顶元素 队列(Queue)是一种运算受限的线性表，插入在表的一端进行，而删除在表的另一端进行，允许删除的一端称为队头(front)，允许插入的 一端称为队尾(rear) ,队列的操作原则是先进先出的，又称作FIFO表(First In First Out) 。队列也有顺序存储和链式存储两种存储结 构。 队列的基本运算有六种： ·置空队：InitQueue(Q) ·判队空：QueueEmpty(Q) ·判队满：QueueFull(Q) ·入队：EnQueue(Q,x) ·出队：DeQueue(Q) ·取队头元素：QueueFront(Q) 顺序队列的"假上溢"现象：由于头尾指针不断前移，超出向量空间。这时整个向量空间及队列是空的却产生了"上溢"现象。 为了克服"假上溢"现象引入循环向量的概念，是把向量空间形成一个头尾相接的环形，这时队列称循环队列。 判定循环队列是空还是满，方法有三种： ·一种是另设一个布尔变量来判断； ·第二种是少用一个元素空间，入队时先测试（(rear+1)%m = front）? 满：空； ·第三种就是用一个计数器记录队列中的元素的总数。 队列的链式存储结构称为链队列，一个链队列就是一个操作受限的单链表。为了便于在表尾进行插入(入队)的操作，在表尾增加一个尾指 针，一个链队列就由一个头指针和一个尾指针唯一地确定。链队列不存在队满和上溢的问题。在链队列的出队算法中，要注意当原队中只 有一个结点时，出队后要同进修改头尾指针并使队列变空。

c语言实现队列和栈的方法

#define OVERFLOW -1

#define OK 1

#define ERROR 0

#define STACK_INIT_SIZE 100

#define STACKINCREMENT 10

#define N 20

typedef char SElemType;

typedef int Status;typedef struct {

SElemType *base;

SElemType *top;

int stacksize;

}SqStack;#includestdio.h

#includestdlib.hStatus CreatStack(SqStack S){

//创建栈

S.base=(SElemType*)malloc(STACK_INIT_SIZE*sizeof(SElemType));

if(!S.base)exit(OVERFLOW);

S.top=S.base;

S.stacksize=STACK_INIT_SIZE;

return OK;

}//CreatStackStatus Push(SqStack S,SElemType e){

//插入e为新的栈顶元素

if(S.top-S.base=S.stacksize){//栈满，追加存储空间

S.base=(SElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(SElemType));

if(!S.base)exit (OVERFLOW);//存储空间分配失败

S.top=S.base+S.stacksize;

S.stacksize+=STACKINCREMENT;

}

*S.top++=e;

return OK;

}//PushStatus Pop(SqStack S ,SElemType e){

//若栈不空，删除栈顶元素，并用e返回其值

if(S.top==S.base) return ERROR;

e=*--S.top;

return OK;

}//Pop typedef char QElemType;

typedef struct QNode{

QElemType data;

struct QNode *next;

}QNode,*QNodePtr;typedef struct{

QNodePtr front;

QNodePtr rear;

}LinkQueue;Status CreatQueue(LinkQueue Q){

//建立一个空的链式栈

Q.front=Q.rear=(QNodePtr)malloc(sizeof(QNode));

if(!Q.front)exit(OVERFLOW);

Q.front-next=NULL;

return OK;

}Status EnQueue(LinkQueue Q,QElemType e){ QNodePtr p;

p=(QNodePtr)malloc(sizeof(QNode));

if(!p)exit(OVERFLOW);

p-data=e;p-next=NULL;

Q.rear-next=p;

Q.rear=p;

return OK;

}Status DeQueue(LinkQueue Q,QElemType e){QNodePtr p;brif(Q.front==Q.rear) return ERROR;brp=Q.front-next; e=p-data;brQ.front-next=p-next;brif(Q.rear==p) Q.rear=Q.front;brfree(p);brreturn OK;br}int stackPalindrom_Test()//判别输入的字符串是否回文序列,是则返回1,否则返回0

{

printf("栈练习，请输入要判断的字符串以#作为结束符，不要超过二十个字符\n");

SqStack S;

CreatStack(S);

char c;

SElemType a;

SElemType b[N];

int count = 0;

fgets( b, N, stdin );

while((b[count])!='#')

{

Push(S,b[count]); //进栈

count++;

}

int i = 0;

while(i count)

{

Pop(S,a);

if(a!=b[i])

return ERROR;

i++;

}

return OK;}//stackPalindrom_Test int queuePalindrom_Test()//判别输入的字符串是否回文序列,是则返回1,否则返回0

{

printf("队列练习，请输入要判断的字符串以#作为结束符，不要超过二十个字符\n");

LinkQueue Q;

CreatQueue(Q); char c;

SElemType a;

SElemType b[N];

int count = 0;

fgets( b, N, stdin );

while((b[count])!='#')

{

EnQueue(Q,b[count]);; //入列

count++;

} while(count-- 0)

{

DeQueue(Q,a);

if(a!=b[count])

return ERROR;

}

return OK;

}//queuePalindrom_Test Status main(){ if(stackPalindrom_Test()==1)

printf("是回文\n");

else printf("不是回文\n"); if(queuePalindrom_Test()==1)

printf("是回文\n");

else printf("不是回文\n");

return OK;

}