栈实现队列c语言源码（用栈实现队列c语言）
本文目录一览：
- 1、栈与队列的应用（C语言）求解
- 2、C语言写 栈队列(先进先出的)
- 3、C数据结构中如何用两个栈实现一个队列
- 4、栈的应用，队列的应用（用C语言编写程序）
- 5、《线性表的插入和删除算法实现》以及《栈和队列的插入和删除算法实现》的c语言代码
- 6、c语言实现队列和栈的方法
栈与队列的应用（C语言）求解
#include "stdio.h"
#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语言写 栈队列(先进先出的)
#includestdio.h
#includemalloc.htypedef
struct
node
/*定义新类型结构体结点*/
{
int
data;/*数据成员可以是多个不同类型的数据*/
struct
node
*next;/*指针变量成员只能是一个*/
}NODE;/*节点结束*/typedef
struct
qnode
/*定义结点类型的变量名*/
{
NODE
*front;/*设定结点头指针变量*/
NODE
*rear;/*
设定结点尾指针变量*/
}QNODE;
/*
链队列的结点定义
*/
void
InitQueue(QNODE
*Q)/*定义指针Q*/
{
NODE
*p;/*定义指针p*/
p=(NODE
*)malloc(sizeof(NODE));/*分配结点字节的容量*/
Q-front=p;
/*指定头指针p*/
Q-front-next=NULL;/*建立空队列*/
Q-rear=Q-front;/*改变Q的值*/
printf("The
init
is
complete!");}
void
*QueuePush(QNODE
*Q)
{
NODE
*p;
p=(NODE
*)malloc(sizeof(NODE));/*分配结点字节的容量*/
printf("Please
input
a
number
:");/*请输入一个数*/
scanf("%d",p-data);/*给第一个结点赋值*/
p-next=NULL;/*指定尾结点*/
Q-rear-next=p;/*指定尾新结点p的地址*/
Q-rear=p;/*指定队尾结束*/
printf("The
%d
has
been
pushed
into
the
Queue!",p-data);/*显示数据成员*/
return
0;/*程序结束*/
}
void
*QueuePop(QNODE
*Q)
{
NODE
*p;/*定义结点指针*/
if(Q-front-next==NULL)
return
0;/*判断对前是否为空，如果是就结束*/
p=Q-front-next;/*指向下以个成员*/
Q-front-next=p-next;/*依次向下循环*/
if(Q-rear==p)
Q-rear=Q-front;/*队尾与对头相同*/
printf("The
%d
has
been
pop
from
the
queue!
\n",p-data);/*显示队列成员*/
free(p);
return
0;
}
void
*PrintQueue(QNODE
*Q)
{
NODE
*p;/*定义链结点*/
p=Q-front-next;/*指定对头*/
while(p!=NULL)/*如不为空*/
{
printf("%5d",p-data);/*显示数据成员*/
p=p-next;/*指定第二个成员*/
}
return
0;
}
void
main()
{
QNODE
*T;
int
i=0;/*取值*/
printf("1.InitQueue
2.QueuePush
3.QueuePop
4.PrintQueue
5.Quit
\n");
while(i!=5)
{
printf("Please
choose
the
gongneng:");
scanf("%d",i);
printf("\n");
switch(i)
{
case
1:
InitQueue(T);
printf("\n");
break;
case
2:
QueuePush(T);
printf("\n");
break;
case
3:
QueuePop(T);
printf("\n");
break;
case
4:
printf("The
queue's
numbers
are:");
PrintQueue(T);
printf("\n");
break;
case
5:
printf("\n");
break;}
}
}
C数据结构中如何用两个栈实现一个队列
照着这个思路做：
假设两个栈 A 和B，且都为空。
可以认为栈 A 为提供入队列的功能，栈 B 提供出队列的功能。
入队列： 入栈 A
出队列：
1 如果栈B 不为空，直接弹出栈 B 的数据。
2 如果栈 B 为空，则依次弹出栈 A 的数据，放入栈 B 中，再弹出栈 B 的数据。
StatckOne.java
import java.util.ArrayList;
public class StatckOne {
private static ArrayList al;
public StatckOne() {
if (al == null)
al = new ArrayList();
}
public void put(Object o) {
al.add(o);
}
public Object top() {
int size = al.size();
if (al != null) {
if (size != 0) {
System.out.println("StatckOne");
return al.get(size - 1);
} else
System.out.println("栈中没有对象");
} else
System.out.println("没有初始化");
System.out.println("StatckOne");
return null;
}
}
StatckTwo.java
import java.util.ArrayList;
public class StatckTwo {
private static ArrayList al;
public StatckTwo() {
al = new ArrayList();
}
public void put(Object o) {
if (al != null)
al.add(o);
else
System.out.println("没有初始化");
}
public Object top() {
int size = al.size();
if (al != null) {
if (size != 0) {
System.out.println("StatckTwo");
return al.get(size - 1);
} else {
StatckOne so = new StatckOne();
return so.top();
}
} else
System.out.println("没有初始化");
return null;
}
}
栈的应用，队列的应用（用C语言编写程序）
//第一个问题
#include stdio.h
#includestdlib.h
struct stack{
char a;
struct stack *last;
}*top,*head,*p;
void SetStack(){
top=(stack*)malloc(sizeof(stack));
top-last=NULL;
head=NULL;
}
bool StackIsNull(){
return head==NULL;
}
void push(char x){
if(StackIsNull()){
top-a=x;
head=top;
return;
}
p=(stack*)malloc(sizeof(stack));
p-a=x;
p-last=head;
head=p;
}
char pop(){
char x=head-a;
p=head;
head=head-last;
free(p);
return x;
}
void main(){
SetStack();
char c;
while((c=getchar())!='\n'c!=' ') push(c);
while(!StackIsNull()) printf("%c",pop());
printf("\n");
}
//第二个
#includestdio.h
#includestdlib.h
struct queue{
int a;
struct queue *next;
}*top,*head,*p;
void SetQueue(){
top=NULL;
}
bool QueueIsNull(){
return top==NULL;
}
void In(int x){
if(QueueIsNull()){
top=(queue*)malloc(sizeof(queue));
top-a=x;
top-next=NULL;
head=top;
return;
}
p=(queue*)malloc(sizeof(queue));
p-a=x;
p-next=NULL;
head-next=p;
head=p;
}
int Out(){
p=top;
top=top-next;
int x=p-a;
free(p);
return x;
}
void main(){
SetQueue();
printf("输入要打印栈实现队列c语言源码的行数\n");
int n;
scanf("%d",n);
if(n=0) return;
In(1);
In(1);
for(int j=0;jn-1;j++) printf(" ");
printf("1 1\n");
for(int i=1;in;i++){
for(j=0;jn-i-1;j++) printf(" ");
int temp=0;
int now=Out();
do{
printf("%d ",temp+now);
In(temp+now);
temp=now;
}while((now=Out())!=1);
printf("%d ",temp+now);
In(temp+now);
In(1);
printf("1 \n");
}
}
《线性表的插入和删除算法实现》以及《栈和队列的插入和删除算法实现》的c语言代码
链表
#include"stdio.h"
#include"malloc.h"
typedef struct node
{
int data;
struct node *next;
}node,*linklist;
int initlist(linklist l)
{
linklist q,p;
int i,n;
q=l;
printf("请输入链表长度:");
scanf("%d",n);
for(i=0;in;i++)
{
p=(linklist )malloc(sizeof(node));
printf("请输入链表数字:");
scanf("%d",p-data);
q-next=p;
q=p;
}
q-next=NULL;
return 1;
}
int printflink(linklist l)
{
linklist p;
p=l-next;
while(p!=NULL)
{
printf("%d\n",p-data);
p=p-next;
}
return 1;
}
int insertlink(linklist l)
{
linklist p,s;
int j=0,i,n;
p=l;
printf("请输入你要插入的位置:");
scanf("%d",i);
printf("请输入插入的数字:");
scanf("%d",n);
while(p-next!=NULLji-1)
{
p=p-next;
j++;
}
if(!(p-next)||ji-1)
{
printf("error\n");
return 1;
}
s=(linklist)malloc(sizeof(node));
s-data=n;
s-next=p-next;
p-next=s;
return 1;
}
int deletelink(linklist l)
{
linklist p,q;
int j=0,e,i;
p=l;
printf("请输入你要删除的位置:");
scanf("%d",i);
while(p-next!=NULLji-1)
{
p=p-next;
j++;
}
if(!(p-next)||ji-1)
{
printf("error\n");
return 1;
}
q=p-next;
p-next=q-next;
free(q);
return 1;
}
int main()
{
linklist l;
l=(linklist)malloc(sizeof(node));
l-next=NULL;
initlist(l);
printflink(l);
insertlink(l);
printflink(l);
deletelink(l);
printflink(l);
return 1;
}
栈
#include"iostream.h"
#include"stdio.h"
#include"malloc.h"
typedef int elementype;
#define MAXSTACK 100
typedef struct stack
{
elementype *base;
elementype *top;
int stacksize;
}stack;
//建栈
int initstack(stack *p)
{
p-base=(elementype *)malloc(MAXSTACK*sizeof(elementype));
if(!p-base)
{
cout"建立栈失败!"endl;
return 1;
}
p-top=p-base;
return 1;
}
//元素进栈
int pushstack(stack *p)
{
elementype e;
if(p-top-p-base=p-stacksize)
{
cout"栈已满!"endl;
return 1;
}
cout"请输入进栈元素:";
cine;
*p-top=e;
p-top++;
return 1;
}
//删除栈顶元素
int deletetop(stack *p)
{
if(p-top==p-base)
{
cout"栈为空"endl;
return 1;
}
p-top--;
return 1;
}
//显示栈中元素
int displaystack(stack *p)
{
int i=0;
elementype *s;
if(p-top==p-base)
{
cout"栈为空!"endl;
return 1;
}
s=p-base;
for(i=0;ip-top-p-base;i++)
{
cout*s" ";
s++;
}
coutendl;
return 1;
}
int main()
{
stack *p;
int a;
initstack(p);
displaystack(p);
pushstack(p);
displaystack(p);
deletetop(p);
displaystack(p);
}
队列
#include"stdio.h"
#include"malloc.h"
typedef struct lnode
{
int data;
struct lnode *next;
}lnode;
typedef struct linkque
{
lnode *front;
lnode *rear;
}linkque;
int queinit(linkque *q)
{
int e;
lnode *p;
q-front=(lnode *)malloc(sizeof(lnode));
q-rear=q-front;
q-front-next=NULL;
while(1)
{
printf("请输入队列数字(输入0结束):");
scanf("%d",e);
if(e==0) break;
p=(lnode *)malloc(sizeof(lnode));
p-data=e;
p-next=NULL;
q-rear-next=p;
q-rear=p;
}
return 1;
}
int quein(linkque *q)
{
lnode *p;
int e;
printf("请输入你要插入队列的数字:");
scanf("%d",e);
p=(lnode *)malloc(sizeof(lnode));
p-data=e;
p-next=NULL;
q-rear-next=p;
q-rear=p;
return 1;
}
int quedel(linkque *q)
{
lnode *p;
int e;
p=q-front-next;
e=p-data;
q-front-next=p-next;
free(p);
return e;
}
int printfque(linkque *q)
{
lnode *p;
p=q-front-next;
while(p)
{
printf("%d\t",p-data);
p=p-next;
}
printf("\n");
}
int main()
{
linkque q;
queinit(q);
printfque(q);
quein(q);
printfque(q);
quedel(q);
printf("队列出列后为:\n");
printfque(q);
return 1;
}
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;
}
