链式栈的表示和实现

// 2014年4月16日
// 链式栈的表示和实现
// 使用头结点保存栈的深度(链表的长度)
// 在单链表的基础上修改一下，不允许随机插入和随机删除
// 入栈和出栈的时候只操作头结点即可

//数据格式
//
// head node         node0          node1         end node
// [data|next] -> [data|next] -> [data|next] ... [data| 0 ]
//


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


typedef int element_t;

typedef struct node_t
{
    element_t   data;
    node_t      *next;
} node_t, *linkstack_t;


void linkstack_init(linkstack_t& stack)
{
    stack = (linkstack_t)malloc(sizeof(node_t));
    stack->next = 0;
    stack->data = 0;
}

void linkstack_clear(linkstack_t& stack)
{
    node_t *p = stack->next;

    while (p != 0)
    {
        node_t *q = p->next;
        free(p);
        p = q;
    }
}

void linkstack_destroy(linkstack_t& stack)
{
    linkstack_clear(stack);
    free(stack);
    stack = 0;
}

bool linkstack_is_empty(linkstack_t& stack)
{
    return 0 == stack->next;
}

// 入栈，直接插入在头结点的后面即可
void linkstack_push(linkstack_t& stack, element_t e)
{
    node_t *p = (node_t *)malloc(sizeof(node_t));
    p->data = e;
    p->next = stack->next;
    stack->next = p;

    ++stack->data;
}

// 出栈，取走头结点后面的那个节点，即最后一个入栈的
bool linkstack_pop(linkstack_t& stack, element_t& e)
{
    if (linkstack_is_empty(stack))
    {
        return false;
    }

    node_t *p = stack->next;
    e = p->data;
    stack->next = p->next;
    free(p);

    --stack->data;

    return true;
}

void print(linkstack_t& stack)
{
    for (node_t *p = stack->next; p != 0; p = p->next)
    {
        printf("%02d ", *p);
    }
    printf("\n");
}

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


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

    srand((unsigned)time(0));

    while (n--)
    {
        linkstack_t stack;

        linkstack_init(stack);

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

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

            print(stack);
        }

        linkstack_destroy(stack);
    }

    return 0;
}