【数据结构】栈（初始化，入栈，出栈，扩容，获取栈顶元素，检测栈是否为空有效元素长度，销毁栈）

1、栈的特性

一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。

 

进行数据插入和删除操作的一端 称为栈顶，另一端称为栈底。 栈中的数据元素遵守后进先出 的原则。

 

 

 

//函数的声明

#pragma once

typedef int DataType;

typedef struct Stack{
    DataType* array;
    int capacity;
    int size;
}Stack;

//栈的初始化
void StackInit(Stack* ps);

//入栈
void StackPush(Stack* ps, DataType data);

//出栈
void StackPop(Stack* ps);

//获取栈顶元素
DataType StackTop(Stack* ps);

//获取栈中有效元素的个数
int StackSize(Stack* ps);

//检测栈是否为空
int StackEmpty(Stack* ps);

//销毁栈
void StackDestory(Stack* ps);


void StackTest();

 

// 函数的实现

#include "Stack.h"
#include <assert.h>
#include <malloc.h>
#include <stdlib.h>
#include <stdio.h>


//栈的初始化
void StackInit(Stack* ps)
{
    //检测数据
    assert(ps);
    //申请动态空间
    ps->array = (DataType*)malloc(sizeof(DataType)*10);  //注意*10，不然是只申请一个字节的空间
    ps->capacity = 10;
    ps->size = 0;
}

void CheckCapacity(Stack* ps)
{
    assert(ps);
    if (ps->size >= ps->capacity)
    {
        //申请新空间
        int newCapacity = ps->capacity * 2;
        DataType* temp = (DataType*)malloc(sizeof(DataType)*newCapacity);

        //拷贝元素
        if (temp)
        {
            //memcpy(temp, ps->array, sizeof(DataType)*ps->capacity));
            for (int i = 0; i < ps->size; ++i)
                temp[i] = ps->array[i];

            //释放空间
            free(ps->array);
            ps->array = temp;
            ps->capacity = newCapacity;
        }
    }
}


//入栈
void StackPush(Stack* ps, DataType data)
{
    //检测数据
    assert(ps);

    //是否扩容
    CheckCapacity(ps);

    //给ps->array的size插入数据，然后栈顶++

    ps->array[ps->size] = data;
    ps->size++;
}

//出栈
void StackPop(Stack* ps)
{
    assert(ps);
    //检测栈中是否还有元素
    if (StackEmpty(ps))
        return;
    ps->size--;
}

//获取栈顶元素
DataType StackTop(Stack* ps)
{
    assert(ps);
    return ps->array[ps->size - 1];
}

//获取栈中有效元素的个数
int StackSize(Stack* ps)
{
    assert(ps);
    return ps->size;
}

//检测栈是否为空
int StackEmpty(Stack* ps)
{
    assert(ps);

    //空：返回真值，非空：返回假值
    return 0 == ps->size;

}

//销毁栈
void StackDestory(Stack* ps)
{
    assert(ps);
    free(ps->array);
    ps->capacity = 0;
    ps->size = 0;
}

// 测试函数

void StackTest()
{
    Stack s;
    StackInit(&s);

    StackPush(&s, 1);
    StackPush(&s, 2);
    StackPush(&s, 3);
    StackPush(&s, 4);
    StackPush(&s, 5);
    StackPush(&s, 6);
    printf("Size:%d\n", StackSize(&s));
    printf("Top:%d\n", StackTop(&s));

    StackPop(&s);
    StackPop(&s);
    StackPop(&s);
    printf("Size:%d\n", StackSize(&s));
    printf("Top:%d\n", StackTop(&s));

    StackDestory(&s);
}



//测试函数

#include "Stack.h"
#include <stdlib.h>

int main()
{
    StackTest();
    system("pause");
    return 0;
}