数据结构-栈

栈：只有一个出入口的表结构，先进后出，FILO表

栈顶操作

一、顺序栈

• 数据项：

存储元素的内存首地址

栈的容量

栈顶位置

• 运算：

创建、销毁、入栈、出栈、栈顶、栈空、栈满、数量

• 栈相关的概念：假设栈容量为cal

空增栈：

top: 0开始  先入栈，再top++，存储地址由低到高

满增栈：

top: -1开始  先top++，再入栈，存储地址由低到高

空减栈：

top: cal-1开始  先入栈，再top--，存储地址由高到低

满减栈：

top: cal开始  先top--，再入栈，存储地址由高到低

栈类型	解释	出入栈操作
满增栈	-1开始，栈顶不为空，存储地址由低到高	入栈：top++，入栈数据 出栈：出栈数据, top - -
满减栈	cal开始，栈顶不为空，存储地址由高到低	入栈：top - -，入栈数据 出栈：出栈数据，top++
空增栈	0开始，栈顶为空，存储地址由低到高	入栈：入栈数据，top++ 出栈：top - -，出栈数据
空减栈	cal-1开始，栈顶为空，存储地址由高到低	入栈：入栈数据，top- - 出栈：top++，出栈数据

• array_stack(顺序栈)（空增栈）

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

#define TYPE int

//    设计顺序栈结构
typedef struct ArrayStack
{
    TYPE* ptr;    
    size_t cal;        //    容量
    size_t top;        //    栈顶位置 指向即将要入栈的位置
}ArrayStack;

//    创建
ArrayStack* create_array_stack(size_t cal)
{
    //    为顺序栈结构分配内存
    ArrayStack* stack = malloc(sizeof(ArrayStack));
    //    为存储数据元素分配内存
    stack->ptr = malloc(sizeof(TYPE)*cal);
    stack->cal = cal;
    stack->top = 0;
    return stack;
}

//    销毁
void destroy_array_stack(ArrayStack* stack)
{
    free(stack->ptr);
    free(stack);
}

//    栈空
bool empty_array_stack(ArrayStack* stack)
{
    return !stack->top;    
}

//    栈满
bool full_array_stack(ArrayStack* stack)
{
    return stack->top >= stack->cal;
}

//    入栈
bool push_array_stack(ArrayStack* stack,TYPE data)
{
    if(full_array_stack(stack)) return false;
    stack->ptr[stack->top++] = data;
    return true;
}

//    出栈
bool pop_array_stack(ArrayStack* stack)
{
    if(empty_array_stack(stack)) return false;
    stack->top--;
    return true;
}

//    栈顶
bool top_array_stack(ArrayStack* stack,TYPE* data)
{
    if(empty_array_stack(stack)) return false;
    *data = stack->ptr[stack->top-1];
    return true;
}

//    数量
size_t size_array_stack(ArrayStack* stack)
{
    return stack->top;
}

//    练习 判断b是否是出栈序列
bool is_pop(const int* a,const int* b,size_t len)
{
    //    创一个栈
    ArrayStack* stack = create_array_stack(len);
    //    按a的顺序入栈
    for(int i=0,j=0; i<len; i++)
    {
        push_array_stack(stack,a[i]);
        //    判断栈顶是否可以按照b顺序出栈
        int val_top = 0;
        while(top_array_stack(stack,&val_top) && val_top == b[j])
        {
            pop_array_stack(stack);
            j++;
        }
    }
    //    判断是否为空
    bool flag = empty_array_stack(stack);
    destroy_array_stack(stack);
    return flag;
}

int main(int argc,const char* argv[])
{
    int a[5] = {1,2,3,4,5};
    int b[5] = {1,2,3,4,5};
    printf("%d\n",is_pop(a,b,5));
    /*
    ArrayStack* stack = create_array_stack(10);
    for(int i=0; i<20; i++)
    {
        if(push_array_stack(stack,i+1))
        {
            int num = -100;
            top_array_stack(stack,&num);
            printf("top:%d size:%d\n",num,size_array_stack(stack));
        }
    }
    printf("----------------\n");
    while(!empty_array_stack(stack))
    {
        int num = -100;
        top_array_stack(stack,&num);
        printf("top:%d size:%d\n",num,size_array_stack(stack));
        pop_array_stack(stack);
    }
    */
}

常见的栈的笔试题

1、某序列为入栈序列，判断哪个序列为正确\不正确的出栈序列

入栈： 1 2 3 4 5        a

出栈： 1 2 3 4 5 yes

3 2 1 5 4 yes

5 4 2 1 3 no

2、实现一个函数，判断序列b是否是序列a的出栈序列

3、两个顺序栈，如何安排入栈方向可以让内存使用率最大化？

让两个顺序栈相邻，且入栈方向相对入栈，能够让内存空间利用率最大化

二、链式栈

• 数据项：

栈顶指针

节点数量

• 运算：

创建、销毁、入栈、出栈、栈顶、栈空、数量

• list_stack 链式栈

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

//    链式栈

#define TYPE int

//    节点结构
typedef struct Node
{
    TYPE data;
    struct Node* next;
}Node;

//    创建节点
Node* create_node(TYPE data)
{
    Node* node = malloc(sizeof(Node));
    node->data = data;
    node->next = NULL;
    return node;
}

//    设计链式栈
typedef struct ListStack
{
    Node* top;        //    指向栈顶指针
    size_t size;    //    栈的节点数量
}ListStack;

//    创建栈
ListStack* create_list_stack(void)
{
    ListStack* stack = malloc(sizeof(ListStack));
    stack->top = NULL;
    stack->size = 0;
    return stack;
}
//    栈空
bool empty_list_stack(ListStack* stack)
{
    return 0 == stack->size;
}
//    入栈
void push_list_stack(ListStack* stack,TYPE data)
{
    Node* node = create_node(data);
    node->next = stack->top;
    stack->top = node;
    stack->size++;
}
//    出栈
bool pop_list_stack(ListStack* stack)
{
    if(empty_list_stack(stack)) return false;

    Node* temp = stack->top;
    stack->top = temp->next;
    free(temp);
    stack->size--;
    return true;
}
//    栈顶
TYPE top_list_stack(ListStack* stack)
{
    return stack->top->data;
}
//    节点数
size_t size_list_stack(ListStack* stack)
{
    return stack->size;
}
//    销毁栈
void destroy_list_stack(ListStack* stack)
{
    while(pop_list_stack(stack))
    free(stack);
}

int main(int argc,const char* argv[])
{
    ListStack* stack = create_list_stack();
    for(int i=0; i<10; i++)
    {
        push_list_stack(stack,i+1);
        printf("top:%d size:%d\n",
            top_list_stack(stack),size_list_stack(stack));
    }
    printf("----------------\n");
    /*
    while(!empty_list_stack(stack))
    {
        printf("top:%d size:%d\n",
            top_list_stack(stack),size_list_stack(stack));
        pop_list_stack(stack);
    }
    */
    destroy_list_stack(stack);
}