数据结构 栈和队列的一些应用

#include <stdio.h>

#include <stdlib.h>

#include <math.h>

#include "conio.h"

#define MAX 50

typedef struct Node

{
int data;
struct Node * next;

}linkqueuenode;

typedef struct 

{
linkqueuenode *front;
linkqueuenode *rear;

}linkqueue;

typedef struct 

{
int a[MAX];
int front;
int rear;

}setqueue;

typedef struct DNode

{
int data;
struct DNode *prior,*next;

}DLNode,*Doublelist;

typedef struct Polynode

{
int coef;
int exp;
Polynode *next;

}Polynode, * Polylist;

typedef struct node

{
char ch;
struct node *next;

}LinkStackNode;

typedef LinkStackNode *LinkStack;

void delay(int n) 

{ 

int i,j; 

for(j=0;j<n*1000;j++) 

for(i=0;i<125;i++){;}

}

int intlinkqueue(linkqueue *Q)

{
Q->front=(linkqueuenode *)malloc(sizeof(linkqueuenode));
if(Q->front!=NULL)
{
Q->rear=Q->front;
Q->front->next=NULL;
return true;
}
else
return false;

}

int enterlinkqueue(linkqueue *Q,int x)

{

   linkqueuenode *p;

   p=(linkqueuenode *)malloc(sizeof(linkqueuenode));

   if(p!=NULL)

   {
  p->data=x;
  //p=Q->rear->next;
  p->next=NULL;
  Q->rear->next=p; // ??? Q->rear->NEXT 指向p
  Q->rear=p;

   }

   return true;

}

int deletelinkqueue(linkqueue *Q,int * x)

{

   linkqueuenode *p;

   p=(linkqueuenode *)malloc(sizeof(linkqueuenode));

   if(p!=NULL)

   {
 *x=Q->front->next->data;  //注意Q->front->next->data 才是队列的第一个值；
  p=Q->front->next;
  Q->front->next=p->next;
  if(Q->rear==p)
  Q->front=Q->rear;
  //  *x=p->data;
  free(p);
  return true;

   }

}

int getlinkhead(linkqueue *Q,int * x)

{

   *x=Q->front->next->data;

   return true;

}

void intqueue(setqueue *Q)

{
Q->front=Q->rear=0;

}

int queueisempty(setqueue *Q)

{
if(Q->front==Q->rear)
return false;
else
return true;

}

int enterqueue(setqueue *Q,int x)

{
if((Q->rear+1)%MAX==Q->front)
return false;
Q->a[Q->rear]=x;
Q->rear=(Q->rear+1)%MAX;
return true;

}

int gethead(setqueue *Q,int * x)

{
*x=Q->a[Q->front];
return true;

}

int deletequeue(setqueue *Q,int * x)

{
if(Q->front==Q->rear)
return false;
*x=Q->a[Q->front];

     Q->front=(Q->front+1)%MAX;
return true;

}

void yanghui()

{
setqueue Q;
intqueue(&Q);
int temp,x;
enterqueue(&Q,1);
for(int n=2;n<=5;n++)
{
enterqueue(&Q,1);
for(int i=1;i<=n-2;i++)
{
deletequeue(&Q,&temp);
printf("%d ",temp);
gethead(&Q,&x);
temp+=x;
enterqueue(&Q,temp);
}
deletequeue(&Q,&x);
printf("%d\n",x);
enterqueue(&Q,1);
}

};

void linkyunsuan()

{
linkqueue Q;

int temp,x,a;
a=intlinkqueue(&Q);

// printf("%d\n",a);
enterlinkqueue(&Q,1);
for(int n=2;n<=5;n++)
{

       enterlinkqueue(&Q,1);
  for(int i=1;i<=n-2;i++)
  {
  deletelinkqueue(&Q,&temp);
  printf("%d ",temp);
  getlinkhead(&Q,&x);
  temp+=x;
  enterlinkqueue(&Q,temp);
  }
  deletelinkqueue(&Q,&x);
  printf("%d\n",x);
  enterlinkqueue(&Q,1);

}

}

void IntStack(LinkStack top)

{
top=(LinkStackNode *)malloc(sizeof(LinkStackNode));
top->next=NULL;

}

int push(LinkStack top,char c)

{
LinkStackNode *temp;

   temp=(LinkStackNode
4000
*)malloc(sizeof(LinkStackNode));

   temp->ch=c;

   temp->next=top->next;

   top->next=temp;

  //free(temp); 不能用free 应为temp还在链栈之中，free之后top->next就找不到下个目标了
return true;

}

int pop(LinkStack top,char *ch)

{

   LinkStackNode *temp;

    temp=(LinkStackNode *)malloc(sizeof(LinkStackNode));
temp=top->next;
top->next=temp->next;
*ch=temp->ch;
free(temp);
return true;

}

int getpop(LinkStack top)

{

   LinkStackNode *temp;

   char ch;

    temp=(LinkStackNode *)malloc(sizeof(LinkStackNode));
temp=top->next;

// top->next=temp->next;
ch=temp->ch;
//free(temp);
return ch;

}

int Isempty(LinkStack top)

{
if(top->next)
return true;
else
return false;

}

int Match(char *str)

{

//LinkStack top;
LinkStackNode top;//可以用上面那个,上面那个是地址，需要下面那句给指针初始化，下面的是链栈，不需要初始化

int i;

char ch,c;

  //top=(LinkStackNode *)malloc(sizeof(LinkStackNode));

for(i=0;str[i]!='\0';i++)

{

  switch(str[i])

  {

  case '[':

  case '{':push(&top,str[i]);//如果用地址方式就是上面注释的方法，需要将&top改成top，要不是会报错
      break;

  case ']':

  case '}':ch=getpop(&top);
// printf("%c\n",c);
 if((ch+2)==str[i])//asii码+2；
  pop(&top,&c);
 else 
 return false;
 break;

  }

  

}

return true;

}

int yunsuan()

{
LinkStackNode OVS,OPTR;
char ch,c,o,a,b;
char v;
push(&OPTR,'=');

       ch=getchar();
  while(ch!='='||getpop(&OPTR)!='=')
  {

          if(ch!='*'&&ch!='/'&&ch!='+'&&ch!='-'&&ch!='=')//需要让ch不等于#
 {
 push(&OVS,ch-48);//可能需要转换成int格式
 ch=getchar();
 }
 else
 {  if(getpop(&OPTR)=='=')
  c='<';
else if((getpop(&OPTR)=='+'||getpop(&OPTR)=='-')&&(ch=='*'||ch=='/'))
 c='<';
 
 else
 c='>';
 switch(c)
 {case '<':push(&OPTR,ch);
          ch=getchar();
  break;
 case '>':pop(&OPTR,&o);

     pop(&OVS,&a);
 pop(&OVS,&b);
 if(o=='+')
 v=a+b;
 else if(o=='-')
 v=a-b;
 else if(o=='*')
 v=a*b;
 else 
 v=a/b;
 push(&OVS,v);
 break;

      

              }
 }
  }
  v=getpop(&OVS);
  return v;
 

}

int huiwen(char *str)

{
LinkStackNode top;
char ch,ch1;
int i=0;
int j;
while(str[i]!='&')
{
push(&top,str[i]);
i++;
}

//  printf("%d\n",sizeof(&top));

 // sizeof(&top)--;

  j=sizeof(&top)-1;
while(j--)
{  pop(&top,&ch);
i++;
if(ch!=str[i])
return false;

}
return true;

}

Polynode *create()

{
Polynode *p,*h,*m;
int c,e;
h=(Polynode *)malloc(sizeof(Polynode));
p=h;
scanf("%d,%d",&c,&e);

while(c)
{

      m=(Polynode *)malloc(sizeof(Polynode));
 m->coef=c;
 m->exp=e;
 p->next=m;
 p=m;
 scanf("%d,%d",&c,&e);
}
p->next=NULL;
return h;

}

void zhanshi(Polynode *h)

{

   Polynode *p;

   p=h;

   p=p->next;

   while(p)

   {
  printf("%dX%d+",p->coef,p->exp);
  p=p->next;

   }

}

Polynode *hebing(Polynode *a,Polynode *b)

{
Polynode *p,*q,*h,*m;
int sum;
m=(Polynode *)malloc(sizeof(Polynode));
p=a;
p=p->next;
q=b;
q=q->next;
m=a;

    while(p!=NULL&&q!=NULL)
{
if(p->exp<q->exp)
{   
m->next=p;
m=p;
p=p->next;
}
else if(p->exp==q->exp)
{
sum=p->coef+q->coef;
p->coef=sum;
m->next=p;
m=p;
p=p->next;
q=q->next;
}
else
{
m->next=q;
m=q;
q=q->next;
}
if(p!=NULL)
m->next=p;
else

            m->next=q;
}

   return a;

}

DLNode *chuangjian(int i,int len)

{

  DLNode *n,*h,*p;

  h=(DLNode *)malloc(sizeof(DLNode));

  h->prior=h;

  h->next=h;

  p=h;

  while(len--)

  {
 n=(DLNode *)malloc(sizeof(DLNode));
 n->data=i;
 p->next=n;
 n->prior=p;

 p=n;
 i++;

  }

   n->next=h;
 h->prior=n;

  return(h);

};

void xianshi(DLNode *h)

{
DLNode *p;
p=h;

    p=p->next;
while(p!=h)
{
printf("%d",p->data);
p=p->next;
// p->next=p;  等号左边会执行，我们希望的就是让他一个一个排下去，所以左边是p->next。
}

};

DLNode * charu(DLNode *h,int i,int a)

{
DLNode *s,*p,*l,*m;
s=h;
m=h;
p=(DLNode *)malloc(sizeof(DLNode));
l=(DLNode *)malloc(sizeof(DLNode));
while(i--)
s=s->next;

p->data=a;

    p->next=s->next->next;
p->prior=s->prior;

    p->prior->next=s;
s->next=p;
p->prior=s;

    return h;

}

DLNode *shanchu(DLNode *h,int i,int a)

{
DLNode *s,*p;
s=h;
p=(DLNode *)malloc(sizeof(DLNode));
while(i--)
{
s=s->next;
}
//p->prior=s->prior;
s->next=s->next->next;

    

return h;

}

void main()

{
DLNode *p,*h,*m;
Polynode *n,*l,*o;
LinkStackNode top;
char s[5]="{[]}";
char b[10]="12+3&3+21";
char ch1,ch2;
int i,v,f,a;
setqueue Q;
p=(DLNode *)malloc(sizeof(DLNode));
p=chuangjian(1,10);
xianshi(p);
printf("\n");
h=charu(p,6,11);
xianshi(h);
printf("\n");
m=shanchu(h,5,10);
xianshi(m);
printf("\n");//以上为循环链表的操作

// n=create();

// zhanshi(n);

 //   printf("\n");

// l=create();

// zhanshi(n);

 //   printf("\n");

// o=hebing(l,n);

// zhanshi(o);//以上为单链表表示多项式

 // i=Match(s);

 // printf("%d\n",i);//以上为用链栈处理括号匹配问题

//  v=yunsuan();

// printf("%d\n",v); //以上为链栈处理一元表达式
yanghui();// 杨辉三角 循环队列
linkyunsuan();// 杨辉三角   链队列

    intqueue(&Q);
for(;;)
{
for(;;)
{
printf("A ");
delay(40);
if(_kbhit())
{
ch1=getch();
if(ch1==';'||ch1==',') break;
f=enterqueue(&Q,int(ch1));

}
}

while(queueisempty(&Q))
{  int(ch2);
deletequeue(&Q,&ch2);
putchar(ch2);

}
delay(80);
if(ch1==';') break;

}//以上，队列键盘输入循环缓存;
a=huiwen(b);
printf("%d",a);//以上 链栈测试回文数

}