C和指针 第17章 经典抽象数据类型 17.10 编程练习

已于 2022-11-30 20:01:59 修改
阅读量240 收藏 1
点赞数
分类专栏： C和指针 文章标签： c语言
于 2022-07-14 22:26:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40186813/article/details/125792183
版权
这篇博客介绍了如何使用C语言实现动态分配的堆栈、队列和二叉搜索树。堆栈增加了resize_stack函数，队列模块通过动态数组和链表两种方式实现，同时提供了resize_queue函数。博客还展示了二叉搜索树的插入、查找和遍历操作。
摘要由CSDN通过智能技术生成

1. 在动态分配数组的堆栈模块中增加一个resize_stack函数。这个函数接受一个参数：堆栈的新长度。 
解析： 
#include <stdio.h>
#include <stdlib.h>
#include "stack.h" 

int main( void ){
    STACK_TYPE values[] = { 1, 2, 3, 4, 5 };
    size_t len = sizeof(values) / sizeof(*values);
    size_t i;
    size_t number;
    
    number = 4;
    create_stack( number );
    for( i = 0; i < number; ++i ){
        push( values[i] );
    }
    printf( "print elements in the stack:\n" );
    for( i = 0; i < number; ++i ){
        printf( "%d ", top() );
        pop();
    }
    printf( "\n" );
    destroy_stack();
    resize_stack( 5 );
    for( i = 0; i < len; ++i ){
        push( values[i] );
    }
    printf( "print elements in the stack:\n" );
    for( i = 0; i < len; ++i ){
        printf( "%d ", top() );
        pop();
    }
    printf( "\n" );
    destroy_stack();
    
    return EXIT_SUCCESS;
}

/*
** 动态数组堆栈 stack.h
*/
#include <stddef.h>
#define STACK_TYPE int /*堆栈所存储的值的类型。*/

/*
**create_stack
**创建堆栈。参数指定堆栈可以保存多少个元素。
**注意：这个函数并不用于静态数组版本的堆栈。 
*/ 
void create_stack( size_t size );

/*
**destroy_stack
**销毁堆栈。它释放堆栈所使用的内存。
**注意：这个函数也不用于静态数组版本的堆栈。
*/ 
void destroy_stack( void );

/*
**push
**把一个新值压入到堆栈中。它的参数是需要被压入的值。 
*/
void push( STACK_TYPE value );

/*
**pop
**从堆栈弹出一个值，并将它丢弃。
*/
void pop( void );

/*
**top
**返回堆栈顶部元素的值，但不对堆栈进行修改。
*/
STACK_TYPE top( void );

/*
**is_empty
**如果堆栈为空，返回TRUE，否则返回FALSE。
*/
int is_empty( void );

/*
**is_full
**如果堆栈已满，返回TRUE，否则返回FALSE。
*/
int is_full( void );

/*
**resize_stack
**参数指定堆栈可以重新设置为保存多少个元素。
*/

void resize_stack( size_t size );

/*
**一个用动态分配数组实现的堆栈。 
**堆栈的长度在创建堆栈的函数被调用时给出，该函数必须在任何其他操作堆栈的函数被调用之前调用。
*/
#include "stack.h"
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <assert.h>
/*
**用于存储堆栈元素的数组和指向堆栈顶部元素的指针。 
*/ 
static STACK_TYPE *stack;
static size_t stack_size;
static int top_element = -1;

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

/*
**destroy_stack
*/
void
destroy_stack( void ){
    assert( stack_size > 0 );
    stack_size = 0;
    free( stack );
    stack = NULL;
}

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

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

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

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

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

/*
**resize_stack
**参数指定堆栈可以重新设置为保存多少个元素。
*/
void resize_stack( size_t size ){
    create_stack( size );
}
输出：

2.把队列模块转换为使用动态分配的数组形式，并增加一个resize_queue函数（类似于编程练习1）。
输出： 
#include <stdio.h>
#include <stdlib.h>
#include "queue.h"

int main( void ){
    QUEUE_TYPE values[] = { 1, 2, 3, 4, 5 };
    size_t len = sizeof(values) / sizeof(*values);
    size_t i;
    size_t number;
    
    number = 4;
    create_queue( number );
    for( i = 0; i < number; ++i ){
        insert( values[i] );
    }
    printf( "print elements in the queue:\n" );
    for( i = 0; i < number; ++i ){
        printf( "%d ", first() );
        delete();
    }
    printf( "\n" );
    destroy_queue();
    resize_queue( 5 );
    for( i = 0; i < len; ++i ){
        insert( values[i] );
    }
    printf( "print elements in the queue:\n" );
    for( i = 0; i < len; ++i ){
        printf( "%d ", first() );
        delete();
    }
    printf( "\n" );
    QUEUE_TYPE value;
    value = 5;
    insert( value );
    
    destroy_queue();
    
    return EXIT_SUCCESS;

}

/*queue.h头文件的内容如下：*/
/*
**一个队列模块的接口。
*/#include <stddef.h>
#define QUEUE_TYPE int /*队列元素的类型*/
/*
**创建一个队列，参数指定队列可以存储的元素的最大数量。
**注意：这个函数只适用于使用动态分配数组的队列。
*/
void create_queue( size_t size );

/*
**destroy_queue
**销毁一个队列。注意：这个函数只适用于链式和动态分配数组的队列。
*/
void destroy_queue( void );

/*
**insert
**向队列添加一个新元素，参数就是需要添加的元素。
*/
void insert( QUEUE_TYPE value );

/*
**delete
**从队列中移除1个元素并将其丢弃。 
*/
void delete( void );

/*
**first
**返回队列中第1个元素的值，但不修改队列本身。
*/
QUEUE_TYPE first( void );

/*
**is_empty
**如果队列为空，返回TRUE，否则返回FALSE。 
*/
int is_empty( void );
 
/*
**is_full
**如果队列已满，返回TRUE，否则返回FALSE。 
*/
int is_full( void );

/*
**resize_queue
**重新设置队列的大小。
*/
void resize_queue( size_t size ); 

/* queue.c文件的内容如下：*/
/*
**一个队列模块的接口。 
*/
#include <stddef.h>
#include <malloc.h>
#include <assert.h> 
#include "queue.h"

#define FALSE 0
#define TRUE 1

typedef struct QUEUE_PTR{
    QUEUE_TYPE *front;
    QUEUE_TYPE *rear;
} QueuePtr;

static QUEUE_TYPE *queue;
static QUEUE_TYPE queue_size;
static QueuePtr qp;

/*
**创建一个队列，参数指定队列可以存储的元素的最大数量。
**注意：这个函数只适用于使用动态分配数组的队列。
*/
void create_queue( size_t size ){
    assert( queue_size == 0 );
    queue_size = size;
    queue = (QUEUE_TYPE *)malloc( sizeof(QUEUE_TYPE) * queue_size );
    assert( queue != NULL );
    qp.front = queue;
    qp.rear = queue;
}

/*
**destroy_queue
**销毁一个队列。注意：这个函数只适用于链式和动态分配数组的队列。
*/
void destroy_queue( void ){
    assert( queue_size > 0 );
    queue_size = 0;
    free( queue );
    queue = NULL;
    qp.front = queue;
    qp.rear = queue;
}

/*
**insert
**向队列添加一个新元素，参数就是需要添加的元素。
*/
void insert( QUEUE_TYPE value ){
    assert( !is_full() );
    *qp.rear = value;
    qp.rear = qp.rear + 1;
}

/*
**delete
**从队列中移除1个元素并将其丢弃。 
*/
void delete( void ){
    assert( !is_empty() );
    qp.front = qp.front + 1; 
}

/*
**first
**返回队列中第1个元素的值，但不修改队列本身。
*/
QUEUE_TYPE first( void ){
    assert( !is_empty() );
    return *qp.front;
}

/*
**is_empty
**如果队列为空，返回TRUE，否则返回FALSE。 
*/
int is_empty( void ){
    assert( queue_size > 0 );
    if( qp.front == qp.rear  ){
        return TRUE;
    } else{
        return FALSE;
    }
}
 /*
**is_full
**如果队列已满，返回TRUE，否则返回FALSE。 
*/
int is_full( void ){
    assert( queue_size > 0 );
    if( qp.rear == queue + queue_size ){
        return TRUE;
    } else{
        return FALSE;
    }
}

/*
**resize_queue
**重新设置队列的大小。
*/
void resize_queue( size_t size ){
    create_queue( size );
}
输出：

3.把队列模块转换为链表实现。
解析：
这个转换类似链式堆栈，但是当最后一个元素被移除时，rear指针也必须被设置为NULL。 
#include "queue.h"
#include <stdio.h>
#include <stdlib.h>

int main( void ){
    QUEUE_TYPE values[] = { 1, 2, 3, 4, 5 };
    size_t len = sizeof(values) / sizeof(*values);
    size_t i;
    size_t number;
    
    number = 4;
    for( i = 0; i < number; ++i ){
        insert( values[i] );
    }
    printf( "print elements in the queue:\n" );
    for( i = 0; i < number; ++i ){
        printf( "%d ", first() );
        delete();
    }
    printf( "\n" );
    destroy_queue();
    for( i = 0; i < len; ++i ){
        insert( values[i] );
    }
    printf( "print elements in the queue:\n" );
    for( i = 0; i < len; ++i ){
        printf( "%d ", first() );
        delete();
    }
    printf( "\n" );
    QUEUE_TYPE value;
    value = 6;
    insert( value );
    printf( "print elements in the queue:\n" );
    for( i = 0; i < len + 1; ++i ){
        printf( "%d ", first() );
        delete();
    }
    destroy_queue();
    
    return EXIT_SUCCESS;
}

/*queue.h头文件的内容如下：*/
/*
** 一个用链表形式实现的队列，它没有长度限制。 
*/ 
#define QUEUE_TYPE int

/*
** destroy_queue
*/
void destroy_queue( void );

/*
** insert
*/
void insert( QUEUE_TYPE value );

/*
** delete
*/
void delete( void );

/*
** first
*/
QUEUE_TYPE first( void );

/*
** is_empty
*/
int is_empty( void );
/*
** is_full
*/
int is_full( void );

/* queue.c文件的内容如下：*/
/*
** 一个用链表形式实现的队列，它没有长度限制。 
*/ 
#include "queue.h" 
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

/*
** 定义一个结构用于保存一个值。link字段将指向队列中的下一个节点。 
*/
typedef struct QUEUE_NODE{
    QUEUE_TYPE value;
    struct QUEUE_NODE *next; 
} QueueNode;

/*
** 指向队列第1个和最后一个节点的指针。 
*/ 
static QueueNode *front;
static QueueNode *rear;

/*
** destroy_queue
*/ 

void destroy_queue( void ){
    while( !is_empty() ){
        delete();
    }
}

/*
** insert
*/
void insert( QUEUE_TYPE value ){
    QueueNode *new_node;
    
    /*
    ** 分配一个新节点，并填充它的各个字段。 
    */    
    new_node = (QueueNode *)malloc( sizeof(QueueNode) );
    assert( new_node != NULL );
    new_node->value = value;
    new_node->next = NULL;
    
    /*
    ** 把它插入到队列的尾部。 
    */ 
    if( rear == NULL ){
        front = new_node;
    } else{
        rear->next = new_node;
    }
    rear = new_node;
}

/*
** delete
*/
void delete( void ){
    QueueNode *next_node;
    
    /*
    ** 从队列的头部删除一个节点，如果它是最后1个节点，
    ** 将rear也设置为NULL。
    */
    assert( !is_empty() );
    next_node = front->next;
    free( front );
    front = next_node;
    if( front == NULL ){
        rear = NULL;
    } 
}

/*
** first
*/
QUEUE_TYPE first( void ){
    assert( !is_empty() );
    return front->value;
}

/*
** is_empty
*/
int is_empty( void ){
    return front == NULL;
}

/*
** is_full
*/
int is_full( void ){
    return 0;
}
输出：

4.堆栈，队列和树模型如果可以处理超过一个的堆栈、队列和树，它们会更加实用。修改动态数组堆栈模型，使它最多可以10个不同的堆栈。此时需要修改堆栈函数的接口，使它们接受另一个参数---需要使用的堆栈的索引。 
解析： 
/*
**一个使用泛型堆栈模块创建两个容纳不同类型数据的堆栈的用户程序
*/
#include <stdlib.h>
#include <stdio.h>
#include "stack.h"

/*
**创建三个堆栈，两个用于容纳整数，另一个用于容纳浮点值。
*/
GENERIC_STACK( int, _int, 10, _1 )
GENERIC_STACK( int, _int, 10, _2 )
GENERIC_STACK( float, _float, 5, _1 )

int main( void ) {
    /*
    **往每个堆栈压入几个值。 
    */
    create_stack_int_1();
    push_int_1( 5 );
    push_int_1( 22 );
    push_int_1( 15 );
    
    create_stack_int_2();
    push_int_2( 6 );
    push_int_2( 23 );
    push_int_2( 16 );
    
    create_stack_float_1();
    push_float_1( 25.3 );
    push_float_1( -40.5 );
    
    /*
    **清空第一个整数堆栈并打印这些值。 
    */
    while( !is_empty_int_1() ){
        printf( "Popping %d\n", top_int_1() );
        pop_int_1();
    }
    destroy_stack_int_1();
    
    /*
    **清空第二个整数堆栈并打印这些值。 
    */
    while( !is_empty_int_2() ){
        printf( "Popping %d\n", top_int_2() );
        pop_int_2();
    } 
    destroy_stack_int_2();
    
    /*
    **清空浮点数堆栈并打印这些值。
    */
    while( !is_empty_float_1() ){
        printf( "Popping %f\n", top_float_1() );
        pop_float_1();
    } 
    destroy_stack_float_1();
    
    return EXIT_SUCCESS;
} 

/* stack.

最低0.47元/天 解锁文章
weixin_40186813
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C和指针第十七章编程练习
16的博客
03-30 169
17.10.1 void resize_stack(size_t size) { assert(stack != NULL); stack_size = size; realloc(stack, sizeof(STACK_TYPE) * size); assert(stack != NULL); } 17.10.2 接口 #include <stdio.h> #include <stdlib.h> #include <assert.h>
C和指针 第十七章 习题
weixin_30653097的博客
09-18 176
17.8 为数组形式的树编写模块，用于从树中删除一个值，如果没有找到，程序节点 ArrayBinaryTree.c // // Created by mao on 16-9-18. // #include "ArrayBinaryTree.h" #include <assert.h> #include <stdio.h> unsign...
c和指针 十七章课后练习 ：链式二叉树 及其拓展功能
qq_57065913的博客
07-18 74
#include <stdio.h> #include<assert.h> #include<stdlib.h> #define TREE_TYPE int typedef struct tree{ struct tree *left; struct tree *right; TREE_TYPE value; } Treelist; void insert(TREE_TYPE value);//1 Treelist** find(TREE_TY..
C和指针读书笔记-第17章（经典抽象数据类型）
欢迎来到饭没了吃的博客
04-28 463
1.为ADT分配内存有三种技巧：静态数组、动态分配的数组和动态分配的链式结构。静态数组对结构施加预先确定固定长度的这个限制。动态数组的长度可以再运行时计算，如果需要数组也可以进行重新分配。链式结构对值的最大数量并未加以任何限制。 2.
C和指针 第17章 经典数据类型 17.5 实现的改进
weixin_客子光阴的博客
07-14 203
C和指针 第17章 经典数据类型 17.5 实现的改进
[C和指针] ch17. 经典抽象数据类型
Y-puyu 的博客
01-11 376
第十七章：经典抽象数据类型 Github 链接：ch17. 经典抽象数据类型 抽象数据类型 (ADT) 是非常常用的，最为常见的就是数组、顺序表、链表、栈和队列等等。诸如 OS 内部的任务调度有队列、双向链表、红黑树等均被广泛应用。熟练掌握各种数据结构是非常重要且必要的。 本章总结及注意点 部分课后习题解答 17.9 问题 栈。 队列。 当然可以。程序员封装即可。top() 取栈顶元素但不进行栈顶元素的出栈，pop() 函数进行栈顶元素的出栈。 并不觉得有多强大。对于静态数组模拟的堆
C语言经典书籍 ---《Pointers On C》C与指针
qq_73472828的博客
04-12 489
注释并不能真正将代码从源文件中删除（/**/）more从逻辑上删除C代码——#if指令#if 0statements#endif在#if和#endif之间的程序段可以去除格式化输入与输出非格式化输入与输出printfputcharscanfgetchar1.在scanf函数的3前未加more2.==与=环境功能翻译源代码被转换为可执行的机器指令执行实际执行码关键字[https://blog.csdn.net/CSDN2133/article/details/122010384?
第十七章 高级数据表示
KaraShok的博客
07-25 837
文章目录17.1 研究数据表示 17.1 研究数据表示
17_第十七章_模型压缩、加速及移动端部署1
08-03
在深度学习领域，模型压缩与加速以及移动端部署是至关重要的环节，因为它们直接影响到模型的实际应用性能和资源占用。本章将探讨模型压缩的原理、方法以及在移动端部署的策略。 17.1 模型压缩理解：模型压缩主要是...
机明自动编程企业标准版v17.10.31.0
12-16
机明自动编程企业标准版v17.10.31.0，机明自动编程企业标准版v17.10.31.0
第十七章_模型压缩、加速及移动端部署1
08-03
深度学习模型在现代人工智能应用中扮演着至关重要的角色，但其巨大的计算和内存需求限制了在资源受限设备上的部署，比如智能手机和平板电脑。模型压缩和加速成为了克服这一挑战的关键技术。 17.1 模型压缩理解 模型...
Ubuntu-17.10-desktop-amd64.ios
12-21
Linux系统Ubuntu17.10桌面版镜像，可以直接安装在虚拟机上。
ubuntu17.10安装docker-ce的方法
09-30
在Ubuntu 17.10上安装Docker CE（Community Edition）是开发者和系统管理员常用的操作，因为Docker CE提供了轻量级的容器化平台，便于部署和管理应用程序。以下是详细的步骤，确保在Ubuntu 17.10上顺利安装Docker CE...
《c和指针》——目录
changqiang08的专栏
07-24 1054
目录 　　第1章　快速上手　 　　1.1　简介　 　　1.1.1　空白和注释　 　　1.1.2　预处理指令　 　　1.1.3　main函数　 　　1.1.4　read_column_numbers函数　 　　1.1.5　rearrange函数　 　    1.2　补充说明　 　　1.3　编译　 　　1.4　总结
C语言：高级IO
m0_58233509的博客
08-10 445
man手册7章是在将机制。------- EINTR：（error interrupt）是阻塞的系统调用，动作非常的慢，这个过程被信号打断了，但并不是操作失败，故是个假错。----------EAGAIN.(error again) 是非堵塞的调用，表示，尝试去做了，但是现在没有数据，并不是真的出错了（并不是当前系统调用函数的问题）。
ccfcsp202312
weixin_51503393的博客
08-11 650
在某些时刻，密码可以由以下方式计算:对于给定的指令区间[l,r]，对初始为空的队列依次执行第l~r条指令，将得到的队列里的所有矩阵从头到尾相乘，并将乘积矩阵中的所有元素对 998244353取模，得到的矩阵即为密码;你的程序首先读取到所有的类别及其上级次级关系，以及每个类别的权重。1.对于每一个类别，统计它和其全部后代类别的权重之和，同时统计其余全部类别的权重之和，并求二者差值的绝对值， 计为w;给定n条指令，编号为1~n，其中每条指令都是对一个双端队列的操作，队列中的元素均为2x2的矩阵;
C语言 | Leetcode C语言题解之第327题区间和的个数
最新发布
m0_59237910的博客
08-11 219
C语言 | Leetcode C语言题解之第327题区间和的个数
eric 6 17.10
09-24
Eric 6 17.10指的是Eric今年6岁，生日是在10月17日。 对于一个6岁的孩子来说，这是他的黄金时期，他正在经历着许多重要的身体和认知发展。在这个年龄段，孩子开始进一步掌握语言技能，能够更好地表达自己的想法和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

weixin_40186813

你的能量无可限量。

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

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

打赏作者

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

抵扣说明：

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

余额充值