数据结构—栈和队列

最新推荐文章于 2024-08-28 23:47:14 发布
最新推荐文章于 2024-08-28 23:47:14 发布
阅读量341 收藏 3
点赞数 2
分类专栏： Data Structure 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/IfYouHave/article/details/129541659
版权

640?wx_fmt=jpeg

目录

1.栈

1.1栈的概念及结构

1.2栈的实现

 1.2.1、数组实现栈结构

1.2.2、初始化栈void StackInit(Stack* ps);

1.2.3、栈的销毁void StackDestroy(Stack* ps)

1.2.4、入栈void StackPush(Stack* ps, STDataType x)

1.2.5、出栈void StackPop(Stack* ps)

1.2.6、获取栈顶元素STDataType StackTop(Stack* ps)

1.2.7、检测栈是否为空，如果为空返回true，如果不为空返回false bool StackEmpty(Stack* ps)

2.队列

2.1队列的概念及结构

2.2队列queue的实现

3.栈和队列面试题

1. 括号匹配问题。

2. 用队列实现栈。

3. 用栈实现队列。

4. 设计循环队列。

4.概念选择题

1.栈

1.1栈的概念及结构

栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端 称为栈顶，另一端称为栈底。

栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。

压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。

出栈：栈的删除操作叫做出栈。出数据也在栈顶。

1.2栈的实现

栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小。

 

 1.2.1、数组实现栈结构

//下面是定长的静态栈的结构，实际中一般不实用，
//所以我们主要实现下面的支持动态增长的栈
//#define N 10
//typedef int STDataType;
//typedef struct Stack
//{
//	STDataType data[N];
//	int top;
//	int capacity;
//}Stack;

// 支持动态增长的栈
typedef int STDataType;
typedef struct Stack
{
	STDataType* data;
	int top;			//栈顶
	int capacity;		//容量
}Stack;

1.2.2、初始化栈
void StackInit(Stack* ps);

//初始化栈
void StackInit(Stack* ps)
{
	assert(ps);
	ps->data = NULL;
	ps->top = 0;
	ps->capacity = 0;
}

1.2.3、栈的销毁
void StackDestroy(Stack* ps)

//栈的销毁
void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->data);
	ps->data = NULL;
	ps->top = ps->capacity = 0;
}

1.2.4、入栈
void StackPush(Stack* ps, STDataType x)

void StackPush(Stack* ps, STDataType x)
{
	assert(ps);
	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->data, sizeof(STDataType) * newcapacity);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		ps->data = tmp;
		ps->capacity = newcapacity;
	}
	ps->data[ps->top] = x;
	++ps->top;
}

1.2.5、出栈
void StackPop(Stack* ps)

//出栈
void StackPop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	ps->top--;
}

1.2.6、获取栈顶元素
STDataType StackTop(Stack* ps)

//获取栈顶元素
STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	return ps->data[ps->top - 1];
}

1.2.7、检测栈是否为空，如果为空返回true，如果不为空返回false 
bool StackEmpty(Stack* ps)

// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
bool StackEmpty(Stack* ps)
{
	assert(ps);
	if (ps->top == 0)
	{
		return true;
	}
	return false;
}

2.队列

2.1队列的概念及结构

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出 FIFO(First In First Out) 入队列：进行插入操作的一端称为队尾 出队列：进行删除操作的一端称为队头

2.2队列queue的实现

队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数 组头上出数据，效率会比较低。

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
// 链式结构：表示队列
typedef int QDataType;
typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;
	
}QNode;
//队列结构
typedef struct Queue
{
	QNode* head;
	QNode* tail;
	//int size;
}Queue;

// 初始化队列
void QueueInit(Queue* pq);
// 销毁队列
void QueueDestroy(Queue* pq);

// 队尾入队列
void QueuePush(Queue* pq, QDataType data);
// 队头出队列
void QueuePop(Queue* pq);

// 获取队列头部元素
QDataType QueueFront(Queue* pq);
// 获取队列队尾元素
QDataType QueueBack(Queue* pq);

// 获取队列中有效元素个数
int QueueSize(Queue* pq);
// 检测队列是否为空，如果为空true，如果非空false 
bool QueueEmpty(Queue* pq);
#include"Queue.h"

// 初始化队列
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = pq->tail = NULL;
}
// 销毁队列
void QueueDestroy(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	while (cur)
	{
		pq->head = pq->head->next;
		free(cur);
		cur = pq->head;
	}
	pq->head = pq->tail = NULL;
}

// 队尾入队列
void QueuePush(Queue* pq, QDataType data)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	newnode->data = data;
	newnode->next = NULL;
	if (pq->tail == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
}
// 队头出队列
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	if (pq->head->next == NULL)
	{

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

// 获取队列头部元素
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->head->data;

}
// 获取队列队尾元素
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->tail->data;
}

// 获取队列中有效元素个数
int QueueSize(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	int size = 0;
	while (cur)
	{
		size++;
		cur = cur->next;
	}
	return size;
}

// 检测队列是否为空，如果为空true，如果非空false 
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	if (pq->head == NULL)
	{
		return true;
	}
	return false;
}

另外扩展了解一下，实际中我们有时还会使用一种队列叫循环队列。如操作系统课程讲解生产者消费者模型 时可以就会使用循环队列。环形队列可以使用数组实现，也可以使用循环链表实现。

3.栈和队列面试题

1. 括号匹配问题。

Loading Question... - 力扣（LeetCode）https://leetcode.cn/problems/valid-parentheses/

 左括号入栈，右括号出栈


// 支持动态增长的栈
typedef char STDataType;
typedef struct Stack
{
	STDataType* data;
	int top;			//栈顶
	int capacity;		//容量
}Stack;

//初始化栈
void StackInit(Stack* ps);

//栈的销毁
void StackDestroy(Stack* ps);

//入栈
void StackPush(Stack* ps,STDataType x);
//出栈
void StackPop(Stack* ps);

//获取栈顶元素
STDataType StackTop(Stack* ps);

// 获取栈中有效元素个数
int StackSize(Stack* ps);

// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
bool StackEmpty(Stack* ps);
//初始化栈
void StackInit(Stack* ps)
{
	assert(ps);
	ps->data = NULL;
	ps->top = 0;
	ps->capacity = 0;
}

//栈的销毁
void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->data);
	ps->data = NULL;
	ps->top = ps->capacity = 0;
}

//入栈
void StackPush(Stack* ps, STDataType x)
{
	assert(ps);
	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->data, sizeof(STDataType) * newcapacity);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		ps->data = tmp;
		ps->capacity = newcapacity;
	}
	ps->data[ps->top] = x;
	++ps->top;
}
//出栈
void StackPop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	ps->top--;
}

//获取栈顶元素
STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	return ps->data[ps->top - 1];
}

// 获取栈中有效元素个数
int StackSize(Stack* ps)
{
	assert(ps);
	return ps->top;
}

// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
bool StackEmpty(Stack* ps)
{
	assert(ps);
	if (ps->top == 0)
	{
		return true;
	}
	return false;
}

bool isValid(char * s){
    Stack sk;
    StackInit(&sk);
    while(*s)
    {
        if(*s == '(' || *s == '{' || *s == '[')
        {
            StackPush(&sk,*s);
            ++s;
        }
        else
        {
            if(StackEmpty(&sk))
            {
                StackDestroy(&sk);
                return false;
            }
            STDataType top1 = StackTop(&sk);
            StackPop(&sk);
            if(top1 == '{' && *s == '}'
            ||top1 == '[' && *s == ']'
            ||top1 == '(' && *s == ')')
            {
                ++s;
            }
            else
            {
                StackDestroy(&sk);
                return false;
            }
        }
    }
    bool ret = StackEmpty(&sk);
    StackDestroy(&sk);
    return ret;
}

2. 用队列实现栈。

利用两个队列，实现栈：

  1. 由于队列先进先出，栈先进后出，
  2. 因此当入栈时，使其入一个队列
  3. 出栈时，将不为空的队列前 n -1 个元素入到空队列，此时不为空的队列变为栈顶元素，进行出队，即出栈 
  4. 获取栈顶元素，只需要返回不为空队列的队尾
  5. 判断栈是否为空只需要判断两队列是否为空
  6. 栈的销毁，首先销毁两个队列，其次销毁栈区

225. 用队列实现栈 - 力扣（LeetCode）https://leetcode.cn/problems/implement-stack-using-queues/

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
// 链式结构：表示队列
typedef int QDataType;
typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;
	
}QNode;
//队列结构
typedef struct Queue
{
	QNode* head;
	QNode* tail;
	//int size;
}Queue;

// 初始化队列
void QueueInit(Queue* pq);
// 销毁队列
void QueueDestroy(Queue* pq);

// 队尾入队列
void QueuePush(Queue* pq, QDataType data);
// 队头出队列
void QueuePop(Queue* pq);

// 获取队列头部元素
QDataType QueueFront(Queue* pq);
// 获取队列队尾元素
QDataType QueueBack(Queue* pq);

// 获取队列中有效元素个数
int QueueSize(Queue* pq);
// 检测队列是否为空，如果为空true，如果非空false 
bool QueueEmpty(Queue* pq);


// 初始化队列
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = pq->tail = NULL;
}
// 销毁队列
void QueueDestroy(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	while (cur)
	{
		pq->head = pq->head->next;
		free(cur);
		cur = pq->head;
	}
	pq->head = pq->tail = NULL;
}

// 队尾入队列
void QueuePush(Queue* pq, QDataType data)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	newnode->data = data;
	newnode->next = NULL;
	if (pq->tail == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
}
// 队头出队列
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	if (pq->head->next == NULL)
	{

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

// 获取队列头部元素
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->head->data;

}
// 获取队列队尾元素
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->tail->data;
}

// 获取队列中有效元素个数
int QueueSize(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	int size = 0;
	while (cur)
	{
		size++;
		cur = cur->next;
	}
	return size;
}

// 检测队列是否为空，如果为空true，如果非空false 
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	if (pq->head == NULL)
	{
		return true;
	}
	return false;
}



typedef struct {
    Queue q1;
    Queue q2;

} MyStack;


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

    return obj;
}

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

int myStackPop(MyStack* obj) {
    Queue* emptQ = &obj->q1;
    Queue* nonEmptyQ = &obj->q2;
    if(!QueueEmpty(&obj->q1))
    {
        emptQ = &obj->q2;
        nonEmptyQ = &obj->q1;
    }
    while(QueueSize(nonEmptyQ) > 1 )
    {
         QueuePush(emptQ,QueueFront(nonEmptyQ));
         QueuePop(nonEmptyQ);
    }
    int top = QueueFront(nonEmptyQ);
    QueuePop(nonEmptyQ);
    return top;
}

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

bool myStackEmpty(MyStack* obj) {
    if(QueueEmpty(&obj->q1) == true && QueueEmpty(&obj->q2) == true)
    {
        return true;
    }
    return false;
}

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

/**
 * Your MyStack struct will be instantiated and called as such:
 * MyStack* obj = myStackCreate();
 * myStackPush(obj, x);
 
 * int param_2 = myStackPop(obj);
 
 * int param_3 = myStackTop(obj);
 
 * bool param_4 = myStackEmpty(obj);
 
 * myStackFree(obj);
*/

3. 用栈实现队列。

232. 用栈实现队列 - 力扣（LeetCode）https://leetcode.cn/problems/implement-queue-using-stacks/

// 支持动态增长的栈
typedef char STDataType;
typedef struct Stack
{
	STDataType* data;
	int top;			//栈顶
	int capacity;		//容量
}Stack;

//初始化栈
void StackInit(Stack* ps);

//栈的销毁
void StackDestroy(Stack* ps);

//入栈
void StackPush(Stack* ps,STDataType x);
//出栈
void StackPop(Stack* ps);

//获取栈顶元素
STDataType StackTop(Stack* ps);

// 获取栈中有效元素个数
int StackSize(Stack* ps);

// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
bool StackEmpty(Stack* ps);
//初始化栈
void StackInit(Stack* ps)
{
	assert(ps);
	ps->data = NULL;
	ps->top = 0;
	ps->capacity = 0;
}

//栈的销毁
void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->data);
	ps->data = NULL;
	ps->top = ps->capacity = 0;
}

//入栈
void StackPush(Stack* ps, STDataType x)
{
	assert(ps);
	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->data, sizeof(STDataType) * newcapacity);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		ps->data = tmp;
		ps->capacity = newcapacity;
	}
	ps->data[ps->top] = x;
	++ps->top;
}
//出栈
void StackPop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	ps->top--;
}

//获取栈顶元素
STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	return ps->data[ps->top - 1];
}

// 获取栈中有效元素个数
int StackSize(Stack* ps)
{
	assert(ps);
	return ps->top;
}

// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
bool StackEmpty(Stack* ps)
{
	assert(ps);
	if (ps->top == 0)
	{
		return true;
	}
	return false;
}

typedef struct {
    Stack pushst;
    Stack popst;
} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
 
    StackInit(&obj->pushst);
    StackInit(&obj->popst);
    return obj;
}

void myQueuePush(MyQueue* obj, int x) {
        StackPush(&obj->pushst,x);
}

int myQueuePop(MyQueue* obj) {
    if(StackEmpty(&obj->popst))
    {
     while(!StackEmpty(&obj->pushst))
     {
        StackPush(&obj->popst,StackTop(&obj->pushst));
        StackPop(&obj->pushst);
     }
    }
    int tmp = StackTop(&obj->popst);
    StackPop(&obj->popst);
    return tmp;
}

int myQueuePeek(MyQueue* obj) {
    if(StackEmpty(&obj->popst))
    {
        while(!StackEmpty(&obj->pushst))
        {
            StackPush(&obj->popst,StackTop(&obj->pushst));
            StackPop(&obj->pushst);
        }
    }
    return StackTop(&obj->popst);
}

bool myQueueEmpty(MyQueue* obj) {
    return StackEmpty(&obj->pushst) && StackEmpty(&obj->popst);

}

void myQueueFree(MyQueue* obj) {
    StackDestroy(&obj->pushst);
    StackDestroy(&obj->popst);
    free(obj);
}

/**
 * Your MyQueue struct will be instantiated and called as such:
 * MyQueue* obj = myQueueCreate();
 * myQueuePush(obj, x);
 
 * int param_2 = myQueuePop(obj);
 
 * int param_3 = myQueuePeek(obj);
 
 * bool param_4 = myQueueEmpty(obj);
 
 * myQueueFree(obj);
*/

4. 设计循环队列。

622. 设计循环队列 - 力扣（LeetCode）https://leetcode.cn/problems/design-circular-queue/

typedef struct {
    int front;
    int rear;
    int * data;
    int size;
    int maxsize;
} MyCircularQueue;

// 构造
MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* Q = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    Q->data = (int*)malloc(sizeof(int) * k);
    Q->front = 0;
    Q->rear = 0;
    Q->size = 0;
    Q->maxsize = k;
    return Q;
}

// 入队
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    // 队满
    if( obj->size == obj->maxsize ){ return 0; }
    obj->data[obj->rear++] = value;
    obj->size++;
    if(obj->rear >= obj->maxsize){
        obj->rear %= obj->maxsize;
    }
    return 1;
}

// 出队
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    // 队空
    if( obj->size == 0 ){ return 0; }
    obj->front = (obj->front + 1) % obj->maxsize;
    obj->size--;
    return 1;
}

// 取队头
int myCircularQueueFront(MyCircularQueue* obj) {
    if(obj->size == 0){ return -1; }
    return obj->data[obj->front];
}

int myCircularQueueRear(MyCircularQueue* obj) {
    if(obj->size == 0){ return -1; }
    if(obj->rear == 0){
        return obj->data[obj->maxsize-1];
    }
    return obj->data[obj->rear-1];
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return !obj->size;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return obj->size == obj->maxsize;
}

void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->data);
    free(obj);
}

4.概念选择题

1.一个栈的初始状态为空。现将元素1、2、3、4、5、A、B、C、D、E依次入栈，然后再依次出栈，则元素出
栈的顺序是（ ）。
A 12345ABCDE
B EDCBA54321
C ABCDE12345
D 54321EDCBA

2.若进栈序列为 1,2,3,4 ，进栈过程中可以出栈，则下列不可能的一个出栈序列是（）
A 1,4,3,2
B 2,3,4,1
C 3,1,4,2
D 3,4,2,1
 
3.循环队列的存储空间为 Q(1:100) ，初始状态为 front=rear=100 。经过一系列正常的入队与退队操作
后， front=rear=99 ，则循环队列中的元素个数为（ ）
A 1
B 2
C 99
D 0或者100

4.以下( )不是队列的基本运算？
A 从队尾插入一个新元素
B 从队列中删除第i个元素
C 判断一个队列是否为空
D 读取队头元素的值


5.现有一循环队列，其队头指针为front，队尾指针为rear；循环队列长度为N。其队内有效长度为？(假设
队头不存放数据)
A (rear - front + N) % N + 1
B (rear - front + N) % N
C ear - front) % (N + 1)
D (rear - front + N) % (N - 1)
1.B
2.C
3.D
4.B
5.B

IfYouHave
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
栈和队列
HHHuYYYue的博客
05-14 244
在学习数据结构的时候, 相信大家印象最为深刻的就是栈和队列了吧. 下面我就介绍一下栈和队列吧 1. 栈(Stack) 1.1 栈的概念 栈是一种特殊的线性表, 它只允许在一端进行插入和删除的操作 栈又分为栈顶和栈底 对栈的所有操作都是在栈顶进行的. 栈中的元素必须遵守先进后出的原则: 即先进栈的数据后出栈, 后进栈的数据先出栈. 1.2 进栈和出栈 1.3 栈的实现 由于Java本身就已经封装好了一个 Stack 的类, 因此, 可以直接调用 Stack 中的方法. 如果想要自己实现一个栈, 我们可以通
数据结构——栈和队列
奇蠢无比の二琦的博客
11-13 258
一、特殊线性表——栈 1.栈的逻辑结构 ①栈：限定仅在表尾进行插入和删除操作的线性表。 允许插入和删除的一端称为栈顶，另一端称为栈底。 栈的特殊操作：后进先出。 ②栈只是对表插入和删除操作的位置进行了限制，并没有限定插入和删除操作进行的时间。 ③栈的抽象数据类型定义 ADT Stack Data 栈中元素具有相同类型及后进先出特性， 相邻元素具有前驱和后继关系 Operation InitStac...
数据结构 栈和队列
qq_52847866的博客
06-15 4189
5. 访问效率：顺序存储结构的元素在内存中是连续存储的，对于 CPU 缓存等硬件有较好的利用效率，因此在访问速度上可能更快。特殊矩阵的压缩存储可以大幅减少存储空间的占用，提高存储效率，并在某些情况下加速矩阵的运算和操作。需要注意的是，多维数组的存储方式可能会影响程序的性能，特别是对于大型多维数组和对数组访问频繁的场景。总之，栈和队列都是重要的数据结构，在不同的应用场景中发挥着关键的作用。栈和队列都是常见的数据结构，可以使用不同的存储结构进行实现，包括顺序存储结构和链式存储结构。函数判断栈是否为空。
数据结构栈和队列
m0_65185254的博客
10-28 4138
数据结构作业
数据结构栈和队列试题及答案
11-26
### 数据结构之栈和队列知识点详解 #### 一、选择题知识点解析 1. **栈的操作原则** 栈是一种特殊的线性表，它只允许在一端进行插入和删除操作，这一端称为栈顶(top)。另一端称为栈底(bottom)，不允许在其上进行...
数据结构栈和队列相关习题及答案
04-20
数据结构栈和队列相关习题及答案
数据结构栈和队列（参考代码）
06-18
### 数据结构栈和队列知识点解析 #### 一、栈的基本概念与操作 **栈**是一种特殊的线性表，只允许在一端进行插入和删除操作，这一端被称为栈顶，另一端被称为栈底。栈遵循先进后出（First In Last Out, FILO）的...
数据结构栈和队列练习题答案.doc
04-02
数据结构
数据结构栈和队列解决迷宫问题
06-07
数据结构栈和队列解决迷宫问题 本文档详细介绍了利用栈和队列解决迷宫问题的步骤，对于初学者学习数据结构能很好的进行辅导。本文档主要涉及到数据结构的两个重要概念：栈和队列，并介绍了如何使用这两个数据结构来...
数据结构
2301_80184169的博客
08-28 389
4.执行代码,复现段错误,产生包含出错信息的core文件(检查core文件是否生成)3.ulimit -c unlimited 不限制core文件的生成的大小。使用这种方法能够很好的解决段错误，在纠正和优化代码时效率显著提升。1.首先按照如下的方法配置Ubuntu，允许生成core文件。5.gdb a.out core 查看段错误产生的位置。2.重新编译代码并加入-g选项(允许进行GDB调试)
25版王道数据结构课后习题详细分析 第五章 树与二叉树 5.4 树、森林
2406_86301373的博客
08-26 446
解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：正确答案：解析：
Python-MNE-源定位和逆问题01：源估计（SourceEstimate）数据结构
weixin_58312922的博客
08-25 635
stc是MNE-Python的一个类，表示从源估计中获得的转换的时间序列。对于两个半球，数据分别存储在和中，储存形式为的形式为一个m*n的矩阵，m是这个半球的空间位置的数量，n是时间点的个数。和对应和。这些是表面表征的位置索引。表面的坐标存储在和中，分别表示左半球和右半球。
【数据结构】队列(Queue)
xiaochuan_bsj的博客
08-28 462
数组，双链表实现队列，附完整代码
数据结构（邓俊辉）学习笔记】串 10——BM_BC算法：坏字符
最新发布
weixin_44399845的博客
08-28 549
BM_BC算法：坏字符
【高阶数据结构】秘法（一）——并查集：探索如何高效地管理集合
2301_80220607的博客
08-28 1266
【高阶数据结构】秘法一：并查集——探讨如何高效管理数据，图算法进修第一步
Linux 数据结构 链表
mxyzhy的博客
08-28 134
单向链表操作
数据结构——单向链表
m0_61965705的博客
08-28 554
算法：快指针先走k步，慢指针和快指针每次走1步(快指针总是领先慢指针k步)，当快指针走到末尾时,慢指针即指向链表倒数第k个节点。无头单向链表，节点插入在头的话，每次头结点都会变，所以有了有头链表，头结点的pNext总是指向链表的第一个节点。算法：快指针pFast每次走2步，慢指针pSlow每次走1步，快指针到达末尾时，慢指针所在的位置即为中间位置。因为快指针第一次比慢指针多1，第二次快指针比慢指针快2，依次类推，环长一定是一个自然数，所以一定能相遇。每次选出最小的，第二小的...最大的，
数据结构 链表
2301_79898193的博客
08-28 196
1.链表可以动态的增加或者减少节点，而顺序表在一开始就定义了大小，扩展或缩小数组会涉及内存的重新分配，效率低下；2.插入和删除效率 链表更容易时间复杂度为O（1），顺序表需要整个移动大量资源时间复杂度为O(n);3.链表的内存可以是碎片化不连续的内存，而顺序表一定是需要连续的内存，会出现浪费行为。数据量增长与程序运行时间的比例关系以函数描述称为时间渐进复杂度函数,简称时间复杂度。3.链表空间不连续,使得理论上长度是无限的。2.链表需要更大的空间存放数据和节点地址。4.链表的插入和删除效率很高。
数据结构栈和队列：基本运算与应用
"队列的基本运算-数据结构栈和队列PP" 在计算机科学中，数据结构是组织和存储数据的方式，以便高效地访问和修改。本资源主要关注两种特殊的数据结构：栈和队列，它们都是线性数据结构的变体。 栈是一种“后进先出...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值