数据结构——顺序栈

栈的定义

      栈是限定仅在表尾进行插入和删除操作的线性表。因此对栈来说，表尾端有其特殊含义，称为栈顶，相应地，表头端称为栈底。不含元素的空表成为空栈。

       假设栈S=(a1, a2, ......, an),则称a1为栈底元素，an为栈顶元素。栈中元素安a1,a2,.....,an的次序进栈，退栈的第一个元素称为栈顶元素。换句话所，栈的修改是后进先出的原则进行的。因此，栈又称为后进先出(last in first out)的线性表(简称LIFO结构),他的这个特点可以用下图来表示。栈有两种存储表示方法，这里是顺序栈

栈结构定义

typedef struct {
    int * base; //在栈构造之前和销毁之后，base的值为NULL
    int * top; //栈顶指针
    int stacksize;  //当前已分配的存储空间， 以元素为单位
}Stack;

栈基本操作

1.初始化一个空栈

void initStack(Stack & s) {
    s.base = (int *)malloc(INIT_STACK_SIZE * sizeof(int));  //动态分配一段连续内存
    if(!s.base){
        printf("动态分配内存失败，程序终止");
        exit(-1);
    }
    s.top = s.base;  //由于是空栈，所以栈顶、栈底指针指向同一个地方
    s.stacksize = INIT_STACK_SIZE;  //初始化空栈的大小
}

2.压栈

void pushStack(Stack & s, int e) {
    if(s.top-s.base == s.stacksize) {    //判断栈是否已满，已满则给原栈增加空间
        s.base = (int *)realloc(s.base, (INIT_STACK_SIZE + STACIINCREMENT)*sizeof(int));
        if(!s.base){
            printf("动态分配内存失败，程序终止");
            exit(-1);
        }
        s.top = s.base + s.stacksize;  
        s.stacksize +=  STACIINCREMENT;
    }
    *s.top ++ = e; //相当于 *s.top = e; s.top++;
}

3.出栈

bool popStack(Stack & s) {
    if(stackEmpty(s)) {
        return false;
    } else{
        s.top--;
        return true;
    }
}

4.判断栈是否为空

bool stackEmpty(Stack & s){
    if(s.top == s.base)
        return true;
    else
        return false;
}

5.遍历

void statckTraverse(Stack s) {
   int range = s.top-s.base;
   for(int i=0; i<range; i++){
        printf("%d ", s.base[i]);
   }
}

7.栈的元素个数

int stackLength(Stack s) {
    return s.top-s.base; //顺序栈在内存中是连续分配，所以栈顶指针减去栈底指针就是元素个数
}

8.返回栈顶元素

bool getTop(Stack s, int & e) {
    if(stackEmpty(s)) {
        return false;
    }
    else {
        e = * --s.top;  //相当于 --s.top; e = *s.top;
        return  true;
    }
}

9.清空栈

void clearStack(Stack & s){
    s.top = s.base;
}

10.销毁站

void destroyStack(Stack & s){
    clearStack(s);
    free(s.base);
}

全部代码

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>

#define INIT_STACK_SIZE 100  //存储空间初始分配量
#define STACIINCREMENT 10  //存储空间分配增量


typedef struct {
    int * base; //在栈构造之前和销魂之后，base的值为NULL
    int * top; //栈顶指针
    int stacksize;  //当前已分配的存储空间， 以元素为单位
}Stack;

void initStack(Stack &);
void pushStack(Stack &, int e);
bool popStack(Stack &);
bool stackEmpty(Stack &);
void statckTraverse(Stack);
int stackLength(Stack);
bool getTop(Stack, int &);
void clearStack(Stack &);
void destroyStack(Stack &);


int main(void) {


    return 0;
}


void initStack(Stack & s) {
    s.base = (int *)malloc(INIT_STACK_SIZE * sizeof(int));
    if(!s.base){
        printf("动态分配内存失败，程序终止");
        exit(-1);
    }
    s.top = s.base;
    s.stacksize = INIT_STACK_SIZE;
}

void pushStack(Stack & s, int e) {
    if(s.top-s.base == s.stacksize) {
        s.base = (int *)realloc(s.base, (INIT_STACK_SIZE + STACIINCREMENT)*sizeof(int));
        if(!s.base){
            printf("动态分配内存失败，程序终止");
            exit(-1);
        }
        s.top = s.base + s.stacksize;
        s.stacksize +=  STACIINCREMENT;
    }
    *s.top ++ = e;
}

bool popStack(Stack & s) {
    if(stackEmpty(s)) {
        return false;
    } else{
        s.top--;
        return true;
    }
}

void statckTraverse(Stack s) {
   int range = s.top-s.base;
   for(int i=0; i<range; i++){
        printf("%d ", s.base[i]);
   }
}

bool stackEmpty(Stack & s){
    if(s.top == s.base)
        return true;
    else
        return false;
}

int stackLength(Stack s) {
    return s.top-s.base;
}

bool getTop(Stack s, int & e) {
    if(stackEmpty(s)) {
        return false;
    }
    else {
        e = * --s.top;
        return  true;
    }
}

void clearStack(Stack & s){
    s.top = s.base;
}

void destroyStack(Stack & s){
    clearStack(s);
    free(s.base);
}