栈: 顺序存储

栈是一种先进后出(First In Last Out,FILO)的数据结构

如果你将两个元素压入栈，先加入的元素将在后加入的元素之后出栈

栈顶元素值为null(未满时)

定义栈的数据结构

#define MAX_SIZE 1024
//利用数组模拟栈的顺序存储
typedef struct sqStack{
    void *data[MAX_SIZE];
    int size; //栈的元素数量
} sqStack;

初始化

sqStack* initStack(){
    sqStack *s = (sqStack*)malloc(sizeof(sqStack));
    for (int i = 0; i < MAX_SIZE; i++){
        s->data[i] = NULL;
    }
    s->size = 0;
    return s;
};

入栈

void PushStack(sqStack *s, void* data){
    if(s==NULL) return; //如果栈为空
    if(s->size==MAX_SIZE) return; //如果栈已满
    if(data==NULL) return; //如果插入数据为null

    s->data[s->size] = data;
    s->size++;
};

返回栈顶元素

void* topSqStack(sqStack *s){
    if(s==NULL) return NULL; 
    if(s->size==0) return NULL;

    return s->data[(s->size-1)]; //第一个元素在栈顶之下
};

弹出栈顶元素

void* PopStack(sqStack *s){
    if(s==NULL) return NULL; 
    if(s->size==0) return NULL; 

    s->data[s->size-1] = NULL; //将元素弹出 
    s->size--; //栈顶下移
};

判断栈是否为空

int ifEmpty_Stack(sqStack *s){
    if(s==NULL) return -1; //SQstack_ERROR
    if(s->size==0) return 1; //SQStack_TRUE
    return 2; //SQStack_FALSE
};

返回栈中的元素个数

int Size_Stack(sqStack *s){
    if(s==NULL) return -1;
    return s->size;
};

清空栈

void clear_Stack(sqStack *s){
    if(s==NULL) return; 
    if(s->size==0) return; 
    for (int i = 0; i < s->size; i++){
        s->data[i] = NULL; //清空所有数据
    }
    s->size=0;
};

销毁栈

void destroy_Stack(sqStack *s){
    if(s==NULL) return;  
    free(s);
};

栈顺序存储的测试

定义栈中元素的数据结构

typedef struct PERSON{
    char name[64];
    int age;
} Person;

测试

int main(){
    //创建栈
    sqStack* stack = initStack();
    //创建数据
    Person p1 = {"aaa",10};
    Person p2 = {"bbb",20};
    Person p3 = {"ccc",30};
    Person p4 = {"ddd",40};
    //进栈
    PushStack(stack, &p1);
    PushStack(stack, &p2);
    PushStack(stack, &p3);
    PushStack(stack, &p4);
    //输出
    while(Size_Stack(stack)>0){
        //访问栈顶元素
        Person* person = (Person*)topSqStack(stack);
        cout << person->name << " " << person->age << endl;
        //弹出栈顶元素
        PopStack(stack);
    }
    //释放内存
    destroy_Stack(stack);

    system("pause");
    return 0;
}

返回元素的顺序与压入的顺序相反(先进后出)