C和指针：第十七章：经典抽象数据类型

于 2021-05-24 12:05:39 发布
阅读量96 收藏
点赞数
分类专栏： C和指针 文章标签： c语言 链表 二叉树 堆栈 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/py431382/article/details/117221171
版权

第十七章：经典抽象数据类型

  1. 堆栈实现

    /*接口声明 stack.h*/
#define STACK_TYPE int

void push(STACK_TYPE value);
void pop( void );
STACK_TYPE top(void );
STACK_TYPE top( void );
int is_empty( void );
int is_full( void );


/*静态数组实现 stack.c*/
#include "stack.h"
#include <assert.h>

#define STACK_SIZE 100

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()
{
    assert( is_empty());
    top_element -= 1;
}

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

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

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


/*动态数组实现 stack.c*/
#include "stack.h"
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>

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 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;
}

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

void pop()
{
    assert( is_empty());
    top_element -= 1;
}

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

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


/*链表实现 stack.c*/
#include "stack.h"
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>

#define FALSE 0

typedef struct STACK_NODE
{
    struct STACK_NODE *next;
    STACK_TYPE value;
} StackNode;

/*链头*/
static StackNode *stack;

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));
    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;
}

  2. 队列实现

    /*队列接口 queue.h*/
#include <stdlib.h

#define  QUEUE_TYPE int

void create_queue(size_t size);
void destroy_queue(void);
void insert(QUEUE_TYPE value);
void delete(void);
QUEUE_TYPE first(void);
int is_empty(void );
int is_full(void );

/*使用不完全数组技巧，静态数组实现队列*/
#include "queue.h"
#include <stdio.h>
#include <assert.h>

#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;
}

  3. 二叉树实现

    /*二叉树接口 tree.h*/
#define TREE_TYPE int

void insert(TREE_TYPE value);
TREE_TYPE *find(TREE_TYPE value);

/*参数为回调函数指针*/
void pre_order_traverse(void (*callback)(TREE_TYPE value));
void mid_order_traverse(void (*callback)(TREE_TYPE value));
void back_order_traverse(void (*callback)(TREE_TYPE value));


/*静态数组实现 tree.c*/
#include "tree.h"
#include <assert.h>
#include <stdio.h>

#define TREE_SIZE 100
#define ARRAY_SIZE (TREE_SIZE + 1)

static TREE_TYPE 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);
    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;
}

/*递归实现前序遍历*/
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 (*callback)(TREE_TYPE value))
{
    do_pre_order_traverse(1,callback);
}

/*递归实现中序遍历*/
static void do_mid_order_traverse(int current, void (*callback)(TREE_TYPE value))
{
    if (current < ARRAY_SIZE && tree[current] != 0)
    {
        do_mid_order_traverse(left_child(current),callback);
        callback(tree[current]);
        do_mid_order_traverse(right_child(current),callback);
    }
}

void mid_order_traverse(void (*callback)(TREE_TYPE value))
{
    do_mid_order_traverse(1,callback);
}

/*递归实现后序遍历*/
static void do_last_order_traverse(int current, void (*callback)(TREE_TYPE value))
{
    if (current < ARRAY_SIZE && tree[current] != 0)
    {
        do_last_order_traverse(left_child(current),callback);
        do_last_order_traverse(right_child(current),callback);
        callback(tree[current]);
    }
}

void last_order_traverse(void (*callback)(TREE_TYPE value))
{
    do_last_order_traverse(1,callback);
}


/*链表实现二叉树*/
#include "tree.h"
#include <assert.h>
#include <stdio.h>
#include <malloc.h>

typedef struct TREE_NODE
{
    TREE_TYPE value;
    struct TREE_NODE *left;
    struct TREE_NODE *right;
} Tree_Node;


static Tree_Node *tree;

void insert( TREE_TYPE value)
{
    Tree_Node *current;
    Tree_Node **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(TREE_NODE));
    assert(current != NULL);
    current->value = value;
    current->left = NULL;
    current->right = NULL;
    *link = current;
}

TREE_TYPE * find(TREE_TYPE value)
{
    Tree_Node *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;
}

void do_pre_order_traverse(Tree_Node *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);
}
ColaForced
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ColaForced

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值