【“栈、队列”的应用】408数据结构代码

网瘾中心呼唤爱2023-10-05 13:05

王道数据结构强化课------【"栈、队列"的应用】代码，持续更新

链式存储栈（单链表实现），并基于上述定义，栈顶在链头，实现"出栈、入栈、判空、判满"四个基本操作

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>

// 定义链表节点
struct Node {
    int data;
    struct Node* next;
};

// 定义栈结构
struct Stack {
    struct Node* top; // 栈顶指针
};

// 初始化栈
void initStack(struct Stack* stack) {
    stack->top = NULL;
}

// 入栈操作
void push(struct Stack* stack, int value) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    if (newNode == NULL) {
        printf("内存分配失败，无法执行入栈操作\n");
        return;
    }
    newNode->data = value;
    newNode->next = stack->top;
    stack->top = newNode;
}

// 出栈操作
int pop(struct Stack* stack) {
    if (stack->top == NULL) {
        printf("栈为空，无法执行出栈操作\n");
        return -1; // 返回一个错误值
    }
    struct Node* temp = stack->top;
    int poppedValue = temp->data;
    stack->top = temp->next;
    free(temp);
    return poppedValue;
}

// 判空操作
int isEmpty(struct Stack* stack) {
    return (stack->top == NULL);
}

// 判满操作（对于链式存储的栈，通常不会满，所以返回0表示不满）
int isFull(struct Stack* stack) {
    return 0;
}

// 释放栈内存
void freeStack(struct Stack* stack) {
    while (stack->top != NULL) {
        struct Node* temp = stack->top;
        stack->top = temp->next;
        free(temp);
    }
}

int main() {
    struct Stack stack;
    initStack(&stack);

    // 入栈操作
    push(&stack, 1);
    push(&stack, 2);
    push(&stack, 3);

    // 出栈操作
    printf("出栈操作: %d\n", pop(&stack));

    // 判空操作
    printf("栈是否为空: %s\n", isEmpty(&stack) ? "是" : "否");

    // 判满操作
    printf("栈是否满: %s\n", isFull(&stack) ? "是" : "否");

    // 释放栈内存
    freeStack(&stack);

    return 0;
}

链式存储栈（双向链表实现）

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>

// 定义链表节点
struct Node {
    int data;
    struct Node* next;
    struct Node* prev;
};

// 定义栈结构
struct Stack {
    struct Node* top; // 栈顶指针，链尾
};

// 初始化栈
void initStack(struct Stack* stack) {
    stack->top = NULL;
}

// 入栈操作
void push(struct Stack* stack, int value) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    if (newNode == NULL) {
        printf("内存分配失败，无法执行入栈操作\n");
        return;
    }
    newNode->data = value;
    newNode->next = NULL;

    if (stack->top == NULL) {
        newNode->prev = NULL;
        stack->top = newNode;
    } else {
        newNode->prev = stack->top;
        stack->top->next = newNode;
        stack->top = newNode;
    }
}

// 出栈操作
int pop(struct Stack* stack) {
    if (stack->top == NULL) {
        printf("栈为空，无法执行出栈操作\n");
        return -1; // 返回一个错误值
    }
    struct Node* temp = stack->top;
    int poppedValue = temp->data;

    if (stack->top->prev != NULL) {
        stack->top = stack->top->prev;
        stack->top->next = NULL;
    } else {
        stack->top = NULL;
    }

    free(temp);
    return poppedValue;
}

// 判空操作
int isEmpty(struct Stack* stack) {
    return (stack->top == NULL);
}

// 判满操作（对于链式存储的栈，通常不会满，所以返回0表示不满）
int isFull(struct Stack* stack) {
    return 0;
}

// 释放栈内存
void freeStack(struct Stack* stack) {
    while (stack->top != NULL) {
        struct Node* temp = stack->top;
        stack->top = temp->prev;
        free(temp);
    }
}

int main() {
    struct Stack stack;
    initStack(&stack);

    // 入栈操作
    push(&stack, 1);
    push(&stack, 2);
    push(&stack, 3);

    // 出栈操作
    printf("出栈操作: %d\n", pop(&stack));

    // 判空操作
    printf("栈是否为空: %s\n", isEmpty(&stack) ? "是" : "否");

    // 判满操作
    printf("栈是否满: %s\n", isFull(&stack) ? "是" : "否");

    // 释放栈内存
    freeStack(&stack);

    return 0;
}

顺序存储的队列（数组实现）

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>

#define MAX_QUEUE_SIZE 10 // 队列的最大容量

// 定义队列结构
struct Queue {
    int front, rear; // 前后指针
    int data[MAX_QUEUE_SIZE];
};

// 初始化队列
void initQueue(struct Queue* queue) {
    queue->front = -1;
    queue->rear = -1;
}

// 判空操作
int isEmpty(struct Queue* queue) {
    return (queue->front == -1);
}

// 判满操作
int isFull(struct Queue* queue) {
    return ((queue->rear + 1) % MAX_QUEUE_SIZE == queue->front);
}

// 入队操作
void enqueue(struct Queue* queue, int value) {
    if (isFull(queue)) {
        printf("队列已满，无法执行入队操作\n");
        return;
    }
    
    if (isEmpty(queue)) {
        queue->front = 0;
    }

    queue->rear = (queue->rear + 1) % MAX_QUEUE_SIZE;
    queue->data[queue->rear] = value;
}

// 出队操作
int dequeue(struct Queue* queue) {
    if (isEmpty(queue)) {
        printf("队列为空，无法执行出队操作\n");
        return -1; // 返回一个错误值
    }

    int dequeuedValue = queue->data[queue->front];
    
    if (queue->front == queue->rear) {
        // 队列中只有一个元素，出队后队列为空
        queue->front = -1;
        queue->rear = -1;
    } else {
        queue->front = (queue->front + 1) % MAX_QUEUE_SIZE;
    }
    
    return dequeuedValue;
}

int main() {
    struct Queue queue;
    initQueue(&queue);

    // 入队操作
    enqueue(&queue, 1);
    enqueue(&queue, 2);
    enqueue(&queue, 3);

    // 出队操作
    printf("出队操作: %d\n", dequeue(&queue));

    // 判空操作
    printf("队列是否为空: %s\n", isEmpty(&queue) ? "是" : "否");

    // 判满操作
    printf("队列是否满: %s\n", isFull(&queue) ? "是" : "否");

    return 0;
}

链式存储队列（单链表实现）

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>

// 定义链表节点
struct Node {
    int data;
    struct Node* next;
};

// 定义队列结构
struct Queue {
    struct Node* front; // 队列前端
    struct Node* rear;  // 队列后端
};

// 初始化队列
void initQueue(struct Queue* queue) {
    queue->front = NULL;
    queue->rear = NULL;
}

// 判空操作
int isEmpty(struct Queue* queue) {
    return (queue->front == NULL);
}

// 判满操作（对于链式存储的队列，通常不会满，所以返回0表示不满）
int isFull(struct Queue* queue) {
    return 0;
}

// 入队操作
void enqueue(struct Queue* queue, int value) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    if (newNode == NULL) {
        printf("内存分配失败，无法执行入队操作\n");
        return;
    }
    newNode->data = value;
    newNode->next = NULL;
    
    if (isEmpty(queue)) {
        queue->front = newNode;
    } else {
        queue->rear->next = newNode;
    }
    
    queue->rear = newNode;
}

// 出队操作
int dequeue(struct Queue* queue) {
    if (isEmpty(queue)) {
        printf("队列为空，无法执行出队操作\n");
        return -1; // 返回一个错误值
    }
    
    struct Node* temp = queue->front;
    int dequeuedValue = temp->data;
    
    queue->front = temp->next;
    free(temp);
    
    if (queue->front == NULL) {
        // 如果出队后队列为空，需要更新rear指针
        queue->rear = NULL;
    }
    
    return dequeuedValue;
}

// 释放队列内存
void freeQueue(struct Queue* queue) {
    while (queue->front != NULL) {
        struct Node* temp = queue->front;
        queue->front = temp->next;
        free(temp);
    }
}

int main() {
    struct Queue queue;
    initQueue(&queue);

    // 入队操作
    enqueue(&queue, 1);
    enqueue(&queue, 2);
    enqueue(&queue, 3);

    // 出队操作
    printf("出队操作: %d\n", dequeue(&queue));

    // 判空操作
    printf("队列是否为空: %s\n", isEmpty(&queue) ? "是" : "否");

    // 判满操作
    printf("队列是否满: %s\n", isFull(&queue) ? "是" : "否");

    // 释放队列内存
    freeQueue(&queue);

    return 0;
}
相关推荐
曳渔23 分钟前
Java-数据结构-二叉树-习题(三) ￣へ￣
java·开发语言·数据结构·算法·链表
shark-chili33 分钟前
数据结构与算法-Trie树添加与搜索
java·数据结构·算法·leetcode
Crossoads2 小时前
【数据结构】排序算法---快速排序
c语言·开发语言·数据结构·算法·排序算法
眰恦3742 小时前
数据结构--第五章树与二叉树
数据结构·算法
未 顾2 小时前
JavaSE--集合总览02：单列集合Collection的体系之一：List
数据结构·list
wx200411022 小时前
Codeforces Round 973 (Div. 2) - D题
数据结构·c++·算法
Crossoads3 小时前
【数据结构】排序算法---基数排序
c语言·开发语言·数据结构·算法·排序算法
爱敲代码的憨仔3 小时前
第二讲 数据结构
数据结构·算法
问道飞鱼3 小时前
每日学习一个数据结构-布隆过滤器Bloom Filter
数据结构·学习·哈希算法
龙ze3 小时前
数据结构—(java)反射，枚举，lambda表达式
java·开发语言·数据结构
热门推荐
01RAG 实践- Ollama+RagFlow 部署本地知识库02组基轨迹建模 GBTM的介绍与实现（Stata 或 R）032024年高教社杯数学建模国赛C题超详细解题思路分析04软件工程从理论到实践客观题汇总(头歌第一章至第八章)05苍穹外卖面试总结06【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提07CCF-CSP认证考试 202406-3 文本分词 100分题解08yolov8实战第五天——yolov8+ffmpg实时视频流检测并进行实时推流——（推流，保姆教学）09【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文10【halcon】halcon字符识别——OCR