『数据结构』栈和队列

最新推荐文章于 2022-05-25 20:09:09 发布
最新推荐文章于 2022-05-25 20:09:09 发布
阅读量240 收藏
点赞数 1
分类专栏： 『数据结构』 文章标签： 数据结构 栈 队列 C
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sss_0916/article/details/88863289
版权

栈

栈，是一种特殊的线性结构，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。
在这里插入图片描述
栈的实现一般可以使用数组或链表实现，相对而言数组的结构更好一些。在数组的尾上插入删除数据的代价都比较小。

栈接口实现

C语言实现

stack.h

#pragma once

typedef int ElementType;

/*---栈---*/
typedef struct Stack 
{
	ElementType* ele;
	size_t top;
	size_t capacity;
} Stack;

/*---初始化---*/
void stackInit(Stack* st);

/*---释放---*/
void stackDestory(Stack* st);

/*---压栈---*/
void stackPush(Stack* st, ElementType v);

/*---弹栈---*/
void stackPop(Stack* st);

/*---取出栈顶元素---*/
ElementType stackTop(const Stack* st);

/*---是否为空---*/
int stackEmpty(const Stack* st);

/*---栈元素数量---*/
size_t stackSize(const Stack* st);

stack.c

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "stack.h"

void stackInit(Stack* st)
{
	assert(st != NULL);
	st->capacity = 1;
	st->top = 0;
	st->ele = (ElementType*)malloc(sizeof(ElementType) * st->capacity);
	assert(st->ele != NULL);
}

void stackDestory(Stack* st)
{
	assert(st != NULL);
	free(st->ele);
	st->ele = NULL;
	st->top = 0;
	st->capacity = 0;
}

static void checkCapacity(Stack* st)
{
	if (st->top >= st->capacity)
	{
		st->capacity *= 2;
		st->ele = (ElementType*)realloc(st->ele,
			sizeof(ElementType) * st->capacity);
	}
}

void stackPush(Stack* st, ElementType v)
{
	assert(st != NULL);
	checkCapacity(st);
	++st->top;
	st->ele[st->top - 1] = v;
}

void stackPop(Stack* st)
{
	assert(st != NULL);
	--st->top;
}

ElementType stackTop(const Stack* st)
{
	assert(st != NULL);
	return st->ele[st->top - 1];
}

int stackEmpty(const Stack* st)
{
	assert(st != NULL);
	if (st->top == 0)
	{
		return 1;
	}
	return 0;
}

size_t stackSize(const Stack* st)
{
	return (size_t)st->top;
}

Java实现

public class MyStack {
    private int[] arr = null;
    private int size = 0;

    // 初始化
    public MyStack(int initCapacity) {
        this.arr = new int[initCapacity];
    }

    // 入栈
    public boolean push(int value) {
        if (this.size == this.arr.length) {
            return false;
        }

        this.arr[this.size] = value;
        ++this.size;
        return true;
    }

    // 出栈
    public Integer pop() {
        if (this.size == 0) {
            return null;
        }

        --this.size;
        return this.arr[this.size];
    }

    // 获取栈顶元素
    public Integer peek() {
        if (this.size == 0) {
            return null;
        }

        return this.arr[this.size - 1];
    }

    // 获取元素数量
    public int size() {
        return this.size;
    }

    // 栈是否为空
    public boolean isEmpty() {
        return this.size == 0;
    }
}

队列

队列，同样是一种特殊的线性结构，只允许在一端进行插入，在另一端进行删除数据操作。队列遵循先进先出FIFO(First In First Out)，进行插入操作的一端称为队尾，进行删除操作的一端称为队头。
在这里插入图片描述
队列的实现可以使用数组和链表的结构实现，使用链表实现更好，数组头上删数据不太方便（但是可以使用数组实现成循环队列的形式，效率还是很高的）。

接口实现（链表实现）

C语言版：
queue.h

#pragma once

typedef int ElementType;

/*---队列结点---*/
typedef struct Node 
{
	ElementType value;
	struct Node* next;
} Node;

/*---队列---*/
typedef struct Queue 
{
	Node* front;
} Queue;

/*---初始化---*/
void queueInit(Queue* q);

/*---释放---*/
void queueDestory(Queue* q);

/*---入队---*/
void queuePush(Queue* q, ElementType v);

/*---出队---*/
void queuePop(Queue* q);

/*---队首元素---*/
ElementType queueFront(const Queue* q);

/*---队尾元素---*/
ElementType queueBack(const Queue* q);

/*---是否为空---*/
int queueEmpty(const Queue* q);

/*---队长---*/
size_t queueSize(const Queue* q);

queue.c

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "queue.h"

void queueInit(Queue* q)
{
	assert(q != NULL);
	q->front = NULL;
}

void queueDestory(Queue* q)
{
	assert(q != NULL);
	while (q->front != NULL)
	{
		Node* temp = q->front;
		q->front = q->front->next;
		free(temp);
		temp = NULL;
	}
}

static Node* createNode(ElementType v)
{
	Node* node = createNode(v);
	assert(node != NULL);
	node->value = v;
	return node;
}

void queuePush(Queue* q, ElementType v)
{
	assert(q != NULL); 
	Node* node = createNode(v);
	if (q->front == NULL)
	{
		node->next = NULL;
		q->front = node;
		return;
	}
	Node* cur = q->front;
	while (cur->next == NULL)
	{
		cur = cur->next;
	}
	node->next = NULL;
	cur->next = node;
}

void queuePop(Queue* q)
{
	assert(q != NULL);
	if (q->front == NULL)
	{
		return;
	}
	Node* temp = q->front;
	q->front = q->front->next;
	free(temp);
	temp = NULL;
}

ElementType queueFront(const Queue* q)
{
	assert(q != NULL);
	assert(q->front != NULL);
	return q->front->value;
}

ElementType queueBack(const Queue* q)
{
	assert(q != NULL);
	assert(q->front != NULL);
	Node* cur = q->front;
	while (cur->next != NULL)
	{
		cur = cur->next;
	}
	return cur->value;
}

int queueEmpty(const Queue* q)
{
	assert(q != NULL);
	if (q->front == NULL)
	{
		return 1;
	}
	return 0;
}

size_t queueSize(const Queue* q)
{
	assert(q != NULL);
	if (q->front == NULL)
	{
		return 0;
	}
	size_t size = 0;
	Node* cur = q->front;
	while (cur != NULL)
	{
		cur = cur->next;
		++size;
	}
	return size;
}

Java版：

public class MyQueue {
    private ListNode head = null;
    private ListNode tail = null;
    private int size = 0;

    // 入队
    public void offer(int val) {
        ListNode newNode = new ListNode(val);

        ++this.size;

        if (this.head == null) {
            this.head = this.tail = newNode;
            return;
        }

        tail.next = newNode;
        tail = newNode;
    }

    // 出队
    public Integer poll() {
        if (this.size == 0) {
            return null;
        }

        --this.size;
        if (this.size == 0) {
            this.tail = null;
        }

        int ret = this.head.val;
        this.head = this.head.next;
        return ret;
    }

    // 取队首元素
    public Integer peek() {
        if (this.size == 0) {
            return null;
        }

        return this.head.val;
    }

    // 队列中元素个数
    public int size() {
        return this.size;
    }

    // 队列是否为空
    public boolean isEmpty() {
        return this.size == 0;
    }
}

class ListNode {
    public int val;
    public ListNode next = null;

    public ListNode(int val) {
        this.val = val;
    }
}

接口实现（数组实现循环队列）

C语言版：
circular_queue.h

#pragma once

typedef int ElementType;

typedef struct CircularQueue{
	ElementType* cir_que;
	int front;
	int rear;
	int max_size;
} CircularQueue;

/* 初始化 */
void cqInit(CircularQueue* cq, int size);

/* 释放 */
void cqDestroy(CircularQueue* cq);

/* 判空 */
bool isEmpty(const CircularQueue* cq);

/* 队满 */
bool isFull(const CircularQueue* cq);

/* 入队 */
bool Push(CircularQueue* cq, ElementType val);

/* 出队 */
bool Pop(CircularQueue* cq);

/* 队首 */
ElementType Front(CircularQueue* cq);

/* 打印 */
void cqDisplay(const CircularQueue* cq);

circular_queue.c

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>
#include "circular_queue.h"

void cqInit(CircularQueue* cq, int size){
	assert(cq != NULL);

	cq->front = 0;
	cq->rear = 0;
	cq->max_size = size;
	cq->cir_que = (ElementType*)malloc(sizeof(ElementType) 
			* cq->max_size);
	assert(cq->cir_que != NULL);
}

void cqDestroy(CircularQueue* cq){
	assert(cq != NULL);

	cq->front = 0;
	cq->rear = 0;
	cq->max_size = 0;
	free(cq->cir_que);
	cq->cir_que = NULL;
}

bool isEmpty(const CircularQueue* cq){
	assert(cq != NULL);

	return cq->front == cq->rear;
}

bool isFull(const CircularQueue* cq){
	assert(cq != NULL);

	return (cq->rear + 1) % cq->max_size == cq->front;
}

bool Push(CircularQueue* cq, ElementType val){
	assert(cq != NULL);

	if(isFull(cq)){
		return false;
	}
	cq->cir_que[cq->rear] = val;
	cq->rear = (cq->rear + 1) % cq->max_size;
	return true;
}

bool Pop(CircularQueue* cq){
	assert(cq != NULL);

	if(isEmpty(cq)){
		return false;
	}

	cq->front = (cq->front + 1) % cq->max_size;
	return true;
}

ElementType Front(CircularQueue* cq){
	assert(cq != NULL);

	if(!isEmpty(cq)){
		ElementType ret = cq->cir_que[cq->front];
		Pop(cq);
		return ret;
	}

	return -1;
}

void cqDisplay(const CircularQueue* cq){
	int i;

	printf("The circular queue is below: \n");
	for(i = cq->front; i < cq->rear; (++i) % cq->max_size){
		printf("%d ", cq->cir_que[i]);
	}
	printf("\n");
}

Java版：

public class CycleQueue {
    private int[] arr;
    private int size = 0;
    private int front = 0;
    private int rear = 0;

    public CycleQueue(int initCapacity) {
        this.arr = new int[initCapacity];
    }

    // 入队
    public boolean offer(int val) {
        if (this.size == this.arr.length) {
            return false;
        }

        if (this.size != 0) {
            this.rear = (this.rear + 1) % this.arr.length;
        }
        this.arr[this.rear] = val;
        ++this.size;

        return true;
    }

    // 出队
    public Integer poll() {
        if (this.size == 0) {
            return null;
        }

        int ret = this.arr[this.front];
        if (this.front != this.rear) {
            this.front = (this.front + 1) % this.arr.length;
        }
        --this.size;

        return ret;
    }

    // 获取队首元素
    public Integer peek() {
        if (this.size == 0) {
            return null;
        }

        return this.arr[this.front];
    }

    // 获取队列中元素个数
    public int size() {
        return this.size;
    }

    // 判断队列是否为空
    public boolean isEmpty() {
        return this.size == 0;
    }
}
爱喝可乐的炸鸡
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构栈和队列、递归算法
梦想之深邃
09-25 1818
知识要点： 栈的定义、结构特点及其存储方式(顺序存储与链接存储)和基本操作的实现算法； 队列的结构、特点及其存储方式(顺序存储与链接存储)和基本操作的实现算法。 递归的基本概念和实现原理以及用递归的思想描述问题和书写算法的方法； 用栈实现递归问题的非递归解法。 栈的定义：只允许一段进行插入或者删除操作的线性表；该端称为栈顶（top），相反另一端不允许被操作的称为栈底（base） 栈内元...
数据结构栈和队列试题及答案
11-26
栈和队列考试题 复习 栈和队列考试题 复习栈和队列考试题 复习
数据结构算法 - 栈和队列
z240336124的专栏
11-21 368
栈和队列在数据结构和算法学习中，是比较容易理解的。但有时候感觉自己掌握了栈和队列，可是在写的时候遇到不同的情况，就不会处理了，因此自己还是想再总结回顾一下。 栈： 是一端受限，一端允许进行操作的线性表。即：先放的后取，后放的先取。就是我们通常说的“先进后出”（FILO）。存储结构最常见的有两种：一种是顺序存储，一种是链式存储。其中顺序存储就是之前讲的数组，链式存储就是之前讲的链表。 队列： 像栈一...
【数据结构与算法】栈和队列
Ye_Ming_OUC的博客
05-19 508
文章目录栈什么是栈？栈的实现代码实现栈的声明初始化栈判断栈是否为空入栈出栈返回栈顶的值获取栈中有效元素的个数销毁栈队列什么是队列？队列的实现代码实现队列的声明初始化队列判断队列是否为空队尾入队列队头出队列取队头的数据取队尾的数据返回队列的数据数销毁队列销毁队列 栈 什么是栈？ 栈是线性表的一种。 它只允许在固定的一端进行插入和删除元素操作。 而进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。 所以栈增删元素就有了我们常说的先进后出(Last In First Out)： 压栈：栈的插入操作叫做进栈/压
数据结构与算法：栈与队列
m0_55859452的博客
04-29 100
我们知道线性表具有序偶的逻辑关系，它在计算机物理存储的方式有两种：顺序存储与链式存储，具体的存储方式，我们在前面简单叙述过了。 今天我们学习线性表中具有特殊性质的两种抽象数据类型：栈与队列； 一、栈（Stack） 1.栈的定义：一种特殊的线性表，具有先进后出的特点。举例：手枪（最先装进去的子弹最后打出）、手电筒（最先装进去的电池最后去出）。 2.相关名词简述： a.栈顶对应表尾，栈尾对应表头,一切进行的删除与插入操作都是在栈顶（表尾）进行； b.入栈：插入一个元素到栈顶 出栈：在栈顶删除一个元素
数据结构练习——栈和队列（调度场算法）
地址ch3nye.top
08-19 825
知识补充：from wiki 调度场算法（Shunting Yard Algorithm）是一个用于将中缀表达式转换为后缀表达式的经典算法，由艾兹格·迪杰斯特拉引入，因其操作类似于火车编组场而得名。 https://zh.wikipedia.org/wiki/%E8%B0%83%E5%BA%A6%E5%9C%BA%E7%AE%97%E6%B3%95 更详细的例子 输入: 3 + 4 * 2...
数据结构栈和队列相关习题及答案
04-20
数据结构栈和队列相关习题及答案
数据结构栈和队列
04-08
栈（stack）又名堆栈，它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。
数据结构栈和队列（参考代码）
06-18
数据结构栈和队列的课程指导上几实验代码 相抵部分
数据结构与算法（栈与队列）
sun_xiao_kai的博客
02-07 122
栈的概念 栈（stack），有些地方称为堆栈，是一种容器，可存入数据元素、访问元素、删除元素，他的特点在于只能允许在容器的一端（称为栈顶端指标，英语top）进行加入数据（英语push）和输出数据（英语pop）的运算。没有了位置概念，保证任何时候可以访问、删除的元素都是此前最后存入的那个元素，确定了一种默认的访问顺序。 由于栈数据结构只允许在一端进行操作，因而按照后进先出（LIFO，Last in...
数据结构与算法——栈与队列
uytuytgu的博客
05-25 375
1、栈的概念 2、栈的实现 3、队列的概念 4、队列的实现 5、栈与队列的OJ讲解 一、栈的概念 栈是内存中的一个部分，在程序中，我们的临时变量与函数的参数都是在栈上开辟的。栈在数据结构中属于顺序结构，在c语言的学习中我们已经了解了栈的特点的先进后出或者是后进先出，也就是说每次删除元素都是从栈顶上删除。 二、栈的实现 栈需要实现的接口函数包括：initial（初始化一个栈），destory（销毁栈），push（往栈底压入数据），pop（从栈顶删除数据），size（栈的大小），top（取栈.
数据结构与算法——栈和队列
Ipkiss Studio
03-29 902
栈和队列 都是线性表 操作受限制 栈（stack ）又称为堆栈，它是运算受限的线性表，只能在表的一端进行插入、删除操作，不允许在其他任何位置进行插入、查找、删除等操作。 栈顶——进行插入、删除操作的一端 栈底——进行插入、删除操作的另一端 入栈——添加操作 出栈——删除操作 特点： 先进后出，后进先出 push——入栈 pop——出栈 peek——获取顶部元素 栈的存储结构可以采用顺序栈（数组）和链栈（链表） 队列（queue）——它和栈一样也是一种运算受限的线性表，其限制是仅
数据结构和算法2（栈和队列）
q1015189243的博客
04-18 439
栈 栈的顺序存储结构 typedef struct { ElemType *base; ElemType *top; int stackSize; }sqStack; base是指向栈底的指针，top是指向栈顶的指针，stackSize是指栈的当前可使用的最大容量。 创建一个栈 ...
浅谈算法和数据结构: 一 栈和队列
weixin_34166472的博客
01-15 324
最近晚上在家里看Algorithems，4th Edition，我买的英文版，觉得这本书写的比较浅显易懂，而且“图码并茂”，趁着这次机会打算好好学习做做笔记，这样也会印象深刻，这也是写这一系列文章的原因。另外普林斯顿大学在Coursera 上也有这本书同步的公开课，还有另外一门算法分析课，这门课程的作者也是这本书的作者，两门课都挺不错的。 计算机程序离不开算法和数据结构，本文简单介绍栈(Stac...
数据结构和算法（三）：栈和队列
杯酒释兵权
05-08 371
栈和队列栈——后进先出栈的顺序存储静态顺序栈定义初始化出栈入栈动态顺序栈定义初始化出栈（弹栈）入栈栈的链式存储栈的结点类型说明栈的初始化出栈（弹栈）压栈 栈——后进先出 表的一段进行插入和删除的操作 栈的顺序存储 静态顺序栈 用一维数组存储，栈底不变，栈顶指针top（整型变量）指向当前栈顶的位置 定义 #define MAX_STACK_SIZE 100 #typedef int ElemType; typedef struct sqstack { ElemType stack_arry[MAX_STA
数据结构与算法-栈和队列
Oligizzz
02-20 305
从数据结构角度看，栈和队列也是线性表，其特殊性在于栈和队列的基本操作也是线性表操作的子集，他们是操作受限的线性表，英词可以称作限定的数据结构。但从数据类型角度来看，他们是和线性表不相同的两类重要的抽象数据类型。 栈的定义和特点 如何理解“栈”？用现实一个通俗贴切的例子，我们平时放盘子的时候，都是从下往上一个一个放；取的时候，我们是从上往下一个一个地依次取，不能从中间任意抽出，先进后出，这就是典型的...
数据结构与算法（3）-栈与队列
Jak的博客
08-15 231
栈 package ch03; /** * 栈，先进后出，后进先出 * @author Administrator * */ public class MyStack { //底层实现是一个数组 private long[] arr; //top栈顶 private int top; /* * 默认的构造方法 */ public MyStack(){ arr =...
数据结构栈的实验报告.doc
最新发布
12-16
以上就是本次数据结构栈和队列实验的报告。通过实验，我深入理解了栈和队列的特性和操作方法，掌握了它们的基本操作。在以后的学习和工作中，我会继续不断加强对数据结构和算法的学习，提高自己的编程能力。希望通过...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值