数据结构（4）—— 栈、队列代码重构实现

最新推荐文章于 2020-04-11 16:31:06 发布
最新推荐文章于 2020-04-11 16:31:06 发布
阅读量499 收藏 7
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构 栈 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Robot__Man/article/details/52606447
版权

1 栈

1.1 顺序结构实现栈

#ifndef _SA_H
#define _SA_H

#include <sys/types.h>
typedef struct Stack{
    int *arr;
    size_t cap;
    size_t top;
}STACK;

void stack_init(STACK* stack,size_t cap);
void stack_deinit(STACK* stack);//释放内存
/*判断栈满或空*/
int stack_full(STACK* stack);
int stack_empty(STACK* stack);
/*入栈、出栈*/
void stack_push(STACK* stack,int data);
int stack_pop(STACK* stack);
/*取栈顶（不出栈）   元素数量*/
int stack_top(STACK* stack);
size_t stack_size(STACK* stack);

#endif
#include <stdlib.h>
#include "sa.h"

void stack_init(STACK* stack,size_t cap){
    stack->arr = malloc(cap * sizeof(int));
    stack->cap = cap;
    stack->top = 0;
}

void stack_deinit(STACK* stack){
    free(stack->arr);
    stack->arr = NULL;
    stack->cap = 0;
    stack->top = 0;
}

int stack_full(STACK* stack){
    return stack->top >= stack->cap;
}

int stack_empty(STACK* stack){
    return !stack->top;
}

void stack_push(STACK* stack,int data){
    stack->arr[stack->top] = data;
    stack-top++;
}

int stack_pop(STACK* stack){
    stack->top--;
    return stack->arr[stack->top];
}

int stack_top(STACK* stack){
    return stack->arr[stack->top - 1];
}

size_t stack_size(STACK* stack){
    return stack->top;
}
#include <stdio.h>
#include "sa.h"

int main(){
    STACK stack;
    stack_init(&stack,10);
    int i;
    for (i = 0;i < 7;i++){
        stack_push(&stack,i + 1);
    }
    while(!stack_empty(&stack){
        printf("%d\n",stack_pop(&stack));
    }
    stack_deinit(&stack);
}

1.2 链式结构实现栈

#ifndef _SL_H
#define _SL_H

#include <sys/types.h>
typedef struct StackNode{
    int data;
    struct StackNode* next;
}STACK_NODE;

typedef struct Stack{
    STACK_NODE* top;
}STACK;

void stack_init(STACK* stack);
void stack_deinit(STACK* stack);
int stack_empty(STACK* stack);//判断是否为空
void stack_push(STACK* stack,int data);//入栈
int stack_pop(STACK* stack);//出栈
int stack_top(STACK* stack);//查看栈顶而不出栈
size_t stack_size(STACK* stack);//元素个数

#endif
#include <stdlib.h>
#include "sl.h"

/*额外提供创建节点和销毁节点的函数（自用）*/
static STACK_NODE* create_node(int data,STACK_NODE* next){
    STACK_NODE* node = malloc(sizeof(STACK_NODE));
    node->data = data;
    node->next = next;
    return node;
}

static STACK_NODE* destroy_node(STACK_NODE*){
    STACK_NODE* next = node->next;
    free(node);
    return next;
}

void stack_init(STACK* stack){
    stack->top = NULL;
}

void stack_deinit(STACK* stack){
    while (stack->top)
        stack->top = destroy_node(stack->top);
}

int stack_empty(STACK* stack){
    return !stack->top;
}

void stack_push(STACK* stack,int data){
    stack->top = create_node(data,stack->top);
}

int stack_pop(STACK* stack){
    int data = stack->top->data;
    stack->top = destroy_node(stack->top);
    return data;
}

int stack_top(STACK* stack){
    return stack->top->data;
}

size_t stack_size(STACK* stack){
    size_t size = 0;
    STACK_NODE* node = stack->top;
    while (node){
        size++;
        node = node->next;
    }
}
#include <stdio.h>
#include "sl.h"

int main(){
    STACK stack;
    stack_init(&stack);
    int i;
    for (i = 0;i < 7;i++){
        stack_push(&stack,i + 1);
    }
    printf("size = %d\n",stack_size(&stack));
    while(!stack_empty(&stack){
        printf("%d\n",stack_pop(&stack));
    }
    stack_deinit(&stack);
}

2 队列

2.1 顺序结构实现队列

#ifndef _QA_H
#define _QA_H

#include <sys/types.h>
typedef struct Queue{
    int *arr;
    int cap;
    size_t front;
    size_t rear;
    size_t size;
}QUEUE;

//队列的初始化和删除
void queue_init(QUEUE* queue,size_t cap);
void queue_deinit(QUEUE* queue);

//判断队列的空和满
int queue_empty(QUEUE* queue);
int queue_full(QUEUE* queue);

void queue_push(QUEUE* queue,int data);
int queue_pop(QUEUE* queue);
int queue_front(QUEUE* queue);
size_t queue_size(QUEUE* queue);

#endif
#include <stdlib.h>
#include "qa.h"

void queue_init(QUEUE* queue,size_t cap){
    queue->arr = malloc(cap * sizeof(int));
    queue->cap = cap;
    queue->front = 0;
    queue->rear = 0;
    queue->size = 0;
}

void queue_deinit(QUEUE* queue){
    free(queue->arr);
    queue->arr = 0;
    queue->cap = 0;
    queue->front = 0;
    queue->rear = 0;
    queue->size = 0;
}

int queue_empty(QUEUE* queue){
    return !queue->size;
}

int queue_full(QUEUE* queue){
    return queue->size >= queue->cap;
}

void queue_push(QUEUE* queue,int data){
    if (queue->rear >= queue->cap)
        queue->rear = 0;
    queue->size++;
    queue->arr[queue->rear] = data;
    queue->rear++;
}

int queue_pop(QUEUE* queue){
    if (queue->front >= queue->cap)
        queue->front = 0;
    queue->size--;
    return queue->arr[queue->front++];
}

int queue_front(QUEUE* queue){
    if (queue->front >= queue->cap)
        queue->front = 0;
    return queue->arr[queue->front];
}

size_t queue_size(QUEUE* queue){
    return queue->size;
}
#include <stdlib.h>
#include "qa.h"

int main(){
    QUEUE queue;
    queue_init(&queue,5);
    int i;
    for (i = 0;!queue_full(&queue);i++){
        queue_push(&queue,i + 1);
    }
    while (!queue_empty(&queue)){
        printf("%d\n",queue_pop(&queue));
    }
    queue_deinit(&queue);
    return 0;
}

2.2 链式结构实现队列

#ifndef _QL_H
#define _QL_H

#include <sys/types.h>
typedef struct QueueNode{
    int data;
    struct QueueNode* next;
}QUEUE_NODE;

typedef struct Queue{
    QUEUE_NODE* front;
    QUEUE_NODE* rear;
}QUEUE;

void queue_init(QUEUE* queue);
void queue_deinit(QUEUE* queue);
int queue_empty(QUEUE* queue);
void queue_push(QUEUE* queue,int data);
int queue_pop(QUEUE* queue);
int queue_front(QUEUE* queue);
size_t queue_size(QUEUE* queue);

#endif
#include <stdlib.h>
#include "ql.h"

//创建节点和销毁节点函数（自用）
static QUEUE_NODE* create_node(int data){
    QUEUE_NODE* node = malloc(sizeof(QUEUE_NODE));
    node->data = data;
    node->next = NULL;
    return node;
}

static QUEUE_NODE* destroy_node(QUEUE_NODE* node){
    QUEUE_NODE* next = node->next;
    free(node);
    return next;
}

void queue_init(QUEUE* queue){
    queue->front = NULL;
    queue->rear = NULL;
}

void queue_deinit(QUEUE* queue){
    while (queue->front)
        queue->front = destroy_node(queue->front);
    queue->rear = NULL;
}

int queue_empty(QUEUE* queue){
    return !queue->front && !queue->rear;
}

void queue_push(QUEUE* queue,int data){
    QUEUE_NODE* rear = create_node(data);
    if (queue->rear)
        queue->rear->next = rear;
    else
        queue->front = rear;
    queue->rear = rear;
}

void queue_pop(QUEUE* queue){
    int data = queue->front->data;
    if (!(queue->front = destroy_node(queue->front)))
        queue->rear = NULL;
    return data;
}

int queue_front(QUEUE* queue){
    return queue->front->data;
}

size_t queue_size(QUEUE* queue){
    size_t size = 0;
    QUEUE_NODE* node = queue->front;
    for (;node;node = node->next)
        size++;
    return size;
}
#include <stdio.h>
#include "ql.h"

int main(){
    QUEUE queue;
    queue_init(&queue);
    int i;
    for (i = 0;i < 5;i++)
        queue_push(&queue,i + 1);
    printf("size = %d\n",queue_size);
    while (!queue_empty(&queue))
        printf("%d\n",queue_pop(&queue));
    queue_deinit(&queue);
}
Robot__Man
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构试验中机器人的操作
11-23
Dr.Kong设计了一个可以前进或后退机器人，该机器人在每个位置i会得到一个移动步数的指令Ki (i=1,2…N),聪明的机器人自己会判断是要前进Ki步还是后退Ki步。 例如：给定指令序列(3 3 1 2 5)，表示机器人在第1个位置时，可以前进3步到第4个位置，此时后退是不起作用的，出界；机器人在第2个位置时，可以前进3步到第5个位置，此时后退是不起作用的，出界；机器人在第3个位置时，可以前进1步到第4个位置，也可以后退1步到第2个位置等等。 你认为，对给定的两个位置A,B, 聪明的机器人从A位置走到B位置至少要判断几次？ 【标准输入】 第一行: M 表示以下有M组测试数据（0<M<=8） 接下来每组有两行数据 头一行：N A B ( 1≤ N≤ 50, 1≤A,B ≤N ) 下一行: K1 K2…..Kn ( 0<=Ki<=N ) 【标准输出】 输出有M行，第i行为第i组测试数据的最少判断次数, 若无法到达，则输出-1。 标准输入 标准输出 2 5 1 5 3 3 1 2 5 8 5 3 1 2 1 5 3 1 1 1 3 -1 刚开始学数据结构，用顺序表写的
单链表的基本操作
小马同学的博客
11-22 114
实现的功能： 单链表的增删查改以及第pos位后插入 SL.h #pragma once #include<stdlib.h> #include<string.h> #include<assert.h> #include<stdio.h> typedef int SLTDataType;//给类型起别名 typedef struct SList {...
406. 根据身高重建队列
路漫漫其修远兮
08-03 1267
题目描述 假设有打乱顺序的一群人站成一个队列。 每个人由一个整数对(h, k)表示，其中h是这个人的身高，k是排在这个人前面且身高大于或等于h的人数。 编写一个算法来重建这个队列。 注意： 总人数少于1100人。 示例 输入: [[7,0], [4,4], [7,1], [5,0], [6,1], [5,2]] 输出: [[5,0], [7,0], [5,2], [6,1], ...
队列的简单实现
正在路上的专栏
02-19 485
/**  * 队列的简单实现  * @author xxxu  *  */ public class Quene { //头结点 private Node first; //尾结点 private Node last; //队列结点个数 private int N=0; private class Node{ int item; Node next; } //队
【RabbitMQ】——5种队列
相由心生-心随相改~
07-31 1万+
应用RabbitMQ，我们可以根据需求选择5种队列之一。 一、简单队列 P：消息的生产者 C：消息的消费者 红色：队列简单队列的生产者和消费者关系一对一 但有时我们的需求，需要一个生产者，对应多个消费者，那就可以采用第二种模式 二、Work模式 一个生产者、2个消费者。 但MQ中一个消息只能被一个消费者获取。即消息要么被C1获取，要么被C2获取。这种模式适用于类似集群，能者多
JAVA上百实例源码以及开源项目源代码
09-17
Java源代码实现部分，比较有意思，也具参考性。像坐标控制、旋转矩阵、定时器、生成图像、数据初始化、矩阵乘法、坐标旋转、判断是否是顺时针方向排列、鼠标按下、放开时的动作等，都可在本源码中得以体现。 Java...
IOI国家集训队论文集1999-2019
09-20
陈 宏 -《数据结构的选择与算法效率——从IOI98试题PICTURE谈起》 来煜坤 -《把握本质，灵活运用——动态规划的深入探讨》 齐 鑫 -《搜索方法中的剪枝优化》 邵 铮 -《数学模型的建立、比较和应用》 石润婷 -...
VC与Labview、Matlab编程论文资料[4].rar
05-05
基于LabVIEW队列状态机的数据采集系统设计.pdf 基于Matcom与COM的VC_Matlab混合编程.pdf 基于Matcom与VC_的信号趋势项处理.pdf 基于MATCOM的MATLAB与VC混合编程技术研究.pdf 基于MATLAB_MFC和Vega的飞机刹车视景仿真...
JAVA上百实例源码以及开源项目
01-03
Java源代码实现部分，比较有意思，也具参考性。像坐标控制、旋转矩阵、定时器、生成图像、数据初始化、矩阵乘法、坐标旋转、判断是否是顺时针方向排列、鼠标按下、放开时的动作等，都可在本源码中得以体现。 Java...
java常用重构技巧
卓越之路
05-23 9840
基本原则 1. 尽量在合适的场合使用单例 使用单例可以减轻加载的负担，缩短加载的时间，提高加载的效率，但并不是所有地方都适用于单例，简单来说，单例主要适用于以下三个方面： 第一，控制资源的使用，通过线程同步来控制资源的并发访问； 第二，控制实例的产生，以达到节约资源的目的； 第三，控制数据共享，在不建立直接关联的条件下，让多个不相关的进程或线程之间实现通信。 2. 尽量避免随意使用静态变量 要知道...
数据结构与算法-剑指Offer系列（12）机器人的运动范围-Java实现
Three_ST的博客
08-20 111
题目12：机器人的运动范围 题目描述： 地上有一个m行n列的方格。一个机器人从坐标(0, 0)的格子开始移动，它每一次可以向左、右、上、下移动一格，但不能进入行坐标和列坐标的数位之和大于k的格子。例如，当k为18时，机器人能够进入方格(35, 37)，因为3+5+3+7=18。但它不能进入方格(35, 38)，因为3+5+3+8=19。请问该机器人能够到达多少个格子？ 题目分析： 本题11...
重建队列
flash的博客
07-04 216
/* 重建队列 执行用时 :11 ms, 在所有 Java 提交中击败了95.28%的用户 内存消耗 :43.5 MB, 在所有 Java 提交中击败了92.45%的用户 */ public static int[][] reconstructQueue(int[][] people) { if(0==people .length ||0==people[0].length)r...
数据结构中，二叉树用到的算法代码综合
编程机器人
07-29 489
#include #include using namespace std; struct BTNode { char data; BTNode* lchild; BTNode* rchild; };// void CreateBTnode(BTNode* &p) { //cout<<"please input your node "<<endl; char ch; cin>>ch
qzezoj 1588 队列重构（加强版）90分做法
fxt275307894a的博客
04-10 119
题面传送门 707070分做法参考这篇博客 考虑在707070分做法上优化。 707070分是一个一个找的。我们可以用树状数组维护序列aia_iai​为iii之前有几个位置被占了。 则当i<ji<ji<j时，ai≤aja_i\leq a_jai​≤aj​，这满足二分的性质，所以我们可以二分找位置。 时间复杂度O(nlog2n)O(nlog^2n)O(nlog2n) 代码实现: #...
qzezoj 1588 队列重构（加强版）
fxt275307894a的博客
04-11 120
题面传送门 909090分做法见这里 正解是线段树+分治。 我们尝试在线段树上跑分治，则维护线段树每个节点的有几个位置没被选两边跑分治就好了。 代码实现: #include<cstdio> using namespace std; int n,sum[4000039],now[1000039],a[1000039],b[1000039]; inline void read(regist...
qzezoj 1585 队列重构
fxt275307894a的博客
04-03 128
题面传送门 对于这道题，正着枚举是很难枚举的，但我们可以反着来。 俗话说得好，正难则反。 考虑最小的一个数hih_ihi​，则所有数都是大于等于它的，所以它的排位应该是在viv_ivi​。 考虑第二小的数hjh_jhj​，则除了hih_ihi​没有其他数小于它，所以我们可以直接找到除了viv_ivi​外的第iii位，它的答案就是在那里。 以此类推。 所以我们可以将所有二元组按hih_ihi​排序。...
重构：一、重新组织方法
Bonjour
05-24 782
重构： 在编写完代码后，仔细再去检查，会发现有很多地方都有改进。代码的重构（整理）可以为后期维护带来很好的选择。每个函数的粒度应该尽可能的比较小，这样复用代码重写代码，效率才会偏高。
数据结构（1）—— 数据结构的三大结构
热门推荐
Robot Man的技术博客
09-07 2万+
1 数据结构的三大结构计算机程序设计 = 数据结构 + 算法 数据结构研究变量的管理方式，算法研究解决特定问题的方法。 数据结构分三个层次：逻辑结构（抽象层）、物理结构（结构层）、运算结构（实现层）。1.1 数据结构的逻辑结构逻辑结构指人对数据之间关系的理解和看法，逻辑结构和计算机无关。 逻辑结构： 1、集合结构：这种结构表示数据可以合并成一个整体。 　　这是数据之间关系最弱的一种，就仅比
排序和查找算法
Robot Man的技术博客
09-09 2228
排序和查找是两种典型的算法1 排序算法冒泡排序算法是最简单的排序算法，它的执行效率最低，但冒泡排序算法既适用于顺序物理结构也适用于链式物理结构 冒泡排序任何时候比较的都是相邻的两个数，而选择排序是固定一个数字，拿它前面所有的数字和它比较 选择排序可以把数字直接放在最终位置，以位置为中心 选择排序有多种实现方法，选择排序也可以使用链式物理结构插入排序假设前面的数字都已经排序完成了，每次把后面的一
数据结构栈与队列代码c语言实现
最新发布
05-19
栈的C语言实现： ```c #include #include #define MAXSIZE 100 typedef struct { int data[MAXSIZE];...void init(Stack *s) { // 初始化栈 ...以上是基本的栈和队列的实现，可以根据需要进行修改和扩展。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值