栈的表示与实现及栈的应用

最新推荐文章于 2022-12-30 20:26:40 发布
最新推荐文章于 2022-12-30 20:26:40 发布
阅读量547 收藏
点赞数
文章标签： struct c input 存储

style="WIDTH: 89.81%; HEIGHT: 64px" src="http://pagead2.googlesyndication.com/pagead/ads?client=ca-pub-4577827332549849&dt=1192819750500&lmt=1192819750&prev_fmts=468x60_as&format=468x15_0ads_al_s&output=html&correlator=1192819750437&channel=1741427766&pv_ch=1741427766%2B&url=http%3A%2F%2Fyzkzoo.5d6d.com%2Fthread-68-1-1.html&color_bg=FFFFFF&color_text=000000&color_link=0000FF&color_url=008000&color_border=336699&ref=http%3A%2F%2Fyzkzoo.5d6d.com%2Fforum-16-1.html&cc=100&ga_vid=1025434795.1192631677&ga_sid=1192817968&ga_hid=1871659779&ga_fc=true&flash=8&u_h=768&u_w=1024&u_ah=738&u_aw=1024&u_cd=32&u_tz=480&u_his=2&u_java=true">

style="WIDTH: 44.33%; HEIGHT: 259px" src="http://pagead2.googlesyndication.com/cpa/ads?client=ca-pub-4577827332549849&cpa_choice=CAEaCB94-nvUZWENUB9QugJQtwRQTVAgULcCUB4&oe=gb2312&dt=1192720966468&lmt=1192720966&format=250x250_as&output=html&correlator=1192720966453&channel=2735220158&url=http%3A%2F%2Fyzkzoo.5d6d.com%2Fthread-67-1-1.html&color_bg=FFFFFF&color_text=000000&color_link=0000FF&color_url=008000&color_border=336699&ad_type=text_image&region=_google_cpa_region_&ref=http%3A%2F%2Fyzkzoo.5d6d.com%2Fforum-16-1.html&cc=100&ga_vid=1025434795.1192631677&ga_sid=1192720940&ga_hid=1155529757&ga_fc=true&flash=8&u_h=768&u_w=1024&u_ah=738&u_aw=1024&u_cd=32&u_tz=480&u_his=2&u_java=true">实现栈的顺序存储。

栈实现示例
#include<stdio.h>
#include<malloc.h>
#include<conio.h>
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define OK 1
#define EQUAL 1
#define OVERFLOW -1
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
typedef int Status ;
struct STU{
  char name[20];
  char stuno[10];
  int age;
  int score;
};
typedef struct STU SElemType;
struct STACK
{
  SElemType *base;
  SElemType *top;
  int stacksize;
};
typedef struct STACK SqStack;
typedef struct STACK *pSqstack;
Status InitStack(SqStack  **S);
Status DestroyStack(SqStack *S);
Status ClearStack(SqStack *S);
Status StackEmpty(SqStack S);
int StackLength(SqStack S);
Status GetTop(SqStack S,SElemType *e);
Status Push(SqStack *S,SElemType e);
Status Pop(SqStack *S,SElemType *e);
Status StackTraverse(SqStack S,Status (*visit)());
Status InitStack(SqStack **S)
{
  (*S)=(SqStack *) malloc(sizeof(SqStack));
  (*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;
}
Status DestroyStack(SqStack *S)
{
free(S->base);
free(S);
}
Status ClearStack(SqStack *S)
{
  S->top=S->base;
}
Status StackEmpty(SqStack S)
{
  if(S.top==S.base) return TRUE;
  else
    return FALSE;
}
int StackLength(SqStack S)
{
  int i;
  SElemType *p;
  i=0;
  p=S.top;
  while(p!=S.base)
    {p++;
     i++;
    }
}
Status GetTop(SqStack S,SElemType *e)
{
  if(S.top==S.base) return ERROR;
  *e=*(S.top-1);
  return OK;
}
Status Push(SqStack *S,SElemType 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;
}
Status Pop(SqStack *S,SElemType *e)
{
  if(S->top==S->base) return ERROR;
  *e=*--S->top;
  return OK;
}
Status StackPrintElem(SElemType * e)
{
  printf("%s  %s  %d  %d/n",e->name,e->stuno,e->age,e->score);
}
Status StackTraverse(SqStack S,Status (*visit)())
{
  while(S.top!=S.base)
     visit(--S.top);
}
main()
{
  SElemType e;
  SqStack *Sa;
  clrscr();
  printf("/n/n-------------------SqStack Demo is running...----------------/n/n");
  printf("First is Push function./n");
  InitStack(&Sa);
  strcpy(e.name,"stu1");
  strcpy(e.stuno,"100001");
  e.age=80;
  e.score=1000;
  printf("   Now Stack is Empty./n");
  StackTraverse(*Sa,StackPrintElem);
  Push(Sa,e);
  printf("   Now Stack has one element./n");
  StackTraverse(*Sa,StackPrintElem);
  strcpy(e.name,"stu3");
  strcpy(e.stuno,"100002");
  e.age=80;
  e.score=1000;
  Push(Sa,e);
  printf("   Now Stack has another element./n");
  StackTraverse(*Sa,StackPrintElem);
  printf("   Now Pop Stack,the top elem put into variable e./n");
  Pop(Sa,&e);
  printf("%s/n%s/n%d/n%d/n",e.name,e.stuno,e.age,e.score);
  printf("   Let's see the left of Stack's elem:/n");
  StackTraverse(*Sa,StackPrintElem);
  getch();
  printf("/n/n/nWelcom to visit http://zmofun.topcool.net/n/n");
}

二、栈的应用
１、利用栈实现数制转换 ２、利用栈实现单行编辑
以上任选一题。
数制转换示例
#include<stdio.h>
#include<malloc.h>
#include<conio.h>
typedef int SElemType;
#include "stack.h"
Status visit(SElemType * e)
{
  printf(" %d  ", *e);
}
void conversion()
{
pSqStack S;
SElemType e;
int n;
InitStack(&S);
printf("Input a number to convert to OCT:/n");
scanf("%d",&n);
if(n<0)
   {
     printf("/nThe number must be over 0.");
     return;
   }
if(!n) Push(S,0);
while(n){
   Push(S,n%8);
   n=n/8;
}
printf("the result is:        ");
while(!StackEmpty(*S)){
   Pop(S,&e);
   printf("%d",e);
}
}
main()
{
  printf("/n/n/n/n");
  conversion();
  getch();
  printf("/n/nWelcome to visit http://zmofun.yeah.net !");
}
单行编辑示例
#include<string.h>
#include<stdio.h>
#include<malloc.h>
#include<conio.h>
#define EOFILE '`'
typedef char SElemType;
#include "stack.h"
Status visit(SElemType * e)
{
  printf("%c", *e);
}
char OP[10]={'+','-','*','/','(',')','#'};
int precede[7][7]={
      1,1,2,2,2,1,1,
      1,1,2,2,2,1,1,
      1,1,1,1,2,1,1,
      1,1,1,1,2,1,1,
      2,2,2,2,2,3,0,
      1,1,1,1,0,1,1,
      2,2,2,2,2,0,3};
int In(char c,char *op)
{
  int i=0;
  while(i<7)
     if(c==op[i++])
       return 1;
  return 0;
}
char Precede(char op,char c)
{
  int pos_op;
  int pos_c;
  int i;
  for(i=0;i<7;i++)
    {
      if(op==OP) pos_op=i;
      if(c==OP) pos_c=i;
    }
  switch(precede[pos_op][pos_c])
    {
      case 1:  return '>';
      case 2:  return '<';
      case 3:  return '=';
    }
}
char Operate(int a,char theta,int b)
{
  switch(theta)
    {
      case '+':return a+b-'0';
      case '-':return a-b+'0';
      case '*':return (a-'0')*(b-'0')+'0';
      case '/':return (a-'0')/(b-'0')+'0';
    }
}
char EvaluateExpression()
{
  SqStack *OPND,*OPTR;
  char c,x,theta;
  char a,b;
  InitStack(&OPTR);  Push(OPTR,'#');
  InitStack(&OPND);
  c=getchar();
  while(c!='#'||GetTop(*OPTR)!='#')
    {
      if(!In(c,OP))
        {Push(OPND,c);c=getchar();}
      else
        switch(Precede(GetTop(*OPTR),c))
          {
            case '<':
              Push(OPTR,c);
              c=getchar();
              break;
            case '=':
              Pop(OPTR,&x);
              c=getchar();
              break;
            case '>':
              Pop(OPTR,&theta);
              Pop(OPND,&b);  Pop(OPND,&a);
              Push(OPND,Operate(a,theta,b));
              break;
          }
    }
  c=GetTop(*OPND);
  DestroyStack(OPTR);
  DestroyStack(OPND);
  return c;
}

main()
{
  char i;
  printf("/n/n/n/nOnly within 0..9 evaluation,input a expression end with symbol #:/n");
  i=EvaluateExpression();
  printf("/nThis expression's result is:   ");
  printf("%d/n/n/n/n",i-'0');
  printf("/n/nWelcome to visit http://zmofun.yeah.net !");
}

这里是实现栈的头文件
#include "simuc.h"

#define OVERFLOW -1
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
typedef int Status;
struct STACK
{
  SElemType *base;
  SElemType *top;
  int stacksize;
};
typedef struct STACK SqStack;
typedef struct STACK *pSqStack;
Status InitStack(SqStack  **S);
Status DestroyStack(SqStack *S);
Status ClearStack(SqStack *S);
Status StackEmpty(SqStack S);
int StackLength(SqStack S);
SElemType GetTop(SqStack S);
Status Push(SqStack *S,SElemType e);
Status Pop(SqStack *S,SElemType *e);
Status StackTraverse(SqStack S,Status (*visit)());
Status InitStack(SqStack **S)
{
  (*S)=(SqStack *)malloc(sizeof(SqStack));
  (*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;
}
Status DestroyStack(SqStack *S)
{
free(S->base);
free(S);
}
Status ClearStack(SqStack *S)
{
  S->top=S->base;
}
Status StackEmpty(SqStack S)
{
  if(S.top==S.base) return TRUE;
  else
    return FALSE;
}
int StackLength(SqStack S)
{
  int i;
  SElemType *p;
  i=0;
  p=S.top;
  while(p!=S.base)
    {p++;
     i++;
    }
}
SElemType GetTop(SqStack S)
{
  if(S.top==S.base) return ERROR;
  return *(S.top-1);
}
Status Push(SqStack *S,SElemType 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;
}
Status Pop(SqStack *S,SElemType *e)
{
  if(S->top==S->base) return ERROR;
  *e=*(--(S->top));
  return OK;
}

Status StackTraverse(SqStack S,Status (*visit)())
{
  while(S.top>S.base)
     visit(--S.top);
}

style="WIDTH: 52.39%; HEIGHT: 263px" src="http://pagead2.googlesyndication.com/cpa/ads?client=ca-pub-4577827332549849&cpa_choice=CAEaCKcC4yuPlq5lUDRQDVAtUK4BUENQCA&oe=gb2312&dt=1192819388296&lmt=1192819388&format=300x250_as&output=html&correlator=1192819388281&channel=2735220158&url=http%3A%2F%2Fyzkzoo.5d6d.com%2Fviewthread.php%3Ftid%3D70%26page%3D1%26extra%3Dpage%253D1&color_bg=FFFFFF&color_text=000000&color_link=0000FF&color_url=008000&color_border=336699&ad_type=text_image&region=_google_cpa_region_&ref=http%3A%2F%2Fyzkzoo.5d6d.com%2Fpost.php%3Faction%3Dedit%26fid%3D16%26tid%3D70%26pid%3D70%26page%3D1%26extra%3Dpage%253D1&cc=100&ga_vid=1025434795.1192631677&ga_sid=1192817968&ga_hid=1527165455&ga_fc=true&flash=8&u_h=768&u_w=1024&u_ah=738&u_aw=1024&u_cd=32&u_tz=480&u_his=5&u_java=true">

style="WIDTH: 82.23%; HEIGHT: 74px" src="http://pagead2.googlesyndication.com/pagead/ads?client=ca-pub-4577827332549849&dt=1192818497343&lmt=1192818497&format=468x60_as&output=html&correlator=1192818497343&channel=1741427766&url=http%3A%2F%2Fyzkzoo.5d6d.com%2Fthread-68-1-1.html&color_bg=FFFFFF&color_text=000000&color_link=0000FF&color_url=008000&color_border=336699&ad_type=text_image&ref=http%3A%2F%2Fyzkzoo.5d6d.com%2Fforumdisplay.php%3Ffid%3D16%26page%3D1&ui=rc%3A6&cc=100&ga_vid=1025434795.1192631677&ga_sid=1192817968&ga_hid=1000484876&ga_fc=true&flash=8&u_h=768&u_w=1024&u_ah=738&u_aw=1024&u_cd=32&u_tz=480&u_his=6&u_java=true">

style="WIDTH: 58.41%; HEIGHT: 156px" src="http://pagead2.googlesyndication.com/pagead/ads?client=ca-pub-4577827332549849&dt=1192819750656&lmt=1192819750&prev_fmts=468x60_as%2C468x15_0ads_al_s%2C234x60_as&format=200x90_0ads_al_s&output=html&correlator=1192819750437&channel=1741427766&pv_ch=1741427766%2B&url=http%3A%2F%2Fyzkzoo.5d6d.com%2Fthread-68-1-1.html&color_bg=FFFFFF&color_text=000000&color_link=0000FF&color_url=008000&color_border=336699&ref=http%3A%2F%2Fyzkzoo.5d6d.com%2Fforum-16-1.html&cc=100&ga_vid=1025434795.1192631677&ga_sid=1192817968&ga_hid=1871659779&ga_fc=true&flash=8&u_h=768&u_w=1024&u_ah=738&u_aw=1024&u_cd=32&u_tz=480&u_his=2&u_java=true"> 

yzkzoo
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
栈的一些基本的应用与实现
07-29
本主题将探讨栈的一些基本应用以及如何实现这些功能。 1. 符号就近匹配：在编程语言解析和编译过程中，符号就近匹配是常见的应用场景。例如，当解析括号、引号等配对符号时，我们可以通过栈来检查一对括号是否正确...
如何用C语言、Python实现栈及典型应用
09-01
C语言实现栈： 在C语言中，我们可以自定义一个链式栈的数据结构。这里使用了一个`stackNode`结构体来表示栈节点，包含一个`void *`类型的值和指向下一个节点的指针。`stack`结构体则包含了栈顶指针、释放元素的函数...
栈——概念、基本操作及其应用
qq_51308373的博客
03-14 4116
前言 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns import warnings warnings.filterwarnings('ignore') import ssl ssl._create_defau
数据结构--栈的基本概念与应用
丹丹的后花园
11-06 1436
栈是一种非常重要的数据结构，虽然逻辑简单，但是非常重要，许多问题的求解，都使用到了栈。
c语言栈的实现和表示
热门推荐
n
04-18 1万+
栈的定义：栈是仅限在表尾进行插入和删除的线性表允许进行插入和删除的一端被称为栈顶另一端被称为栈底，插入被称为进栈或入栈，删除被称为出栈或退栈。 栈的特点：先进后出 栈的基本算法： 1．进栈 ①若TOP≥n时，则给出溢出信息，作出错处理（进栈前首先检查栈是否已满，满则溢出；不满则作②）； ②置TOP=TOP+1（栈指针加1，指向进栈地址）； ③S(TOP)=X，结束（X为新进栈的元素）； 2．退栈...
栈及其应用
weixin_51550438的博客
10-04 1796
Java语言介绍栈数据结构
数据结构-栈及栈的应用
初始化的博客
07-19 4535
栈的概述 栈式一种重要的线性结构，属于一种操作受限的线性表 栈(stack) 是限定尽在表尾进行插入或删除操作的线性表 表尾端称为栈顶(top)，表头端称为栈底(bottom) 栈的元素先进后出(后进先出)，即最先进入栈的元素最后出栈 ...
C语言栈的表示与实现实例详解
09-04
栈在C语言中的表示通常使用数组或链表实现，这里我们将主要关注基于数组的顺序栈。 1. 基本概念： 栈是一种线性数据结构，其特点是只允许在表的一端，也就是栈顶进行插入（Push）和删除（Pop）操作。栈底是固定的，...
java 栈的实现和应用
07-05
在Java中，有两种主要的方式来实现栈： 1. **ArrayDeque类**：Java集合框架提供了一个双端队列`ArrayDeque`，它可以被用作一个高效的栈。`ArrayDeque`继承自`AbstractCollection`，并实现了`Deque`接口，这个接口...
栈 的 实 现 与 应 用.docx
01-23
链栈的操作与顺序栈类似，但不再受限于固定大小的数组，其空间效率更高。 提升型实验主要考察了栈在实际问题中的应用，比如括号匹配。在这个问题中，遇到左括号（如'('、'['或'{'）时，将其压入栈中；遇到右括号时...
栈的实现和应用（实验报告+代码）
04-28
实现了以下三个问题 1、 实现自己的顺序栈类； 2、 判断输入的字符串中的括号是否配对； 3、 输入一个后缀表达式，并进行求值。
栈以及栈的应用
weixin_42776344的博客
05-02 2754
一、栈的定义 栈是只能在表尾进行插入和删除操作的线性表。对于插入到栈的元素按“后进先出”的规则处理，插入和删除操作都在栈顶进行，一般用定长数组存储栈元素。由于进栈和出栈都是在栈顶进行，因此要有一个size变量来记录当前栈的大小，当进栈时size不能超过数组长度，size+1，出栈时栈不为空，size-1。 二、顺序栈 采用顺序存储的栈称为顺序栈，它利用一组地址连续的存储单元存放自栈底到栈顶的数据元素，同时附设一个指针（top）指示当前栈顶元素的位置。 栈顶指针：S.top，初始时设置S.top = -1；
【数据结构（13）】3.3 栈的表示和操作的实现
最新发布
shangguanxiu的博客
12-30 1389
严蔚敏版【数据结构】 一、栈的抽象数据类型的类型定义 1. 栈的基本操作 二、顺序栈的表示和实现 1. 顺序栈的表示 2. 顺序栈的实现 2.1 顺序栈的初始化 2.2 判断顺序栈是否为空 2.3 求顺序栈长度 2.4 清空顺序栈 2.5 销毁顺序栈 2.6 顺序栈的入栈 2.7 顺序栈的出栈 三、链栈的表示和实现 1. 链栈的表示 2. 链栈的实现 2.1 链栈的初始化 2.2 判断链栈是否为空 2.3 链栈的入栈 2.4 链栈的出栈 2.5 取链栈的栈顶元素
栈的表示和实现（C语言）
Prefectkn的博客
07-25 399
本篇博客详细介绍了数据结构中“栈”的概念结构、练习题、基于C语言的代码实现。
栈的实现及其应用
m0_55769200的博客
05-29 932
实现顺序栈的基本操作：构造空栈、入栈、出栈、取栈顶元素。 输入一包含’[‘ ‘]’ “(”和“)”的字符串，检测括号是否匹配（其中括号中能嵌套括号），并输出括号是否匹配的信息。 输入一个十进制数, 输出其对应的八进制数。 ...
栈的定义，顺序栈表示和实现及其简单的应用
qq_43697688的博客
05-01 913
一.栈的定义:栈是限定仅在表尾进行插入或删除操作的线性表，对于栈来说，尾端称为栈顶，表头端称为栈底，不含元素的空表称为空栈。例如:S=（a1,a2,a3…,an），则a1称为栈底元素，an为栈顶元素，栈遵守先进后出的原则，如进入12345，出去为54321. 二.先定义一个结构体: typedef struct{ int *base; //在栈构造之前和销毁之后，...
数据结构（四）——栈实现及其应用
仙八哥的博客
03-09 1559
1、栈的概念 栈是限制在一端进行插入或者删除操作的线性表（俗称堆栈） 允许进行操作的一端称为“栈顶” 另一固定端称为“栈底” 当栈中没有元素时称为“空栈” 特点：后进先出（LIFO） 栈的应用：解决非线性问题，通过一个栈把问题线性化。 2、栈的创建 typedef int data_t; //先定义一个结构体 typedef strcut{ data_t *data; int maxlen; int top; }sqstack; 以32位的系统为例，指针为4个字节，int为4个字节，所以该结构体
复习理解栈实现及其应用
Specif1c的博客
09-30 329
几个月前学的，回来记笔记，温故而知新… 一、栈 1、什么是栈 栈(Stack)是一种线性存储结构，它具有如下特点： （1）栈中的数据元素遵守”先进后出”(First In Last Out)的原则，简称FILO结构。 （2）限定只能在栈顶进行插入和删除操作。 2、栈的特点 栈：后进先出( LIFO-last in first out ) : 最后插入的元素最先出来。 3、栈的基本操作 栈主要有以下几种基本操作： （1）push(): 向栈内压入一个成员； （2）pop(): 从栈顶弹出一个.
顺序栈表示与实现
SuiGi的博客
07-11 847
//stack basic operation //sequent list //if base=top null stack #include<stdio.h> #include<iostream.h> #include<malloc.h>//free #include<cstdlib> #include<math.h> #includ...
栈与队列操作：判断栈满的实现及应用
在实现栈的顺序存储结构时，可以使用数组，并设定一个变量top作为栈顶指针，用于跟踪当前栈顶元素的位置。例如，如果栈的大小为StackSize（如定义为100），当top等于stacksize-1时，意味着栈已满，不能再进行压栈...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值