栈和队列的有关操作

直接上代码：

#include <stdio.h>
#include <stdlib.h>
#define  Stack_Init_Size  100
#define  Max_Size  100
struct node {
   int res;
   struct node *next;
};

struct node *Init_List_Stack(){    //对链栈的初始化，进栈，出栈操作
    struct node *head;
    head=(struct node *)malloc(sizeof(struct node));
    if(!head)
    return NULL;
    head->next=NULL;
    return head;
}

void Push_List_Stack(int x,struct node *head){
   struct node *p,*q;
   p=(struct node *)malloc(sizeof(struct node));
   p->res=x;
   q=head;
   while(q->next){
    q=q->next;
   }
  q->next=p;
  p->next=NULL;
}

void Pop_List_Stack(struct node *head){
   struct node *q,*tmp;
   q=head;
   while(q->next->next){
    q=q->next;
   }
  tmp=q->next;
  q->next=tmp->next;
  free(tmp);
}

void Read_List_Stack(struct node *head){
    while(head->next){
     printf("%d ",head->next->res);
     head=head->next;
    }
    printf("\n");
}
struct Sq_Stack{
    int *base;
    int *top;
    int stacksize;
};

void Init_Sq_Stack(struct Sq_Stack &s){   //对顺序栈的初始化，进栈，出栈操作
  s.base=(int *)malloc(Stack_Init_Size*sizeof(int));
  if(!s.base)
  printf("内存开辟失败\n");
  s.top=s.base;
  s.stacksize=Stack_Init_Size;
}

void Push_Sq_Stack(struct Sq_Stack &s,int x){
    if(s.top-s.base>=Stack_Init_Size)
    printf("栈已满\n");
    else{
    *(s.top)=x;
    s.top++;
    }
}

void Pop_Sq_Stack(struct Sq_Stack &s){
   if(s.top==s.base)
    printf("栈已空\n");
    else
    s.top--;
}

void Read_Sq_Stack(struct Sq_Stack s){
   while(s.top!=s.base){
     printf("%d ",*(s.base++));
   }
   printf("\n");
}

struct  Qnode{
  int res;
  struct Qnode *next;
};

struct  Link_Queue{
   struct Qnode *front;
   struct Qnode *rear;
};

void Init_Link_Queue(struct Link_Queue &s){    //对链队列的初始化，进队，出队操作
    s.front=(struct Qnode*)malloc(sizeof(struct Qnode));
    if(!s.front)
    printf("开辟内存失败\n");
    s.rear=s.front;
    s.front->next=NULL;
}

void Enter_Queue(struct Link_Queue &s,int x){
    struct Qnode *p;
    p=(struct Qnode*)malloc(sizeof(struct Qnode));
    p->res=x;
    p->next=NULL;
    s.rear->next=p;
    s.rear=p;
}

void Delete_Queue(struct Link_Queue &s){
    struct Qnode *p;
    if(s.front==s.rear)
    printf("队列已空\n");
    p=s.front->next;
    s.front->next=p->next;
    if(p==s.rear)
    s.rear=s.front;
    free(p);
}

void Read_Queue(struct Link_Queue s){
     while(s.front->next){
     printf("%d ",s.front->next->res);
     s.front=s.front->next;
     }
     printf("\n");
}

struct Circle_Queue{
    int *base;
    int front;
    int rear;
};

void Init_Circle_Queue(struct Circle_Queue &s){    //对循环队列的初始化，进队，出队操作
    s.base=(int *)malloc(Max_Size*sizeof(int));
    if(!s.base)
    printf("内存开辟失败\n");
    s.front=s.rear=0;
}

void Enter_Circle_Queue(struct Circle_Queue &s,int x){
    if((s.rear+1)%Max_Size==s.front)
     printf("循环队列已满\n");
    s.base[s.rear]=x;
    s.rear=(s.rear+1)%Max_Size;
}

void Delete_Circle_Queue(struct Circle_Queue &s){
    if(s.front==s.rear)
     printf("循环队列已空\n");
     s.front=(s.front+1)%Max_Size;
}

void Read_Circle_Queue(struct Circle_Queue s){
    int i;
    for(i=s.front;i<s.rear;i++)
        printf("%d ",s.base[i]);
    printf("\n");
}

void  Conversion(int data,int num){   //利用栈来实现进制转换
    struct Sq_Stack s;
    int res;
    Init_Sq_Stack(s);
    while(data){
     Push_Sq_Stack(s,data%num);
     data=data/num;
    }
    while(s.base!=s.top){
      res=*(--s.top);
     if(res>=10)
       printf("%c",(char)(65+res-10));
     else
       printf("%d",res);
    }
    printf("\n");
}

void Print_YHSJ(int n){           //利用队列来打印杨辉三角
    struct Circle_Queue t;
    int i,j;
    int q1,q2;
    Init_Circle_Queue(t);
    Enter_Circle_Queue(t,0);
    Enter_Circle_Queue(t,1);
    for(i=1;i<=n;i++)
    {
     for(j=1;j<=n-i;j++)
        printf(" ");
     Enter_Circle_Queue(t,0);
     do
     {
     q1=t.base[t.front];
     Delete_Circle_Queue(t);
     q2=t.base[t.front];
     Enter_Circle_Queue(t,q1+q2);
     if(q2)
     printf("%d ",q2);
     }
     while(q2);
     printf("\n");
    }
}
int main()
{
    struct node *head;
    struct Sq_Stack  s;
    struct Link_Queue r;
    struct Circle_Queue t;
    int data,num;
    int n,x,i;
    printf("链栈的基本操作     \n");


    printf("请输入要入栈节点的个数\n");
    head=Init_List_Stack();
    scanf("%d",&n);
    printf("请输入节点中的数据\n");
    for(i=1;i<=n;i++){
     scanf("%d",&x);
     Push_List_Stack(x,head);
    }
    printf("完整的栈中数据\n");
    Read_List_Stack(head);
    printf("将栈中栈顶元素依次出栈\n");
    for(i=1;i<=n;i++){
    Pop_List_Stack(head);
    Read_List_Stack(head);
    }

    printf("顺序栈的基本操作     \n");

    Init_Sq_Stack(s);
    printf("请输入要入栈节点的个数\n");
    scanf("%d",&n);
     printf("请输入要入栈的数据\n");
     for(i=1;i<=n;i++){
     scanf("%d",&x);
     Push_Sq_Stack(s,x);
    }
     printf("完整的栈中数据\n");
     Read_Sq_Stack(s);
     printf("将栈中栈顶元素依次出栈\n");
     for(i=1;i<=n;i++){
      Pop_Sq_Stack(s);
      Read_Sq_Stack(s);
     }

     printf("链队列的基本操作     \n");

     printf("请输入要入队列的个数\n");
     Init_Link_Queue(r);
      scanf("%d",&n);
     printf("请输入队列节点中的数据\n");
       for(i=1;i<=n;i++){
     scanf("%d",&x);
     Enter_Queue(r,x);
    }
    printf("完整的队列中数据\n");
    Read_Queue(r);
     printf("将队列中元素依次出队\n");
     for(i=1;i<=n;i++){
      Delete_Queue(r);
      Read_Queue(r);
     }

    printf("循环队列的基本操作     \n");

    printf("请输入要入队列的个数\n");
    Init_Circle_Queue(t);
    scanf("%d",&n);
    printf("请输入队列节点中的数据\n");
       for(i=1;i<=n;i++){
     scanf("%d",&x);
     Enter_Circle_Queue(t,x);
    }
    printf("完整的队列中数据\n");
    Read_Circle_Queue(t);
    printf("将循环队列中元素依次出队\n");
     for(i=1;i<=n;i++){
      Delete_Circle_Queue(t);
      Read_Circle_Queue(t);
     }


     printf("请输入要转换的数\n");
     scanf("%d",&data);
     printf("输入要转换的进制\n");
     scanf("%d",&num);
     Conversion(data,num);

      printf("请输入要转换的数\n");
     scanf("%d",&data);
     printf("输入要转换的进制\n");
     scanf("%d",&num);
     Conversion(data,num);

      printf("输出杨辉三角\n");

      printf("输入杨辉三角的行数\n");
      scanf("%d",&n);
      Print_YHSJ(n);

    return 0;
}