Classic Abstract Data Types--C

本文内容来自《pointers on C》

/*    Interface for a stack module */
#define STACK_TYPE int

void push(STACK_TYPE value);

void pop(void);

STACK_TYPE top(void);

int is_empty(void);

int is_full(void);

    /* a stack implemented with a dynamically allocated arry*/
    static STACK_TYPE *stack;
    static size_t stack_size;
    static int top_element=-1;
    
    void create_stack(size_t size)
    {
        assert(stack_size==0);
        stack_size=size;
        stack=malloc(stack_size*sizeof(STACK_TYPE));
        assert(stack!=NULL);
    }
    void destroy_stack(void)
    {
        assert(stack_size>0);
        stack_size=0;
        free(stack);
        stack=NULL;
    }

    /*a stack implemented with a linked list*/
    typedef struct STACK_NODE
    {
        STACK_TYPE value;
        struct STACK_NODE *next;

    }StackNode;
    static StackNode *stack;
    
    void destroy_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 *first_node;
        assert(!is_empty());
        first_node=stack;
        stack=first_node->next;//在前面删除
        free(first_node);
    }
    STACK_TYPE top(void)
    {
        assert(is_empty());
        return stack->value;
    }
    int is_empty(void)
    {
        return stack==NULL;
    }
    int is_full(void)
    {
        return FALSE;
    }

/*Interface for a queue module*/
#include<stdlib.h>

#define QUEUE_TYPE int

void create_queue(size_t size);    /*this applies only to the dynamically                                      allocated array implementation*/
void destroy_queue(void);    /*this applies only to the linked and dyn-                                  amically allcoated array implementations.*/
void insert(QUEUE_TYPE value);
void delete(void);
QUEUE_TYPE first(void);
int is_empty(void);
int is_full(void);

    /* A queue implemented with a static array */
#define QUEUE_SIZE 100
#define ARRAY_SIZE (QUEUE_SIZE+1)
    static QUEUE_TYPE queue[ARRAY_SIZE];
    static size_t front=1;
    static size_t rear=0;
    
    void insert(QUEUE_TYPE value)
    {
        assert(!is_full());
        rear=(rear+1)%ARRAY_SIZE;
        queue[rear]=value;
    }
    void delete(void)
    {
        assert(!is_empty());
        front=(front+1)%    ARRAY_SIZE;
    }
    QUEUE_TYPE first(void)
    {
        assert(!is_empty());
        return queue[front];
    }
    int is_empty(void)
    {
        return (rear+1)% ARRAY_SIZE== front;
    }
    int is_full(void)
    {
        return (rear + 2) % ARRAY_SIZE== front;
    }

/* Interface for a binary search tree module*/
#define TREE_TYPE int

void insert(TREE_TYPE value);    /* must not already exist in the tree*/

TREE_TYPE  *find(TREE_TYPE value); /* pass the first argument*/

void pre_order_traverse(void (*callback)(TREE_TYPE value)); /* callback                                                               process node*/

    /* A binary search tree implemented with a static array */
#define TREE_SIZE 100
#define ARRAY_SIZE (TREE_SIZE+1)
    static TREE_SIZE tree[ARRAY_SIZE];

    static int left_child(int current)
    {
        return current*2;
    }
    static int right_child(int current)
    {
        return current*2+1;
    }
    void insert(TREE_TYPE value)
    {
        int current;
        assert(value!=0);    /* zero indicates an unused node */
        current=1;
        while(tree[current]!=0)
        {
            if(value<tree[current])
                current=left_child(current);
            else
            {
                assert(value!=tree[current]);
                current=right_child(current);
            }
            assert(current<ARRAY_SIZE);
        }
        tree[current]=value;
    }
    TREE_TYPE *find(TREE_TYPE value)
    {
        int current;
        current=1;
        while(current<ARRAY_SIZE && tree[current]!=value)
        {
            if(value<tree[current])
                current=left_child(current);
            else
                current=right_child(current);
        }
        if(current<ARRAY_SIZE)
            return tree+current;
        else 
            return 0;
    }
    /* helper function; not a part of the clent‘s interface*/
    static void do_pre_order_traverse(int current,                void (*callback)(TREE_TYPE value))
    {
        if(current<ARRAY_SIZE && tree[current]!=0)
        {
            callback(tree[current]);
            do_pre_order_traverse(left_child(current),callback);
            do_pre_order_traverse(right_child(current),callback);
        }
    }
    void pre_order_traverse(void (*callbace)(TREE_TYPE value))
    {
        do_pre_order_traverse(1,callbace);
    }

    /* A binary search tree implemented by linking dynamically allocated*/
    typedef struct TREE_NODE
    {
        TREE_TYPE value;
        struct TREE_NODE *left;
        struct TREE_NODE *right;
    }TreeNode;
    static TreeNode *tree;
    void insert(TREE_TYPE value)
    {
        TreeNode *current;
        TreeNode **link;//link是指向树节点指针的指针
        link=&tree;
        while((current=*link)!=NULL)
        {
            if(value<current->value)
                link=&current->left;
            else
            {
                assert(value!=current->value);
                link=&current->right;
            }
        }
        current =malloc(sizeof(TreeNode));
        assert(current!=NULL);
        current->value=value;
        current->left=NULL;
        current->right=NULL;
        *link=current;
    }
    TREE_TYPE *find(TREE_TYPE value)
    {
        TreeNode *current;
        current=tree;
        while(current!=NULL && current->value!=value)
        {
            if(value<current->value)
                current=current->left;
            else
                current=current->right;
        }
        if(current!=NULL)
            return &current->value;
        else
            return NULL;
    }
    static void do_pre_order_traverse(TreeNode *current,                void (*callback)(TREE_TYPE value))
    {
        if(current!=NULL)
        {
            callback(current->value);
            do_pre_order_traverse(current->left,callback);
            do_pre_order_traverse(current->right,callback);
        }
    }
    void pre_order_traverse(void(*callback)(TREE_TYPE value))
    {
        do_pre_order_traverse(tree,callback);
    }

/*ADTs of stack*/
#include<assert.h>

#define GENERIC_STACK(STACK_TYPE,SUFFIX,STACK_SIZE)     static STACK_TYPE stack##SUFFIX[STACK_SIZE];     static int top_element##SUFFIX=-1;     int is_empty##SUFFIX(void)     {         return top_element##SUFFIX==-1;     }     int is_full##SUFFIX(void)     {         return top_element##SUFFIX==STACK_SIZE-1;     }     void push##SUFFIX(STACK_TYPE value)     {         assert(!is_full##SUFFIX());         top_element##SUFFIX++;         stack##SUFFIX[top_element##SUFFIX]=value;     }     void pop##SUFFIX(void)     {         assert(!is_empty##SUFFIX());         top_element##SUFFIX--;     }     STACK_TYPE top##SUFFIX(void)     {         assert(!is_empty##SUFFIX());         return stack##SUFFIX[top_element##SUFFIX];     }

/* A client that uses  the generic stack module to create two stacks
   holding defferent types of data
   */
#include<stdlib.h>
#include<stdio.h>
#include"g_stack.h"

GENERIC_STACK(int,_int,10);
GENERIC_STACK(float,_float,5);

int main()
{
    push_int(5);
    push_int(22);
    push_int(15);
    push_int(21);
    push_float(25.4);
    push_float(-20.1);
    while(!is_empty_int())
    {
        printf("popping %d\n",top_int());
        pop_int();
    }
    while(!is_empty_float())
    {
        printf("popping %f\n",top_float());
        pop_float();
    }
    return EXIT_SUCCESS;
}