C语言抽象数据类型(ADT：abstract data type)之堆栈的三种实现

所有ADT都要确定的一件事：如何获取内存来存储值，C语言有三种方案

静态数组 要求结构长度固定，编译时就要确定，最简单最不易出错

动态数组 运行时才分配，如有需要，可以通过分配一个更大的新的数组，复制原来的值到新数组中，删除原先的数组，达到动态改变数组长度的目的

链式结构 很灵活，但链接字段要消耗内存，访问一个特定的元素的效率不如数组

C语言实现堆栈

定义一个堆栈模块的接口

#define STACK_TYPE int

void push( STACK_TYPE value);

void pop( void );

STACK_TYPE top( void );

int is_empty( void );

int is_full( void );

1、使用静态数组实现的堆栈

#include "stack.h"
#include <assert.h>

#define STACK_SIZE 100

//所有不属于外部接口的内容都定义为static

static STACK_TYPE stack[STACK_SIZE];
static int        top_element = -1;

void 
push(STACK_TYPE value)
{
     assert( !is_full() );
     top_element+=1;
     stack[top_element] = value;
}

void pop(void)
{
     assert( !is_empty() );
     top_element-=1;//不需要删除旧值，减少指针就好了
}

STACK_TYPE top(void)
{
     assert( !is_empty() );
     return stack[top_element];
}

int is_empty(void)
{
     return top_element == -1;
}

int is_full(void)
{
     return top_element == STACK_SIZE-1;
}

2、使用动态数组实现的堆栈

此时要在接口中添加两个新的函数

void create_stack(size_t size);

void destory_stack(void);

新的实现

#include "stack.h"
#include <assert.h>
#include <stdio.h>
#include <mallco.h>
#include <stdlib.h>

//所有不属于外部接口的内容都定义为static

static STACK_TYPE *stack;
static int        top_element = -1;
static size_t     stack_size;

void create_stack(size_t size)
{
     assert(size==0);
     stack_size=size;
     stack = malloc(sizeof(STACK_TYPE)*stack_size);
     assert(stack==NULL);
}

void destory_stack(void)
{
     assert(stack_size > 0);
     stack_size=0;
     free(stack);
     stack==NULL;
}

void push(STACK_TYPE value)
{
     assert( !is_full() );
     top_element+=1;
     stack[top_element] = value;
}

void pop(void)
{
     assert( !is_empty() );
     top_element-=1;//不需要删除旧值，减少指针就好了
}

STACK_TYPE top(void)
{
     assert( !is_empty() );
     return stack[top_element];
}

int is_empty(void)
{
     assert(stack_size>0);
     return top_element == -1;
}

int is_full(void)
{
     assert(stack_size>0);
     return top_element == STACK_SIZE-1;
}

3、用链表实现堆栈

接口中不再需要create_stack函数

#include "stack.h"
#include <assert.h>
#include <stdio.h>
#include <mallco.h>
#include <stdlib.h>

#define FALSE 0

typedef stack STACK_NODE{
        STACK_TYPE  value;
        struct STACK_NODE *next;
}StackNode;
//所有不属于外部接口的内容都定义为static

static StackNode* stack;
static int        top_element = -1;
static size_t     stack_size;

void create_stack(size_t size)
{

}

void destory_stack(void)
{
     while( !is_empty() )
          pop();
}

void push(STACK_TYPE value)
{
     StackNode *new_node;
    
     new_node = malloc(sizeof(StackNode));
     assert( new_node != NULL);
     new_node->value = value;
     new_node->next = stack;
     stack = new_node;
}

void pop(void)
{
     StackNode *tem_Node;
     assert( !is_empty() );
     tem_Node = stack;
     stack = stack->next;
     tem_Node->next = NULL;
     free(tem_Node);
}

STACK_TYPE top(void)
{
     assert( !is_empty() );
     return stack->value;
}

int is_empty(void)
{
     return stack==NULL;
}

int is_full(void)
{
     return FALSE;
}