堆栈

作者: 百合_b06b | 来源:发表于2018-11-04 23:54 被阅读0次

堆栈的顺序存储

#include<stdio.h>

#include<stdlib.h>

#defineFALSE0

#defineTRUE1

typedefintElemType;

typedefintBOOL;

typedefstruct

{

        inttop;                      //栈顶

        intmaxSize;           //堆栈最大的栈顶下标位置(存储空间)

        ElemType*element;     //存储堆栈的元素

}Stack;

//创建一个能容纳mSize个单元的空栈

voidCreate(Stack*S,intmSize)

{

        S->maxSize =mSize- 1;

        S->element = (ElemType*)malloc(sizeof(ElemType)*mSize);

        S->top = -1;

}

//销毁一个已存在的堆栈,即释放堆栈占有的数组空间

voidDestroy(Stack*S)

{

        S->maxSize = -1;

        free(S->element);

        S->top=-1;

}

//判断堆栈是否为空栈,若是,则返回TRUE;否则返回FALSE;

BOOLIsEmpty(Stack*S)

{

        returnS->top == -1;

}

//判断堆栈是否已满,若是,则返回TRUE,否则返回FALSE

BOOLIsFULL(Stack*S)

{

        returnS->top ==S->maxSize;

}

//获取栈顶元素,并通过x返回。若操作成功,则返回TRUE;否则返回FALSE.

BOOLTop(Stack*S,ElemType*x)

{

        if(IsEmpty(S))                       //空栈处理

               returnFALSE;

        *x=S->element[S->top];

        returnTRUE;

}

//在栈顶位置插入元素x(入栈操作)。若操作成功,则返回TRUE,否则返回FALSE.

BOOLPush(Stack*S,ElemTypex)

{

        if(IsFULL(S))                //溢出处理

               returnFALSE;

        S->top++;

        S->element[S->top] =x;

        returnTRUE;

}

//删除栈顶元素(出栈操作)。若操作成功,则返回TRUE,否则返回FALSE.

BOOLPop(Stack*S)

{

        if(IsEmpty(S))                       //空栈处理

               returnFALSE;

        S->top--;

        returnTRUE;

}

//清除堆栈中的全部元素,但并不释放空间。

voidClear(Stack*S)

{

        S->top = -1;

}

//输出

intoutput(StackS)

{

        intx;

        if(IsEmpty(&S))

               returnFALSE;                 //空栈处理

        while(!IsEmpty(&S)){

               Top(&S, &x);                  //获取栈顶元素

               Pop(&S);                              //删除栈顶元素

               printf("%d", x);              //打印栈顶元素

        }

        returnTRUE;

}

intmain()

{

        inti, x;

        StackS;

        Create(&S, 10);                                      //创建一个能容纳mSize个单元的空栈

        for(i = 0; i < 10; i++)              //将0到9依次存入栈中

               Push(&S, i);

        printf("顺序栈中的元素:");           

        output(S);

        Top(&S, &x);                                 //获取栈顶元素

        printf("\n顺序栈中栈顶的元素:");

        printf("%d", x);                             //打印栈顶元素

        Pop(&S);                                             //删除栈顶元素

        printf("\n顺序栈中的元素:");

        output(S);                                           //输出删除一个栈顶元素后的顺序栈

        Clear(&S);                                           //清除堆栈中的全部元素,但并不释放空间。

        output(S);

        printf("\n");

}


//堆栈的链接表示(先进后出,后进先出)

#include<stdio.h>

#include<stdlib.h>

#defineERROR0

#defineOK1

#defineOverflow2            //Overflow表示上溢

#defineUnderflow3           //Underflow表示下溢

#defineNotPresent4   //NotPresent表示元素不存在

#defineDuplicate5           //Duplicate表示有重复元素

typedefintElemType;

typedefintBOOL;

typedefstructNode{

        ElemTypeelement;

        structNode*link;

}Node;

typedefstruct{

        intn;

        structNode*top;

}Stacklist;

//创建

BOOLCreate(Stacklist*s){

        s->top =NULL;

        s->n = 0;

        returnOK;

}

//销毁

voidDestroy(Stacklist*s){

        Node*p;

        while(s->top){

               p =s->top->link;

               free(s->top);

               s->top = p;

        }

}

//判断是否为空

BOOLIsEmpty(Stacklist*s){

        returns->top ==NULL;

}

//获取栈顶元素

BOOLTop(Stacklist*s,ElemType*x){

        if(IsEmpty(s))

               returnERROR;

        *x=s->top->element;

        returnOK;

}

//在栈顶位置插入元素x(入栈)

BOOLPush(Stacklist*s,ElemTypex){

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

        if(p==NULL)

               return0;

        p->element =x;

        p->link =s->top;

        s->top = p;

        s->n++;

        returnOK;

}

//删除栈顶元素(出栈)

BOOLPop(Stacklist*s){

        Node*p;

        if(IsEmpty(s)){

               return0;

        }

        p =s->top;

        s->top =s->top->link;

        free(p);

        s->n--;

        returnOK;

}

//清除堆栈中的所有元素,但不释放空间

voidClear(Stacklist*s){

        s->top =NULL;

}

//输出

BOOLoutput(Stacklists){

        intx;

        if(IsEmpty(&s))

               returnERROR;

        while(!IsEmpty(&s)){

               Top(&s, &x);           //获取

               Pop(&s);

               printf("%d", x);

        }

        returnOK;

}

intmain(){

        inti;

        Stacklists;

        Create(&s);

        for(i = 0; i < 10; i++)

               Push(&s, i);

        printf("链接栈中的元素:");

        output(s);

        Clear(&s);

        printf("\n");

}

相关文章

  • Go 堆栈的理解

    在讲Go的堆栈之前,先温习一下堆栈基础知识。 什么是堆栈?在计算机中堆栈的概念分为:数据结构的堆栈和内存分配中堆栈...

  • 三种常见的计算模型

    堆栈机 堆栈机,全称为“堆栈结构机器”,即英文的 “Stack Machine”。基于堆栈机模型实现的计算机,无论...

  • 初识堆栈

    什么是堆栈 引出堆栈 在学习堆栈之前,我们需要从之前寄存器和内存中引出堆栈,我们要思考堆栈有什么必要性?现在假设我...

  • Linux内核——用户堆栈和内核堆栈

    定义 每个进程都有用户堆栈和内核堆栈两个堆栈。进程在用户态时使用用户堆栈,陷入到内核态时便使用内核堆栈。 切换过程...

  • 数据结构和算法(三) - 栈

    堆栈数据结构在概念上与物理的堆栈相同。将元素添加到堆栈时,将其放在堆栈顶部。从堆栈中删除元素时,始终会删除最顶层的...

  • crash之野指针

    例子一 堆栈信息 根据堆栈分析:1,野指针2,有对应的堆栈查看堆栈代码,看那些有可能野指针: 分析所有参数:url...

  • ARM栈结构

    ARM 栈类型 根据栈生长方向,ARM的栈可分为递增堆栈和递减堆栈。 递增堆栈:栈向高地址生长 递减堆栈:栈向低地...

  • 查看JVM信息的命令

    1. jstack 获取线程堆栈信息 打印堆栈信息到标准输出 jstack PID 打印堆栈信息到标准输出,会打印...

  • 20.有效括号

    检测括号对 (),{},[]是否有效。 思路:利用堆栈。遇到左括号压入堆栈,遇到右括号从堆栈弹出并比较。注意(),...

  • 在Python中实现两个堆栈的队列

    在Python中实现两个堆栈的队列。数据结构了解堆栈和队列。然后用两个堆栈实现一个队列。堆栈和队列都是列表。但它们...

网友评论

      本文标题:堆栈

      本文链接:https://www.haomeiwen.com/subject/bzcjxqtx.html