嵌入式（三）----数据结构---顺序栈

顺序栈定义

栈：操作受限的线性表，限定仅在栈顶进行插入和删除操作的线性表，即后进先出。这一端被称为栈顶，相对地，把另一端称为栈底。

顺序栈：用顺序结构存储的栈。

例子：打字框，先打的字，不动光标，只能最后删除，后打的字可以最先删除。

顺序栈的初始化

#ifndef _STACK_H
#define _STACK_H

#include  <stdio.h>
#include  <stdlib.h>
#include  <string.h>
#include  <strings.h>

#define SIZE 100
typedef int data_t;
typedef struct {
    data_t data[SIZE];
    int top;

}stack_t;

stack_t *stack_create();//创建顺序栈
int stack_show(stack_t *stack);//显示顺序栈
int stack_length(stack_t *stack);//求顺序表长度
int stack_is_empty(stack_t *stack);//求顺序表是否为满
int stack_is_full(stack_t *stack);//求顺序表是否为空
int stack_push(stack_t *stack,data_t data);
data_t stack_pop(stack_t *stack);
data_t stack_top(stack_t *stack);
int stack_clear(stack_t *stack);
int stack_destory(stack_t **stack);

#endif

顺序栈功能实现—c语言

创建顺序栈

注意：这里top为data数组的下标，创建时没有data值，所以要为-1；

stack_t *stack_create()
{
    stack_t *stack = (stack_t *)malloc(sizeof(stack_t));
    if(stack == NULL)//判断链表是否创建成功
    {
        return NULL;
    }
    memset(stack->data,0,sizeof(stack->data));
    stack->top = -1;
    return stack;
}

遍历打印顺序栈

这里采用的是从栈底遍历到栈顶

int stack_show(stack_t *stack)//显示顺序栈
{
    
    if(stack == NULL)//判断链表是否创建成功
    {
        return -1;
    }
    for(int i = 0;i<=stack->top;i++)
    {
        printf("%d  ",stack->data[i]);

    }
    putchar('\n');
    return 0;
}

顺序栈长度

top为data数组的下标，返回top+1即为顺序栈的长度。

int stack_length(stack_t *stack)//求顺序表长度
{
    if(stack == NULL)//判断链表是否创建成功
    {
        return -1;
    }
    return stack->top+1;
    
}

判断顺序栈是否为空或满

这里重点在正确返回那里，运用了三目运算的思想，表达式为真返回1，表达式为假返回0；

int stack_is_empty(stack_t *stack)//求顺序表是否为满
{

    if(stack == NULL)//判断链表是否创建成功
    {
        return -1;
    }
    return stack->top == -1;
}
int stack_is_full(stack_t *stack)//求顺序表是否为空
{

    if(stack == NULL)//判断链表是否创建成功
    {
        return -1;
    }
    return stack->top == SIZE-1;
}

顺序栈的入栈

首先判断栈是否存在，然后判断栈是否为满，然后栈顶自加，把data赋值给top，就完成入栈啦。

int stack_push(stack_t *stack,data_t data)
{
    
    if(stack == NULL)//判断链表是否创建成功
    {
        return -1;
    }
    if(stack_is_full(stack))
    {
        return -1;
    }
    stack->top++;
    stack->data[stack->top]=data;
    return 0;
}

顺序栈的出栈

首先判断栈是否存在，然后判断是否为空，然后先保留原top位置的data值，后top自减，完成出栈。

data_t stack_pop(stack_t *stack)
{
    if(stack == NULL)//判断链表是否创建成功
    {
        return (data_t)-1;
    }
    if(stack_is_empty(stack))
    {
        return (data_t)-1;
    }
    int a=stack->data[stack->top];
    stack->top--;
    return a;
}

顺序栈取栈顶元素

判断顺序栈是否存在以及是否为空，之后直接返回栈顶元素即可

data_t stack_top(stack_t *stack)
{

    if(stack == NULL)//判断链表是否创建成功
    {
        return -1;
    }
    if(stack_is_empty(stack))
    {
        return (data_t)-1;
    }
    return stack->data[stack->top];
}

清空顺序栈，摧毁顺序栈

清空顺序栈不需要清空数据，直接将top赋值为-1即可，后面插入数据会自动翻盖以前的值，这不同于链式存储结构，链式存储结构要一个个删除，而且还要一个个释放结点。

int stack_clear(stack_t *stack)
{
    if(stack == NULL)//判断链表是否创建成功
    {
        return -1;
    }
    stack->top=-1;
    return 0;
}
int stack_destory(stack_t **stack)
{
    if(*stack == NULL)//判断链表是否创建成功
    {
        return -1;
    }
    stack_clear(*stack);
    free(*stack);
    *stack=NULL;
}

顺序栈测试

#include "stack.h"

int main(int argc, char *argv[])
{ 
    
    stack_t *stack = (stack_t *)malloc(sizeof(stack_t));
    stack = stack_create();
    if(NULL == stack)
    {
        printf("stack fail ...\n");
        return -1;
    }
    printf("seccess...\n");
    printf("empty=%d\n",stack_is_empty(stack));
    printf("full=%d\n",stack_is_full(stack));
    printf("len=%d\n",stack_length(stack));
    stack_show(stack);
    stack_push(stack,1);
    stack_push(stack,2);
    stack_push(stack,3);
    stack_push(stack,4);
    stack_show(stack);
    printf("empty=%d\n",stack_is_empty(stack));
    printf("full=%d\n",stack_is_full(stack));
    printf("len=%d\n",stack_length(stack));
    printf("%d  ",stack_pop(stack));
    printf("%d  ",stack_pop(stack));
    printf("%d  ",stack_pop(stack));
    putchar('\n');
    printf("empty=%d\n",stack_is_empty(stack));
    printf("full=%d\n",stack_is_full(stack));
    printf("len=%d\n",stack_length(stack));
    stack_clear(stack);
    printf("clear---len=%d\n",stack_length(stack));

    return 0;
} 

测试结果

seccess...
empty=1
full=0
len=0

1  2  3  4  
empty=0
full=0
len=4
4  3  2  
empty=0
full=0
len=1
clear---len=0