数据结构之栈与队列

最新推荐文章于 2024-06-11 19:36:10 发布
最新推荐文章于 2024-06-11 19:36:10 发布
阅读量1k 收藏 19
点赞数 17
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80001343/article/details/138911075
版权

一.栈

1.定义：一种线性表，只允许在固定的一端进行删除和插入数据的操作，该端叫栈底，另一端叫栈顶

2.特点：先进后出

注：栈中元素出栈是一对多的(他虽然满足先进后出但是我们可以在pop数据前先获取栈顶元素并打印再pop，这样就可能改变数据在屏幕上出现的顺序)

3.思路：可以用数组实现，也可以用链表实现

数组实现更简单，链表实现较为复杂，下面小编将从两方面解释不选择链表实现的原因

1>若选择单链表，在进行删除操作时，我们不好解决栈顶先前移一位的问题

2>若选择双向链表，将占用过多的内存

4.代码实现(以数组实现栈为例)：

(1)栈的结构体定义：包含数组指针，栈顶的位置，有效空间容量

typedef int STDatatype;
typedef struct Stack
{
	STDatatype* arr;
	int top;//栈顶
	int capacity;//有效空间容量
}ST;

(2)栈的初始化：将栈顶初始化为0：表示栈顶指向最后一个数据的下一个

                          将栈顶初始化为-1：表示栈顶指向最后一个数据所在位置

//栈的初始化
void STInit(ST* ps)
{
	assert(ps);
	ps->arr = NULL;
	//top指向栈顶后的一个元素,此时top等值于有效数据个数
	ps->top = 0;
	ps->capacity = 0;
}

(3)栈的销毁

//栈的销毁
void STDestory(ST* ps)
{
	assert(ps);

	free(ps->arr);
	ps->arr = NULL;
	ps->capacity = ps->top = 0;
}

(4)插入数据/入栈：先判断是否需要增容，再插入数据

//入栈
void STPush(ST* ps, STDatatype x)
{
	assert(ps);
	//判断是否需要增容
	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity * 2==0 ? 4 : ps->capacity*2;
		STDatatype* tmp = (STDatatype*)realloc(ps->arr, sizeof(STDatatype) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		ps->arr = tmp;
		ps->capacity = newcapacity;
	}
	ps->arr[ps->top] = x;
	ps->top++;
}

(5)删除数据/出栈：先判断数组是否为空，再将top--即完成删除

//出栈
void STPop(ST* ps)
{
	assert(ps);
	assert(ps->top > 0);

	ps->top--;
}

(6)获取栈顶元素

//获取栈顶数据
STDatatype STTop(ST* ps)
{
	assert(ps);
	return ps->arr[ps->top-1];
}

(7)判断栈是否为空：若top==0则为空

//判断栈是否为空
bool STEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}

(8)栈中有效数据个数

//栈的有效数据个数
int STSize(ST* ps)
{
	assert(ps);
	return ps->top;
}

二.队列

1.定义：一种线性表，只允许在一端(队尾)进行数据插入，在另一端(队头)进行数据删除

2.特点：先进先出

注：队列的数据出队列时是一对一的

3.思路：可以用数组实现，也可以用链表实现 

单链表实现更简单，数组实现较为复杂，是因为在使用数组实现时，进行删除数据不好记录下一次该删除数据的位置

4.代码实现(以单链表实现队列为例)：

(1)队列的节点定义：指向下一个节点的指针，存储数据的数值

    队列的结构体定义：队列的头指针，尾指针，队列有效数据的个数

typedef int QueueDataType;

typedef struct QueueNode
{
	QueueDataType val;
	struct QueueNode* next;
}QNode;

typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Queue;

(2)队列的初始化

//队列的初始化
void QueueInit(Queue* pq)
{
	assert(pq);

	pq->head = NULL;
	pq->tail = NULL;
	pq->size = 0;
}

(3)队列的销毁：先逐个销毁队列的节点，再销毁队列

//队列的销毁
void QueueDestory(Queue* pq)
{
	assert(pq);

	QNode* cur = pq->head;
	while (cur)
	{
		QNode* Next = cur->next;
		free(cur);
		cur = Next;
	}
	pq->head = NULL;
	pq->tail = NULL;
	pq->size = 0;
}

(4)插入数据：为该数据开辟一个新节点，若原队列中有数据则让尾指针向后走一步，若无则头尾    指针均指向该新节点

//队尾入数据
void QueuePush(Queue* pq, QueueDataType x)
{
	//开辟一个新节点
	QNode* node = (QNode*)malloc(sizeof(QNode));
	if (node == NULL)
	{
		perror("malloc fail");
		return;
	}
	node->val = x;
	node->next = NULL;

	//队列中没有节点
	if (pq->tail == NULL)
	{
		pq->head = node;
		pq->tail = node;
	}
	else
	{
		pq->tail->next = node;
		pq->tail = node;
	}

	pq->size++;
}

(5)删除数据：删除头指针指向的节点，并让头指针向后走一步，若只有一个节点删除后需将尾指针置空

//队头出数据
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(pq->size != 0);

	QNode* next = pq->head->next;
	free(pq->head);
	pq->head = next;
	if (pq->head == NULL)
	{
		pq->tail = NULL;
	}

	pq->size--;
}

(6)获取队头元素

//获取队头数据
QueueDataType QueueFront(Queue* pq)
{
	assert(pq);
	return pq->head->val;
}

(7)获取队尾元素

//获取队尾数据
QueueDataType QueueBack(Queue* pq)
{
	assert(pq);
	return pq->tail->val;
}

(8)判断队列是否为空

//判断队列是否为空
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->size == 0;
}

(9)队列的大小

//获取队列有效数据个数
int QueueSize(Queue* pq)
{
	assert(pq);
	return pq->size;
}

三.栈与队列的相互转化

1.用栈实现队列

. - 力扣（LeetCode）

(1)思路：栈：先进后出，队列：先进先出

               创建两个栈实现队列中数据的删除

(2)解题方法：

1>自己实现栈

2>定义一个队列结构体包含两个栈

3>队列的创建：为队列结构体malloc一块空间，防止出函数时结构体被销毁

4>队列的销毁：先销毁两个栈，再销毁队列

5>队尾插数据：当两栈均为空栈时：随便在哪个空栈的栈顶插入数据均可

                          当有一个栈不为空时：在非空栈的栈顶插入数据

6>队头删数据：将非空栈的前size-1个数据导入空栈中，再删除队头的数据。此时对下次删除来说栈中数据顺序是错乱的，故还需要将原空栈的数据导回原非空栈中。

7>判断队列为空：当两个栈均为空时，队列为空

8>获取队尾数据：即非空栈的栈顶数据

(3)代码实现：

typedef int STDatatype;
typedef struct Stack
{
	STDatatype* arr;
	int top;//栈顶
	int capacity;//有效空间容量
}ST;

//栈的初始化
void STInit(ST* ps);

//栈的销毁
void STDestory(ST* ps);

//入栈
void STPush(ST* ps, STDatatype x);

//出栈
void STPop(ST* ps);

//获取栈顶数据
STDatatype STTop(ST* ps);

//判断栈是否为空
bool STEmpty(ST* ps);

//栈的有效数据个数
int STSize(ST* ps);

//栈的初始化
void STInit(ST* ps)
{
	assert(ps);
	ps->arr = NULL;
	//top指向栈顶后的一个元素,此时top等值于有效数据个数
	ps->top = 0;
	ps->capacity = 0;
}

//栈的销毁
void STDestory(ST* ps)
{
	assert(ps);

	free(ps->arr);
	ps->arr = NULL;
	ps->capacity = ps->top = 0;
}

//入栈
void STPush(ST* ps, STDatatype x)
{
	assert(ps);
	//判断是否需要增容
	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity * 2==0 ? 4 : ps->capacity*2;
		STDatatype* tmp = (STDatatype*)realloc(ps->arr, sizeof(STDatatype) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		ps->arr = tmp;
		ps->capacity = newcapacity;
	}
	ps->arr[ps->top] = x;
	ps->top++;
}

//出栈
void STPop(ST* ps)
{
	assert(ps);
	assert(ps->top > 0);

	ps->top--;
}

//获取栈顶数据
STDatatype STTop(ST* ps)
{
	assert(ps);
	return ps->arr[ps->top-1];
}

//判断栈是否为空
bool STEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}

//栈的有效数据个数
int STSize(ST* ps)
{
	assert(ps);
	return ps->top;
}

typedef struct {
    ST st1;
    ST st2;
} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue* pq=(MyQueue*)malloc(sizeof(MyQueue));
    STInit(&(pq->st1));
    STInit(&(pq->st2));
    return pq;
}

void myQueuePush(MyQueue* obj, int x) {
    assert(obj);
    if(!STEmpty(&(obj->st1)))
    {
        STPush(&(obj->st1),x);
    }
    else
    {
        STPush(&(obj->st2),x);
    }
    
}

int myQueuePop(MyQueue* obj) {
    assert(obj);
    ST* empty=&(obj->st1);
    ST* noempty=&(obj->st2);
    if(!STEmpty(&(obj->st1)))
    {
        empty=&(obj->st2);
        noempty=&(obj->st1);
    }
    while(STSize(noempty)>1)
    {
        STPush(empty,STTop(noempty));
        STPop(noempty);
    }
    STDatatype ret=STTop(noempty);
    STPop(noempty);
    //将noempty的数据导回empty,保证下次pop时数据顺序
    while(STSize(empty)>0)
    {
        STPush(noempty,STTop(empty));
        STPop(empty);
    }
    return ret;
}

int myQueuePeek(MyQueue* obj) {
    if(!STEmpty(&(obj->st1)))
    {
        return obj->st1.arr[0];
    }
    else
    {
        return obj->st2.arr[0];
    }
}

bool myQueueEmpty(MyQueue* obj) {
    return STEmpty(&(obj->st1)) && STEmpty(&(obj->st2));
}

void myQueueFree(MyQueue* obj) {
    assert(obj);
    STDestory(&(obj->st1));
    STDestory(&(obj->st2));
    free(obj);
    obj=NULL;
}

2.用队列实现栈

. - 力扣（LeetCode）

(1)思路：栈：先进后出，队列：先进先出

               创建两个队列实现栈中数据的删除

(2)解题方法：

1>自己实现队列

2>定义一个栈结构体包含两个队列

3>栈的创建：为栈结构体malloc一块空间，防止出函数时结构体被销毁

4>栈的销毁：先销毁两个队列，再销毁栈

5>入栈：当两队列均为空队列时：随便在哪个空队列的队尾插入数据均可

                          当有一个队列不为空时：在非空队列的队尾插入数据

6>出栈：将非空队列的前size-1个数据导入空队列中，再删除栈顶元素。

7>判断栈为空：当两个队列均为空时，栈为空

8>获取栈顶数据：即非空队列的队尾元素

(3)代码实现：

typedef int QueueDataType;

typedef struct QueueNode
{
	QueueDataType val;
	struct QueueNode* next;
}QNode;

typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Queue;

//队列的初始化
void QueueInit(Queue* pq);

//队列的销毁
void QueueDestory(Queue* pq);

//队尾入数据
void QueuePush(Queue* pq, QueueDataType x);

//队头出数据
void QueuePop(Queue* pq);

//获取队头数据
QueueDataType QueueFront(Queue* pq);

//获取队尾数据
QueueDataType QueueBack(Queue* pq);

//获取队列有效数据个数
int QueueSize(Queue* pq);

//判断队列是否为空
bool QueueEmpty(Queue* pq);

//队列的初始化
void QueueInit(Queue* pq)
{
	assert(pq);

	pq->head = NULL;
	pq->tail = NULL;
	pq->size = 0;
}

//队列的销毁
void QueueDestory(Queue* pq)
{
	assert(pq);

	QNode* cur = pq->head;
	while (cur)
	{
		QNode* Next = cur->next;
		free(cur);
		cur = Next;
	}
	pq->head = NULL;
	pq->tail = NULL;
	pq->size = 0;
}

//队尾入数据
void QueuePush(Queue* pq, QueueDataType x)
{
	//开辟一个新节点
	QNode* node = (QNode*)malloc(sizeof(QNode));
	if (node == NULL)
	{
		perror("malloc fail");
		return;
	}
	node->val = x;
	node->next = NULL;

	//队列中没有节点
	if (pq->tail == NULL)
	{
		pq->head = node;
		pq->tail = node;
	}
	else
	{
		pq->tail->next = node;
		pq->tail = node;
	}

	pq->size++;
}

//队头出数据
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(pq->size != 0);

	QNode* next = pq->head->next;
	free(pq->head);
	pq->head = next;
	if (pq->head == NULL)
	{
		pq->tail = NULL;
	}

	pq->size--;
}

//获取队头数据
QueueDataType QueueFront(Queue* pq)
{
	assert(pq);
	return pq->head->val;
}

//获取队尾数据
QueueDataType QueueBack(Queue* pq)
{
	assert(pq);
	return pq->tail->val;
}

//获取队列有效数据个数
int QueueSize(Queue* pq)
{
	assert(pq);
	return pq->size;
}

//判断队列是否为空
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->size == 0;
}

typedef struct {
    Queue q1;
    Queue q2;
} MyStack;


MyStack* myStackCreate() {
    MyStack* pst=(MyStack*)malloc(sizeof(MyStack));
    QueueInit(&(pst->q1));
    QueueInit(&(pst->q2));
    return pst;
}

void myStackPush(MyStack* obj, int x) {
    if(!QueueEmpty(&(obj->q1)))
    {
        QueuePush(&(obj->q1),x);
    }
    else
    {
        QueuePush(&(obj->q2),x);
    }
}

int myStackPop(MyStack* obj) {
    Queue* empty=&(obj->q1);
    Queue* noempty=&(obj->q2);
    if(!QueueEmpty(&(obj->q1)))
    {
        empty=&(obj->q2);
        noempty=&(obj->q1);
    }
    //把前size-1个数据移到空队列中
    while(QueueSize(noempty)>1)
    {
        QueuePush(empty,QueueFront(noempty));
        QueuePop(noempty);
    }
    QueueDataType top=QueueFront(noempty);
    QueuePop(noempty);
    return top;
}

int myStackTop(MyStack* obj) {
    if(!QueueEmpty(&(obj->q1)))
    {
        return QueueBack(&(obj->q1));
    }
    else
    {
        return QueueBack(&(obj->q2));
    }
}

bool myStackEmpty(MyStack* obj) {
    assert(obj);
    return QueueEmpty(&(obj->q1)) && QueueEmpty(&(obj->q2));
}

void myStackFree(MyStack* obj) {
    assert(obj);
    QueueDestory(&(obj->q1));
    QueueDestory(&(obj->q2));
    free(obj);
    obj=NULL；
}

四.循环队列

. - 力扣（LeetCode）

1.定义：一种线性结构，基于先进先出原则，将队尾与队头连接起来构成循环

2.特点：有限空间，保证先进先出，从重复使用

3.思路：可以用数组实现，也可以用链表实现

用数组实现较为简单，用链表实现比较困难，下面小编将从两个角度来解释原因：

1>若使用单链表，在删除数据时不好获取待删除数据的前一个节点的位置，无法实现队尾的改变

2>若使用双向链表，占用内存太大，而且此时在判空判满时需要比较两个节点的地址比较麻烦

4.代码实现(以数组实现为例)：

(1)循环队列的结构体定义：数组指针，队头的下标，队尾下一个数据的下标，空间的大小

typedef struct {
    int* a;
    int head;//指向头
    int rear;//指向尾的下一个
    int k;//空间大小
} MyCircularQueue;

(2)循环队列的创建：

1>为循环队列malloc一块空间，防止出函数时，结构体被销毁

2>由于rear指向队尾的下一个数据，若直接开辟指定大小的空间，在插入最后一个数据时，rear会越界访问，此时我们称该情况为假溢出现象，为了解决假溢出我们可以采取以下两种措施

【1】为数组多开一块空间

【2】

MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* pc=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    
    //多开一块空间，解决假溢出问题
    pc->a=(int*)malloc(sizeof(int)*(k+1));
    pc->head=0;
    pc->rear=0;
    pc->k=k;
    return pc;
}

(3)循环队列的销毁：先销毁为数组开辟的空间，再销毁循环队列

void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    obj->a=NULL;
    free(obj);
    obj=NULL;
}

(4)循环队列的判空：

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    assert(obj);
    //头与尾的下一个指向同一位置即为空
    return obj->head==obj->rear;
}

(5)循环队列的判满：

bool myCircularQueueIsFull(MyCircularQueue* obj) {

    assert(obj);
    //尾的下一个和头指向的位置相同即为满
    return obj->head==(obj->rear+1)%(obj->k+1);
}

(6)循环队列插入数据：在队尾插入数据，让rear向后走一步，为了避免rear++后越界访问，需要将自增后的rear模上k+1，使其在有效下标内且可以完成循环

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    assert(obj);
    if(myCircularQueueIsFull(obj))
    {
        return false;
    }
    obj->a[obj->rear]=value;
    obj->rear++;
    obj->rear%=(obj->k+1);
    return true;
}

(7)循环队列删除数据：删除队头数据，让head向后走一步，为了避免head++后越界访问，需要将自增后的head模上k+1，使其在有效下标内且可以完成循环(原理同上，就不再赘述了)

ool myCircularQueueDeQueue(MyCircularQueue* obj) {
    assert(obj);
    if(myCircularQueueIsEmpty(obj))
    {
        return false;
    }

    obj->head++;
    obj->head%=(obj->k+1);
    return true;
}

(8)获取队尾元素：


int myCircularQueueRear(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else
    {
        return obj->rear==0?obj->a[obj->k]:obj->a[obj->rear-1];
    }
}

(9)获取队头元素：

int myCircularQueueFront(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else
    {
        return obj->a[obj->head];
    }
}

level_xiwei
关注
  • 17
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构——栈与队列
m0_57484470的博客
10-17 6198
数据结构栈与队列相关基础知识详解！！！
数据结构之栈与队列详解
Ruiren_的博客
01-20 1804
栈和队列是一种特殊的线性结构，他与之前学的线性结构不同，栈和队列是拥有一种特殊规则的线性结构，虽然它是用数组或者链表实现，但是只有符合这种规则才能被称作栈或者队列
[详解栈和队列]数据结构之栈与队列
Philosophy7的博客
05-12 3618
✅作者简介：大家好,我是Philosophy7？让我们一起共同进步吧！🏆 📃个人主页：Philosophy7的csdn博客 🔥系列专栏： 👑哲学语录: 承认自己的无知，乃是开启智慧的大门 💖如果觉得博主的文章还不错的话，请点赞👍+收藏⭐️+留言📝支持一下博>主哦🤞 文章目录栈和队列1.物理结构和逻辑结构2.什么是栈2.1栈的基本操作3.什么是队列队列的基本操作小结 栈和队列 1.物理结构和逻辑结构 再了解栈和队列之前，我们要先知道什么是逻辑结构和物理结构。 逻辑结构: 按照逻辑结构划分:数据结.
数据结构：栈和队列(Stack & Queue)【详解】
热门推荐
UniqueUnit的博客
02-19 21万+
栈和队列知识框架 栈 一、栈的基本概念 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为先进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：
数据结构之栈与队列浅谈
wahkim的博客
12-14 1032
栈(Stack)和队列(Queue) 栈和队列，也属于线性表，都用于存储逻辑关系为 “一对一” 的数据。 栈也可分为顺序栈和链表，队列也分为顺序队列和链队列。 栈(Stack) 栈同顺序表和链表一样，栈也是用来存储逻辑关系为 “一对一” 数据的线性存储结构，且遵循"先进后出(FILO)"原则。 如下图所示： 有图 栈只能从表的一端存取数据，另一端是封闭的。 在栈中，无论是存数据还是取数据，都必须遵循"先进后出"的原则，即最先进栈的元素最后出栈。从图中可看出数据的存储状态，元素 1 是最先进的栈。因此，
Java数据结构之栈和队列
fear_wolf的博客
10-24 1040
我们可以从集合那一节的图中看出，Stack继承了Vector，Vector和ArrayList类似，都是动态的顺序表，不同的是Vector是线程安全的。我们可以采用头插法来入栈，每次出栈时删除的也是头节点，时间复杂度也是O（1），但仍没有顺序栈方便，毕竟顺序栈不用修改指向。：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有。，队不为空时，rear都是front之后，随着入队出队的操作，最终。：栈的插入操作，叫做进栈/压栈/入栈，入数据在栈顶。
数据结构与算法——栈和队列
小田是个程序员的博客欢迎你的到来呀~
06-25 1万+
栈和队列是两种重要的线性结构，本篇文章详细总结了数据结构与算法中栈和队列的终点知识，并且结合代码片段实现其基本操作，干货满满，每一句话都是重点，希望能给更多的小伙伴在学习数据结构与算法时带来一定帮助...
数据结构之栈和队列
weixin_45699237的博客
02-19 2665
1、栈 1.1 概念 栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈 顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。 出栈：栈的删除操作叫做出栈。出数据在栈顶。 ...
【第三节】C/C++数据结构之栈与队列
攻城狮7号的博客
06-05 1530
栈(Stack)可以看成是一种特殊的线性表。限定仅只能在表尾端进行插入和删除的线性表。栈顶：表尾端被称之为栈顶。栈底：和表尾相对应的另一端，称之为栈底。时间有序表：LIFO （Last In First Out）后进先出特征的线性结构。public:AbsStack ( ) { } // 默认构造函数virtual ~ AbsStack ( ) { } // 析构函数// 判栈空吗？// 判栈满吗？//将栈清空。//新结点进栈。// 栈顶结点出栈。
Python常见数据结构之栈与队列用法示例
09-19
主要介绍了Python常见数据结构之栈与队列用法,结合实例形式简单介绍了数据结构中栈与队列的概念、功能及简单使用技巧,需要的朋友可以参考下
java 数据结构之栈与队列
08-29
主要介绍了java 数据结构之栈与队列的相关资料,这里对java中的栈和队列都做出实现实例来帮助大家理解学习数据结构，需要的朋友可以参考下
数据结构-栈与队列
01-07
数据结构-栈与队列一、顺序栈1.顺序栈的定义2：入栈二、顺序队列1：顺序栈的定义2：入队3：出队三、链队列1：链队列的定义：2：入队3：出队 一、顺序栈 1.顺序栈的定义 #define MaxSize 64 /* const int MaxSize =64...
数据结构栈和队列试题及答案
11-26
栈和队列考试题 复习 栈和队列考试题 复习栈和队列考试题 复习
鸿蒙轻内核A核源码分析系列二 数据结构-位图操作
maniuT的博客
06-11 1035
位操作模块提供对32位无符号整数数值的bit位进行操作，bit位取值为0-31，以0开始计算，从左向右，第0位，第1位。。。第31位等。⑴处定义的宏如下，也就是十进制31。如果传入的比特位pos大于31，会通过逻辑与运算截断，只取低5位，确保不会大于31，避免溢出。⑵处定义的位图掩码全是1。在文件中定义了常用的位操作相关的宏。宏根据参数x计算出需要操作第几个状态字，由于计算状态字的使用的是UINTPTR，状态字可以是32位、也可以是64位。后文，我们默认以32位进行讲解。宏传入的参数是位操作的开始bit。
数据结构--第七章--树和二叉树
2302_80052051的博客
06-11 309
前序+中序可以确定一个二叉树；中序+后序可以确定一个二叉树。，将数据元素组织成层次结构，元素间属于。二叉树的定义是递归定义。
数据结构--线性表和串
code袁的博客
06-08 815
🦁作者简介：一名喜欢分享和记录学习的在校大学生💥个人主页code袁💥个人QQ🐯个人wechat：code8896线性表是一种常见的数据结构，它是具有相同数据类型的有限序列。线性表中的元素之间存在一种顺序关系，可以通过元素在表中的位置来访问和操作。串是由零个或多个字符组成的有限序列，也可以理解为字符串。串是计算机科学中最基本的数据类型之一，常用于表示文本信息。手动码字，如有错误，欢迎在评论区指正💬~你的支持就是我更新的最大动力💪~
数据结构 -- 树状数组
gghhb12的博客
06-09 1200
树状数组或二叉索引树（Binary Indexed Tree），又以其发明者命名为 Fenwick 树。其初衷是解决数据压缩里的累积频率的计算问题，现多用于高效计算数列的前缀和、区间和。它可以以 O(logn) 的时间得到任意前缀和。并同时支持在 O(logn) 时间内支持动态单点值的修改。空间复杂度 O(n)。具体区别和联系如下：1.两者在复杂度上同级, 但是树状数组的常数明显优于线段树, 其编程复杂度也远小于线段树.
【算法与数据结构】【数组篇】【题6-题10】
最新发布
handsomethefirst的博客
06-11 1163
首先，是一个递增排序，那么我们可以知道头尾相加，判断最大值和最小值的和是否等于目标值，如果大于目标值，则说明我们值找大了，那就要找到次第二最大值，作为新区间的最大值，然后继续判断是否等于目标值。当为偶数的时候，如果x+y=i，i的值小于最大的行数，代表坐标x从i开始，y从0开始，如果i大于等于最大的行数，代表坐标x从m开始，y=i-m开始。当为奇数的时候，如果x+y=i，i的值小于最大的列数，代表坐标y从i开始，x从0开始, 如果i大于等于最大的列数，代表坐标y从n开始，x=i-n开始。
数据结构栈与队列实验
05-22
数据结构中，栈和队列都是非常重要的线性数据结构，它们都可以通过数组和链表来实现。在实验中，我们可以通过编写程序来实现栈和队列的基本操作，从而更好地理解它们的实现原理和使用方法。 在栈实验中，我们通常会...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值