顺序栈的表示和实现

// 2014年4月16日
// 顺序栈的表示和实现

// tag_stack_t 的数据格式
//
// size             栈的大小
//         [data]
// top  -> [data]   栈顶
//         [data]   第一个节点
//         [data]
// base -> [data]   栈底


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <time.h>


typedef int element_t;

typedef struct tag_stack_t
{
    size_t    size;
    element_t *top;
    element_t *base;
} *stack_t;

// 初始化一个只有一个节点的栈
// 符合栈已满的判断条件，这是一个满了的栈
void stack_init(stack_t& stack)
{
    stack = (stack_t)malloc(sizeof(tag_stack_t));
    stack->base = (element_t *)malloc(sizeof(element_t));
    stack->top = stack->base;
    stack->size = 1;
}

void stack_destroy(stack_t& stack)
{
    free(stack->base);
    free(stack);
    stack = 0;
}

bool stack_is_empty(stack_t& stack)
{
    return stack->top == stack->base;
}

bool stack_is_full(stack_t& stack)
{
    return stack->top == stack->base + stack->size;
}

void stack_push(stack_t& stack, element_t e)
{
    if (stack_is_full(stack))
    {
        // 栈已满，大小增长一倍
        size_t size = stack->size << 1;
        stack->base = (element_t *)realloc(stack->base,
                                           size * sizeof(element_t));
        stack->top = stack->base + stack->size;
        stack->size = size;
    }

    // 栈顶指针指向的位置是空的，先放进去，再更新栈顶指针
    *stack->top = e;
    ++stack->top;
}

bool stack_pop(stack_t& stack, element_t& e)
{
    if (stack_is_empty(stack))
    {
        return false;
    }

    // 栈顶指针指向的位置是空的，先更新栈顶指针，再取出数据
    --stack->top;
    e = *stack->top;

    return true;
}

void print(stack_t& stack)
{
    for (element_t *p = stack->top - 1; p >= stack->base; --p)
    {
        printf("%02d ", *p);
    }
    printf("\n");
}

int range(int a, int b)
{
    return rand()%b + a;
}


int main()
{
    int n = 10;
    int size = 20;

    srand((unsigned)time(0));

    while (n--)
    {
        stack_t stack;

        stack_init(stack);

        // 随机入栈
        int a = range(1, size);
        while (a--)
        {
            int i = range(1, 10);
            stack_push(stack, i);
            print(stack);
        }

        // 随机出栈
        int b = range(1, size);
        while (b--)
        {
            int i = range(1, 10);
            if (!stack_pop(stack, i))
            {
                break;
            }

            print(stack);
        }

        stack_destroy(stack);
    }

    return 0;
}