顺序栈操作

• 定义
• 结构体
• 顺序栈的基本操作
  
  
  
  1. 创建栈
  2. 判栈空
  3. 压栈
  4. 弹栈
  5. 读栈
  6. 置空栈
  7. 求栈长度
• 顺序栈应用

1.定义

栈(stack)是一种特殊的线性表.栈是限定结点插入和删除只能在同一端进行的线性表.

栈犹如一个一端开口一端封闭的容器.可插入和删除的一端称为栈顶,另一端称为栈底.

”栈顶指针”:指示最后插入栈中的结点位置,处于栈顶位置的结点称为栈顶结点.”栈底指针”:指示栈底位置,它始终指向最先插入的结点的下面位置.

不含任何结点的栈称为”空栈”.栈为空时,栈顶指针和栈底指针重合.

栈的插入形象地称为”压栈”.删除称为弹栈.

栈的重要特点,最后压入的结点最先弹出,最先压入的结点只能最后弹出.因此,栈又称为后进先出表,或称LIFO表(Last In First Out).

2.结构体

在StackCs.c

# define DT char# define M 100typedef struct {    DT data[M];    int top;}SEQSTACK;

顺序存储结构存储的栈称为”顺序栈”,和顺序表一样,用一个一维数组存储.栈底是:下标为0的数组元素处,也可以设置为另一端.栈顶指针是数组元素的下标,始终指向最后插入的那个元素.这里的指针不是指针类型,而是一个整数.

data[M]是一个一维数组,是栈体,top是栈顶指针.栈底固定在数组的低下标端,所以无需设置栈底指针.当top=0时,栈为空.所以约定的是data[0]闲置不用,即:栈本身的数据是从data[1]开始存储的.

3.顺序表操作

3.1创建栈

创建一个新栈S,且为空栈,并返回S

在StackControl.h写出方法声明

/* 创建空栈 */SEQSTACK createEmptyStack();

在StackControl.c中实现此方法

#include "StackControl.h"/* 创建空栈 */SEQSTACK createEmptyStack(){    SEQSTACK S;    S.top=0;    return S;}

在main.c中的main方法(int main(int argc, const char * argv[]) {})调用此方法,并且进行判断

#include "StackControl.h"int main(int argc, const char * argv[]) {   // 创建空栈和判空栈    printf("创建空栈和判空栈\n");    SEQSTACK S=createEmptyStack();    int i=isEmptyStack(S);    if(i==1){        printf("S是空栈\n");    }else{        printf("S不是空栈");    }    printf("\n");    }

打印结果:

创建空栈和判空栈S是空栈

3.2判栈空

判断一个栈是否为空栈,那么就是栈顶指针是否为0,即:栈顶指针和栈底指针相等
判断指定栈是否为空栈,若为空则返回1,否则返回0
在StackControl.h写出方法声明

/* 判栈空 */int  isEmptyStack(SEQSTACK S){    if(S.top==0){        return 1;    }    return 0;}

在StackControl.c中实现此方法

#include "StackControl.h"int  isEmptyStack(SEQSTACK S){    if(S.top==0){        return 1;    }    return 0;}

在main.c中的main方法(int main(int argc, const char * argv[]) {})调用此方法,并且进行判断

#include "StackControl.h"int main(int argc, const char * argv[]) {   // 创建空栈和判空栈    printf("创建空栈和判空栈\n");    SEQSTACK S=createEmptyStack();    int i=isEmptyStack(S);    if(i==1){        printf("S是空栈\n");    }else{        printf("S不是空栈");    }    printf("\n");    }

打印结果:

创建空栈和判空栈S是空栈

3.3压栈

将数据添加到栈顶位置.
给定指定结点数据x,向指定栈S插入x,并为栈顶结点
在StackControl.h写出方法声明

/* 压栈 */SEQSTACK pussStack(SEQSTACK S,DT value);/* 显示栈数据 */void printfStack(SEQSTACK S);

在StackControl.c中实现此方法

SEQSTACK pussStack(SEQSTACK S,DT value){    //1.判断是否会上溢    if(S.top+1>=M){        printf("overflow  puss failure\n");    }else{        //2.移动顶指针        S.top++;        //3.进行压栈数据        S.data[S.top]=value;        printf("puss success!\n");    }    return S;}void printfStack(SEQSTACK S){    printf("stack={");    printf("{");    int index=0;    for(int i=1;i<=S.top;i++){        if(index==0){            printf("%c",S.data[i]);            index=1;        }else{            printf(",%c",S.data[i]);        }    }    printf("},top=%d",S.top);    printf("}\n");}

在main.c中的main方法(int main(int argc, const char * argv[]) {})调用此方法,并且进行判断

  #include "StackControl.h"  int main(int argc, const char * argv[]) {     //压栈    printf("压栈\n");    SEQSTACK pStack={{'0','a','b'},2};    printfStack(pStack);    pStack=pussStack(pStack, 'c');    printfStack(pStack);    printf("\n");}

打印结果:

压栈stack={{a,b},top=2}puss success!stack={{a,b,c},top=3}

3.4弹栈

从指定栈S中删除栈顶结点

在StackControl.h写出方法声明

/* 弹栈 */SEQSTACK popStack(SEQSTACK S);

在StackControl.c中实现此方法

SEQSTACK popStack(SEQSTACK S){    //1.判断是否为空栈    if(S.top==0){        printf("S is Empty Stack,pop stack failure!\n");    }else{        //2.顶指针向下移动一位        S.top--;        //3.将弹出的结点职位空        DT d;        S.data[S.top+1]=d;        printf("pop success!\n");    }    return S;}

在main.c中的main方法(int main(int argc, const char * argv[]) {})调用此方法,并且进行判断

  #include "StackControl.h"  int main(int argc, const char * argv[]) {     //弹栈    printf("弹栈\n");    SEQSTACK poStack={{'0','a','b','c','d','e'},5};    printfStack(poStack);    poStack=popStack(poStack);    printfStack(poStack);    printf("\n");}

打印结果:

弹栈stack={{a,b,c,d,e},top=5}pop success!stack={{a,b,c,d},top=4}

3.5读栈

读出指栈S的栈顶结点数据,并返回结点数据
在StackControl.h写出方法声明

/* 读栈 */DT getStack(SEQSTACK S);

在StackControl.c中实现此方法

DT getStack(SEQSTACK S){    DT  t;    //1.判断栈是否为空栈    if(S.top==0){        printf("stack is  empty,get stack failure\n");    }else{        t=S.data[S.top];        printf("get stack success!\n");    }    return t;}

在main.c中的main方法(int main(int argc, const char * argv[]) {})调用此方法,并且进行判断

  #include "StackControl.h"  int main(int argc, const char * argv[]) {      //读栈    printf("读栈\n");    SEQSTACK gStack={{'0','a','b','c','d','e'},5};    printfStack(gStack);    DT t=getStack(gStack);    printf("读取的数据是:%c\n",t);    printf("\n");}

打印结果:

读栈stack={{a,b,c,d,e},top=5}get stack success!读取的数据是:e

3.6置空栈

置指定栈S为空栈,即删除栈中所有结点
在StackControl.h写出方法声明

/* 置空栈 */SEQSTACK  setEmptyStack(SEQSTACK S);

在StackControl.c中实现此方法

SEQSTACK  setEmptyStack(SEQSTACK S){    if(S.top==0){        return S;    }    //1.循环执行弹栈    do{       //栈顶指针向下移动        S.top--;    }while(S.top>0);    printf("置栈空success!\n");    return S;}

在main.c中的main方法(int main(int argc, const char * argv[]) {})调用此方法,并且进行判断

  #include "StackControl.h"  int main(int argc, const char * argv[]) {     //置空栈    printf("置空栈\n");    SEQSTACK setStack={{'0','a','b','c','d','e'},5};    printfStack(setStack);    setStack=setEmptyStack(setStack);    int isEmpty=isEmptyStack(setStack);    if(isEmpty==1){        printf("S是空栈\n");    }else{        printf("S不是空栈");    }    printf("\n");}

打印结果:

置空栈stack={{a,b,c,d,e},top=5}置栈空success!S是空栈

3.7求栈的长度

计算栈中结点数
在StackControl.h写出方法声明

/* 求栈长度 */int  getLengthStack(SEQSTACK S);

在StackControl.c中实现此方法

int  getLengthStack(SEQSTACK S){    //1.判断是否为空栈,则长度是0    if(S.top==0){        return 0;    }    //栈顶指针是数据的下表,那么长度就是S.top    return S.top;}

在main.c中的main方法(int main(int argc, const char * argv[]) {})调用此方法,并且进行判断

  #include "StackControl.h"  int main(int argc, const char * argv[]) {    //求栈的长度    printf("求栈长度\n");     SEQSTACK lenStack={{'0','a','b','c','d','e'},5};    int  length=getLengthStack(lenStack);    printf("length=%d",length);    printf("\n");    }

打印结果:

求栈长度length=5

顺序栈应用

十进制转换为二进制
在StackControl.h写出方法声明

/* 十进制转换为二进制 */void doto(int n);

在StackControl.c中实现此方法

void doto(int n){    SEQSTACK NS;    int x=0;     printf("Conversed to Binary %d=",n);    //1.创建一个空栈    NS=createEmptyStack();    if(n==0){        //2.压栈,第一个数据data[0]不参与操作,栈底指针        NS=pussStack(NS, 0);    }    //3.开始计算转换,知道余数为1    while (n) {        //3.1将n/2的余数压入栈中        NS=pussStack(NS, n%2);        //3.2把商赋给n        n=(n-n%2)/2;    }    //4.进行读栈    while (!isEmptyStack(NS)) {        //读栈        x=getStack(NS);        printf("%d",x);        //弹栈        NS=popStack(NS);    }    printf("\n");}

在main.c中的main方法(int main(int argc, const char * argv[]) {})调用此方法,并且进行判断

  #include "StackControl.h"  int main(int argc, const char * argv[]) {    int number=45;    //十进制数据转化二进制    doto(number);  }

打印结果:

Conversed to Binary 45=101101

这是顺序栈基本操作,请大家指点,有好的建议请大家指出,有好的书籍,还往大家推荐!