数据结构——栈与队列

题目：

1.编写函数,采用链式存储实现栈的初始化、入栈、出栈操作

2.编写函数,采用顺序存储实现栈的初始化、入栈、出栈操作

3.编写函数,采用链式存储实现队列的初始化、入队、出队操作

4.编写函数,采用顺序存储实现队列的初始化、入队、出队操作

5.编写一个主函数,在主函数中设计一个简单的菜单,分别调试上述算法

题目分析：

1.顺序栈的类型定义

#define MAX 100  //栈的最大值
typedef struct
{
    ElemType *base;
    int top;
} SqStack;

2.链栈的类型定义

typedef struct SqNode
{
    SElemType data;
    SqNode *Link;
} *Sqptr;
typedef struct
{
    Sqptr top;  //栈项指针
}

3.顺序队列的类型定义

#define MAX 100 //队列的最大长度
typedef struct
{
    ElemType *base;
    int front,rear;
} SqQueue;

4.单链队列的类型定义

typedef struct QNode
{
    QElemType data;
    struct QNode *next;
} *QueuePtr;
 
typedef struct
{
    QueuePtr frout;   //队头指针
    QueuePtr rear;    //队尾指针
}

下面是具体的程序：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
 
#define OVERFLOW -2 
#define ERROR 0 
#define OK 1 
#define MAX 100    //栈的最大值
 
typedef int SElemType; 
typedef int QElemType; 
typedef struct
{
    SElemType *base;   
    SElemType *top; 
}SqStack;  

SqStack InitStacka( )  //顺序存储实现栈的初始化
{ 
    SqStack S;  
    S.base = ( SElemType * )malloc( MAX *sizeof( SElemType ));  
    if( !S.base ) 
    exit( OVERFLOW  );  
    S.top = S.base;  
return(S); 
} 
 
 
void Pusha(SqStack &S, int x)   //顺序存储实现栈的入栈操作
{
    if(S.top - S.base >= MAX) 
    {
       exit(OVERFLOW);
    }  
    *S.top++ = x; 
}  
 
 
void Popa(SqStack &S)    //顺序存储实现栈的出栈操作
{
    SElemType *p;  
    int x;  
    if(S.top == S.base)
   {
       return ; 
    } 
    else 
   {
       p = S.top;  
       x = * --S.top;  
       printf("\t删除的栈顶元素是%d\n\t出栈操作完成后的栈为:\n", x);  
   } 
} 
 
 
void printa(SqStack S)   //输出
{
    SElemType *p;  
    p = S.base; 
    printf("\t");  
    while(p != S.top)  
   {
       printf("%d ", *(p++));
    } 
    printf("\n"); 
}  
 
 
typedef struct SqNode
{
     SElemType data;  
     SqNode *Link; 
}*Sqptr,NODE; 

typedef struct 
{
     Sqptr top; 
}Stack;

Stack InitStackb()  //链式存储实现栈的初始化
{ 
    Stack S;  
    S.top = ( Sqptr )malloc( sizeof( NODE ) );  
    if( !S.top )
    { 
        exit (OVERFLOW);  
    }
        S.top -> Link = NULL;  
return(S); 
}  
 
 
void Pushb(Stack &S, int x)  //链式存储实现栈的入栈操作
{ 
    Sqptr p;  
    p = ( Sqptr )malloc( sizeof( NODE ) );  
    if( !p ) 
    {
        return ; 
     } 
    p -> data = x;  
    p -> Link = S.top -> Link;  
    S.top -> Link = p; 
}
 
 
void Popb(Stack &S)   //链式存储实现栈的出栈操作
{ 
    int x;  
    Sqptr p;  
    if(S.top -> Link == NULL)
    { 
        return ;  
     }
    else 
   {    
        p = S.top -> Link;        
        x = p -> data;     
        S.top -> Link = p -> Link;     
        printf("\t删除的栈顶元素是%d\n", x);     
       free(p);
    } 
}  
 
typedef struct QNode 
{
    QElemType data;  
    struct QNode *next; 
}*QueuePtr,QNode; 

typedef struct 
{
    QueuePtr front;  
    QueuePtr rear; 
}LinkQueue;

LinkQueue InitQueue()  //链式存储实现队列的初始化
{ 
    LinkQueue Q;  
    Q.front = Q.rear = ( QueuePtr )malloc( sizeof( QNode ) );  
    if( !Q.front ) 
   {
       exit (OVERFLOW); 
    } 
       Q.front -> next = NULL;   
return(Q); 
} 
 
void EnQueue(LinkQueue &Q, QElemType x)   //链式存储实现队列的入队操作
{ 
    QueuePtr p;  
    p = ( QueuePtr )malloc( sizeof( QNode ) );  
    if( !p ) 
    {
        exit(OVERFLOW);  
     }
     p -> data = x; 
     p -> next = NULL; 
     Q.rear -> next = p;  
     Q.rear = p; 
} 
 
 
void DeQueue(LinkQueue &Q)   //链式存储实现队列的出队操作
{ 
    int x;  
    if(Q.front == Q.rear) 
   {
       return ; 
    } 
    QueuePtr p;  
    p = Q.front -> next;  
    x = p -> data;  
    printf("\t删除的队头元素是%d\n", x);  
    Q.front -> next = p -> next;  
    if(Q.rear == p)
    {
        Q.rear = Q.front; 
     }
    free(p);  
return; 
}  
 
typedef struct 
{
    SElemType *base;  
    int front, rear; 
}SqQueue; 

SqQueue InitQueueb()  //顺序存储实现队列的初始化
{ 
    SqQueue S;  
    S.base = ( SElemType * )malloc( MAX *sizeof( SElemType ));  
    if( !S.base ) 
    {
         exit(OVERFLOW);
     }  
    S.front = S.rear = 0;  
return(S); 
}
 
 
void EnQueueb(SqQueue &S, int x)   //顺序存储实现队列的入队操作
{ 
    if((S.rear+1) % MAX == S.front)
    { 
        return ;  
     }
    S.base[S.rear] = x;  
    S.rear = (S.rear+1) % MAX; 
}
 
 
void DeQueueb(SqQueue &S)  //顺序存储实现队列的出队操作
{
    int x;  
    if(S.front == S.rear)
    { 
       return ;  
     }
     x = S.base[S.front];  
     S.front = (S.front+1) % MAX;  
     printf("\t删除的队头元素是:%d\n", x); 
} 
 
 
int main() 
{
    int choice;  
    int n, x;  
    printf("\t1.使用链式存储实现栈的初始化、入栈、出栈操作\n"); 
    printf("\t2.使用顺序存储实现栈的初始化、入栈、出栈操作\n"); 
    printf("\t3.使用链式存储实现队列的初始化、入栈、出栈操作\n"); 
    printf("\t4.使用顺序存储实现队列的初始化、入栈、出栈操作\n"); 
    printf("\t请选择:");  
    scanf("%d", &choice);  
    switch(choice) 
     {
         case 1:
               Stack Sa;
               printf("\t1.链式存储实现栈的初始化\n");     
               printf("\t2.链式存储实现栈的入栈操作\n");     
               printf("\t3.链式存储实现栈的出栈操作\n");           
               while(1)
               {                
                   printf("\t请选择：");                
                   scanf("%d", &n);                
                   switch(n)                
                   {
                        case 1:
                            Sa = InitStackb();                        
                            printf("\t链式存储栈的初始化完成!\n");
                            break;                 
                        case 2:
                            printf("\t以‘0‘结束\n");
                            printf("\t");         
                            scanf("%d", &x);                     
                            while(x)
                            {               
                                Pushb(Sa, x);
                                scanf("%d", &x);
                             }                  
                            printf("\t链式存储栈的入栈操作完成!\n");
                            break;                 
                        case 3:
                            Popb(Sa);
                            break;
                   }
              }
              break;
         case 2:
              SqStack S;     
              printf("\t1.顺序存储实现栈的初始化\n");     
              printf("\t2.顺序存储实现栈的入栈操作\n");     
              printf("\t3.顺序存储实现栈的出栈操作\n");     
              while(1)
              { 
                  printf("\t请选择:");      
                  scanf("%d", &n);     
                  switch(n)      
                  {  
                      case 1:
                           S = InitStacka();             
                           printf("\t顺序存储栈的初始化完成!\n");
                           break;      
                      case 2:
                           printf("\t以‘0‘结束!\n");          
                           printf("\t"); 
                           scanf("%d", &x);             
                           while(x)
                           {                      
                                Pusha(S, x);                   
                                scanf("%d", &x);
                           }                   
                           printf("\t顺序存储栈的入栈操作完成!\n");                   
                           printa(S);
                           break;               
                       case 3:
                           Popa(S);         
                           printa(S);
                           break;
                   }
              }
              break;
         case 3:
              LinkQueue Q;         
              printf("\t1.链式存储实现队的初始化\n");          
              printf("\t2.链式存储实现队的入栈操作\n");          
              printf("\t3.链式存储实现队的出栈操作\n");         
              while(1)
              {         
                  printf("\t请选择：");          
                  scanf("%d", &n);          
                  switch(n)          
                  {    
                      case 1:
                           Q = InitQueue();                      
                           printf("\t链式存储队的初始化完成!\n");
                           break;               
                      case 2:
                           printf("\t以‘0‘结束\n");
                           printf("\t");
                           scanf("%d", &x);                   
                           while(x)
                           {            
                                EnQueue(Q, x);
                                scanf("%d", &x);
                            }                
                           printf("\t链式存储队的入栈操作完成!\n");
                           break;                
                      case 3:
                           DeQueue(Q);
                           break;
                  }
              }
              break;   
         case 4:
              SqQueue Sv;   
              printf("\t1.顺序存储实现队的初始化\n");          
              printf("\t2.顺序存储实现队的入栈操作\n");          
              printf("\t3.顺序存储实现队的出栈操作\n");          
              while(1)
              {          
                  printf("\t请选择：");          
                  scanf("%d", &n);          
                  switch(n)           
                  {       
                      case 1:
                          Sv = InitQueueb();                   
                          printf("\t链式存储栈的初始化完成!\n");
                          break;            
                      case 2:
                          printf("\t以‘0‘结束\n");
                          printf("\t");
                          scanf("%d", &x);                 
                          while(x)
                          {           
                               EnQueueb(Sv, x);
                               scanf("%d", &x);
                          }              
                          printf("\t链式存储栈的入栈操作完成!\n");
                          break;
                      case 3: 
                          DeQueueb(Sv);
                          break;
                   }
              }
              break; 
        } 
system("pause");
return 0;
}

时间： 2024-12-18 23:23:54

数据结构——栈与队列的相关文章

C数据结构-栈和队列,括号匹配举例

1.栈和队列是两种特殊的线性表运算操作被限定只能在表的一端或两端插入,删除元素,故也称它们为限定的线性表结构 2.栈的基本运算 1).Stackinit(&s) 构造一个空栈 2).Stackempty(s) 判断s是否为空栈,当s为空栈时,函数返回值1 否则 0 3).Push(&s,x) 在栈s 的顶部插入元素x,简称将x入栈 4).Pop(&s,&x) 在栈s 中删除顶元并将其值保存在x单元中返回,简称将x出栈 5)Gettop(s,&x) 读s栈中的

数据结构——栈和队列相关算法实现

数据结构栈和队列的基本算法实现限定性线性表--栈栈的定义栈作为一种限定性的线性表,是将线性表的插入和删除操作限制为仅在表的一端进行. 基本算法演示 /* 栈的常见操作: 1.初始化栈 2.元素进栈 3.元素出栈 4.栈的遍历 5.判断栈是否为空栈 6.清空整个栈 */ # include <stdio.h> # include <stdlib.h> typedef struct Node { int date; struct Node * pNext; }NODE,* PNO

C#数据结构—栈和队列

一:栈栈和队列也是线性结构,线性表.栈和队列这三种数据结构的数据元素以及数据元素间的逻辑关系完全相同,差别是线性表的操作不受限制,而栈和队列的操作受到限制.栈的操作只能在表的一端进行,队列的插入操作在表的一端进行而其它操作在表的另一端进行,所以,把栈和队列称为操作受限的线性表. 1:栈的定义及基本运算栈(Stack)是操作限定在表的尾端进行的线性表.表尾由于要进行插入.删除等操作,所以,它具有特殊的含义,把表尾称为栈顶(Top),另一端是固定的,叫栈底(Bottom).当栈中没有数据元素时叫

c数据结构 -- 栈与队列

栈和队列 ·栈和队列是两种常用的.重要的数据结构 ·栈和队列是限定插入和删除只能在表的“端点”进行的线性表栈只能在队尾插入,只能在队尾删除 -- 后进后出表尾称为栈顶:表头称为栈底插入元素到栈顶(即表尾)的操作,称为入栈从栈顶删除最后一个元素的操作,称为出栈注意:函数调用的流程就是入栈和出栈的实现,遵循后调用的先返回队列只能在队尾插入,只能在对队头删除 -- 先进先出顺序栈的实现: #include <stdio.h> #include <stdlib.h> #d

数据结构-栈、队列和链表

一.栈stack 是后进先出的数据结构栈顶指针指的始终是栈最上方元素的一个标记,即放在最上面的元素.栈顶元素为空时令top为-1. 在使用pop()函数和top()函数时,需要使用empty()判断栈是否为空. 在STL中stack容器来编写代码,STL定义stack的复杂度是O(1). 常见函数: clear() size() empty() push() pop() top() 二.队列queue 是一种先进先出的数据结构需要一个队首指针front来指向队首元素的前一个位置,而使用一个队

数据结构-栈和队列

栈和队列都是线性表,所以满足-只有一个节点没有前继,只有后继,只有一个节点只有后继没有前继,其他的节点只有一个前继只有一个后继. 栈的定义是先进后出,最典型的例子就是弹夹,最先进去的反而是最后射出来的,在实际的软件开发中会进经常的遇到这种类型的线性表,我们成为LIFO(Last in First out).可以把栈想象成是只有一个出口的容器,最先放进去的东西只能够等其上面的东西呗拿走之后才能够拿出来. 队列则是另外的一种线性表,队列在我们生活中就更常见了,比如排队啊什么的,队列讲的是先进先出,在

数据结构-栈与队列

相比于数组这种存储数据的数据,栈(Stock)和队列(Queue)主要作用是在程序中作为构思算法的辅助工具,是一种程序员开发过程中的便利工具.Stock和Queue具有访问受限以及更加抽象的特征. 一.栈栈只允许访问最后一个插入的元素,即栈是先进后出(FILO)的一种数据结构.栈主要提供的算法包括push,pop和peek.其中push是插入一个元素,pop是弹出最近添加的一个元素,peek是返回最近添加的一个元素. 栈的底层实现可以是数组,也可以是链表,这里采用数组实现一个栈,代码如下: 1

JavaScript数据结构——栈和队列

栈:后进先出(LIFO)的有序集合队列:先进先出(FIFO)的有序集合 ------------------------------------------------------------------------------------------------------ 栈方法声明: 首先,采用数组来保存栈里的元素. 序号方法说明 1 push ( element(s) ) 添加一个(或几个)新元素到栈顶 2 pop ( ) 移除栈顶的元素,同时返回被移除的元素 3 peek ( )

考研数据结构-栈和队列

栈栈是一种只能在一端进行插入或删除操作的线性表. 线性表:栈的逻辑结构属于线性表,只不过在操作上加了一些约束. 一端:可以插入或者删除元素的一端叫栈顶,另一端叫栈底. 顺序栈 1 int stack[maxSize]; 2 int top = -1; 3 4 //元素入栈 5 stack[++top] = x; 6 7 //元素出栈 8 x = stack[top--]; 链栈 1 LNode *head = (LNode*)malloc(sizeof(LNode)); 2 head→next