[数据结构]栈和队列面试题解析

已于 2022-11-16 11:54:50 修改
阅读量646 收藏 10
点赞数 19
分类专栏： 数据结构 文章标签： 数据结构 算法 leetcode
于 2022-11-16 10:41:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_59456417/article/details/127880587
版权

作者： 华丞臧.
专栏：【数据结构】
各位读者老爷如果觉得博主写的不错，请诸位多多支持(点赞+收藏+关注)。如果有错误的地方，欢迎在评论区指出。
推荐一款刷题网站 👉 LeetCode刷题网站

文章目录

一、有效括号

题目描述

LeetCode.20 有效的括号
给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

  1. 左括号必须用相同类型的右括号闭合。
  2. 左括号必须以正确的顺序闭合。
  3. 每个右括号都有一个对应的相同类型的左括号。

在这里插入图片描述

解题思路

我们知道在一个式子当中后出现的左括号要与先出现的右括号配对；那么对于左括号而言，就是先入后出符合栈的特性，所以我们用栈来存储左括号；当遇到右括号时，判断栈顶的括号和该右括号是否配对，如果配对成功则出栈栈顶元素，否则配对失败则return false,这样既保证了相同类型又保证了顺序闭合；当遍历完传入的字符串时，还需要检查栈中是否为空。

代码实现

typedef char STDataType;

typedef struct Stack
{
	STDataType* data;
	int top;
	int capacity;
}ST;


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

//销毁栈
void StackDestroy(ST* ps);

//入栈
void StackPush(ST* ps, STDataType x);

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

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

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

//检查栈是否为空，如果为空返回非0结果，如果不为空返回0
bool StackEmpty(ST* ps);

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

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

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


//入栈
void StackPush(ST* 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, newCapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		ps->data = tmp;
		ps->capacity = newCapacity;
	}
	ps->data[ps->top] = x;
	ps->top++;
}


//出栈
void StackPop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));

	ps->top--;
}


//获取栈顶元素
STDataType StackTop(ST* ps) 
{
	assert(ps);
	assert(!StackEmpty(ps));

	return ps->data[ps->top - 1];
}


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

	return ps->top;
}


//检查栈是否为空，如果为空返回非0结果，如果不为空返回0
bool StackEmpty(ST* ps)
{
	assert(ps);

	/*if (ps->top == 0)
	{
		return true;
	}
	else
	{
		return false;
	}*/

	return ps->top == 0;
}

bool isValid(char* s)
{
    ST pst;
    StackInit(&pst);
    char* cur = s;

    while(*cur)
    {
        if(*cur == '(' || *cur == '{' || *cur == '[')
        {
            StackPush(&pst,*cur);
        }
        else
        {
            if(StackEmpty(&pst))
            {
                StackDestroy(&pst);
                return false;
            }
            char tmp = StackTop(&pst);
            StackPop(&pst);
            if((*cur == '}' && tmp != '{')
            || (*cur == ']' && tmp != '[')
            || (*cur == ')' && tmp != '('))
            {
                StackDestroy(&pst);
                return false;
            }
        }
    cur++;
    }

   bool flag = StackEmpty(&pst);
    StackDestroy(&pst);
    return flag;
}

二、用队列实现栈

题目描述

LeetCode.225 用队列实现栈
请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

实现 MyStack 类：

  • void push(int x) 将元素 x 压入栈顶。
  • int pop() 移除并返回栈顶元素。
  • int top() 返回栈顶元素。
  • boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。

在这里插入图片描述

解题思路

队列是先入先出，而栈是先入后出。
用两个队列实现栈，进行入栈操作时把数据放入不为空的队列(两个队列都为空则随意)；出栈时，把不为空的队列中元素倒入另一个为空的队列，只留一个元素，然后再返回这个元素的值并且删除该元素。只有两个队列都为空时，栈才为空；销毁时，注意要先销毁队列再销毁用队列实现的栈。
出队列：
在这里插入图片描述

代码实现

typedef int QDataType;

typedef struct QListNode
{
	struct QListNode* next;
	QDataType data;
}QLNode;

typedef struct Queue
{
	QLNode* head;
	QLNode* tail;
	int size;
}QE;

//初始化队列
void QueueInit(QE* q);

//队尾入队列
void QueuePush(QE* q,QDataType x);

//队头出队列
void QueuePop(QE* q);

//获取队列头部元素
QDataType QueueFront(QE* q);

//获取队列队尾元素
QDataType QueueBack(QE* q);

//获取队列有效元素个数
int QueueSize(QE* q);

//检查队列是否为空，如果为空返回非0数，如果不为空返回0
bool QueueEmpty(QE* q);

//销毁队列
void QueueDestroy(QE* q);

//申请一个结点
QLNode* BuyQListNode(QDataType x);

//初始化队列
void QueueInit(QE* q)
{
	assert(q);

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


//申请一个结点
QLNode* BuyQListNode(QDataType x)
{
	QLNode* newnode = (QLNode*)malloc(sizeof(QLNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}

//队尾入队列
void QueuePush(QE* q, QDataType x)
{
	assert(q);

	//申请一个结点
	QLNode* newnode = BuyQListNode(x);

	//分有数据和无数据
	if (q->head == NULL && q->tail == NULL)
	{
		q->head = newnode;
		q->tail = newnode;
	}
	else
	{
		q->tail->next = newnode;
		q->tail = newnode;
	}
	q->size++;
}


//队头出队列
void QueuePop(QE* q)
{
	assert(q);
	assert(!QueueEmpty(q));

	if (q->head->next == NULL)
	{
		free(q->head);
		q->head = q->tail = NULL;
	}
	else
	{
		QLNode* tmp = q->head->next;
		free(q->head);
		q->head = tmp;
	}	
	--q->size;
}

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

	return q->head->data;
}


//获取队列队尾元素
QDataType QueueBack(QE* q)
{
	assert(q);
	assert(!QueueEmpty(q));

	return q->tail->data;
}


//获取队列有效元素个数
int QueueSize(QE* q)
{
	assert(q);
	return q->size;
}

//检查队列是否为空，如果为空返回非0数，如果不为空返回0
bool QueueEmpty(QE* q)
{
	assert(q);
	return q->head == NULL && q->tail == NULL;
}


//销毁队列
void QueueDestroy(QE* q)
{
	assert(q);
	while (q->head)
	{
		QLNode* tmp = q->head->next;
		free(q->head);
		q->head = tmp;
	}
	q->head = q->tail = NULL;
	q->size = 0;
}

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


MyStack* myStackCreate() {
    MyStack* obj = (MyStack*)malloc(sizeof(MyStack));
    if(obj == NULL)
    {
        perror("malloc fail");
        return NULL;
    }
    QueueInit(&obj->q1);
    QueueInit(&obj->q2);    
    return obj;
}

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

int myStackPop(MyStack* obj) {
    assert(obj);
    QE* empty = &obj->q1;
    QE* nonempty = &obj->q2;

    if(QueueEmpty(&obj->q2))
    {
        empty = &obj->q2;
        nonempty = &obj->q1;
    }

    int tmp = 0;

    while(QueueSize(nonempty) > 1)
    {
        QueuePush(empty,QueueFront(nonempty));
        QueuePop(nonempty);
    }
    tmp = QueueFront(nonempty);
    QueuePop(nonempty);
    
    return tmp;
}

int myStackTop(MyStack* obj) 
{
    assert(obj);

    if(!QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2))
    {
        return obj->q1.tail->data;
    }
    else if(!QueueEmpty(&obj->q2) && QueueEmpty(&obj->q1))
    {
        return obj->q2.tail->data;
    }
    return 0;
}

bool myStackEmpty(MyStack* obj) {
    assert(obj);

    return  QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}

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

三、用栈实现队列

题目描述

LeetCode.232 用栈实现队列
请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：

实现 MyQueue 类：

  • void push(int x) 将元素 x 推到队列的末尾
  • int pop() 从队列的开头移除并返回元素
  • int peek() 返回队列开头的元素
  • boolean empty() 如果队列为空，返回 true ；否则，返回 false

在这里插入图片描述

解题思路

用两个栈实现队列，那么我们把两个栈分为 入队列的栈 push 和 出队列的栈 pop;进行入队列操作时，把数据压入push。进行出队列操作时，如果pop为空，则把push中的数据压入pop中再进行出栈操作；如果push不为空，则直接对pop进行出栈操作。
在这里插入图片描述

代码实现

typedef int STDataType;

typedef struct Stack
{
	STDataType* data;
	int top;
	int capacity;
}ST;


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

//销毁栈
void StackDestroy(ST* ps);

//入栈
void StackPush(ST* ps, STDataType x);

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

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

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

//检查栈是否为空，如果为空返回非0结果，如果不为空返回0
bool StackEmpty(ST* ps);

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

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

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


//入栈
void StackPush(ST* 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, newCapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		ps->data = tmp;
		ps->capacity = newCapacity;
	}
	ps->data[ps->top] = x;
	ps->top++;
}


//出栈
void StackPop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));

	--ps->top;
}


//获取栈顶元素
STDataType StackTop(ST* ps) 
{
	assert(ps);
	assert(!StackEmpty(ps));

	return ps->data[ps->top - 1];
}


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


//检查栈是否为空，如果为空返回非0结果，如果不为空返回0
bool StackEmpty(ST* ps)
{
	assert(ps);

	return ps->top == 0;
}


typedef struct {
    ST push;
    ST pop;
} MyQueue;


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

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

int myQueuePop(MyQueue* obj) {
    assert(obj);

    STDataType top = 0;
    if(!StackEmpty(&obj->pop))
    {
        top = StackTop(&obj->pop);
        StackPop(&obj->pop);
    }
    else
    {
        while(StackSize(&obj->push) > 0)
        {
            StackPush(&obj->pop,StackTop(&obj->push));
            StackPop(&obj->push);
        }
        top = StackTop(&obj->pop);
        StackPop(&obj->pop);
    }
    return top;
}

int myQueuePeek(MyQueue* obj) {
    assert(obj);
    if(!StackEmpty(&obj->pop))
    {
        return StackTop(&obj->pop);
    }
    else
    {
        while(StackSize(&obj->push) > 0)
        {
            StackPush(&obj->pop,StackTop(&obj->push));
            StackPop(&obj->push);
        }
        return StackTop(&obj->pop);
    }
}

bool myQueueEmpty(MyQueue* obj) {
    assert(obj);

    return StackEmpty(&obj->push) && StackEmpty(&obj->pop);
}

void myQueueFree(MyQueue* obj) {
    assert(obj);

    free(obj->push.data);
    free(obj->pop.data);
    free(obj);

}

四、设计循环队列

题目描述

LeetCode.622 设计循环队列
设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。

循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。

你的实现应该支持如下操作：

  • MyCircularQueue(k): 构造器，设置队列长度为k。
  • Front: 从队首获取元素。如果队列为空，返回 -1 。
  • Rear: 获取队尾元素。如果队列为空，返回 -1 。
  • enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
  • deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
  • isEmpty(): 检查循环队列是否为空。
  • isFull(): 检查循环队列是否已满。

解题思路

在这里插入图片描述
用数组实现循环队列，循环队列如上图所示，其长度是固定的，当循环队列存满时就不能存放新的数据了；给两个标记front和back，分别用来标记循环队列的第一个元素和最后一个元素；当 back 的下一个元素等于 front 时，循环队列存满就不能再存放数据了；当 bakc 等于 front 时，循环队列为空。删除队列元素只需要对 front 减一即可。

代码实现

typedef struct {
    int* data;
    int front;
    int back;
    int size;
    int capacity;
} MyCircularQueue;

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    //return ((back - front + obj->capacity) % obj->capacity);
    if(obj->size)
    {
        return false;
    }
    else
    {
        return true;
    }
}

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

MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    int* tmp = (int*)malloc(sizeof(int)*k);
    if(tmp == NULL)
    {
        perror("malloc fail");
        exit(-1);
    }
    obj->data = tmp;
    obj->front = obj->back = obj->size = 0;
    obj->capacity = k;
    return obj;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if(myCircularQueueIsFull(obj))
    {
        return false;
    }
    obj->data[obj->back] = value;
    obj->back++;
    if(obj->back == obj->capacity)
    {
        obj->back = 0;
    }
    obj->size++;
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    obj->front++;
    if(obj->front == obj->capacity)
    {
        obj->front =  0;
    }
    obj->size--;
    return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    return obj->data[obj->front];
}

int myCircularQueueRear(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    return obj->data[(obj->back - 1 + obj->capacity) % obj->capacity];
}



void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->data);
    free(obj);
}
华丞臧.
关注
  • 19
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 6
    评论
专栏目录
509 道 Java 面试题汇总与解析 免费开源！！
10-31
丰富的 Java 技术栈：基础和框架，线程池和锁优化，SpringBoot 和分布式消息队列，数据结构和常用算法，设计模式和 JVM 等 易学易会：提供了大量的图片说明和代码示例 你会获得什么 收获 Java 技术栈的核心知识点 这...
dailyLearn:javascript，实现数据结构和算法题
05-07
使用javascript实现经典的数据结构面试题。练手和温习 水平有限，如有缺漏，望见谅！ 文件结构： 1）ADT ———— 抽象数据类型（ADT） 包含：list（列表），llist（链表），queue（队列），stack（堆），tree（树）...
【数据结构】栈和队列选择题和面试编程题
m0_63198468的博客
06-03 992
本文重点讲述了数据结构里面的练习题和一些常见的面试题，给出了详细的解析思路，还附有动图，希望可以帮助大家。
数据结构 Java数据结构 栈和队列 以及LeetCode相关面试题
2401_84103936的博客
05-03 885
Java架构进阶面试及知识点文档笔记这份文档共498页，其中包括Java集合，并发编程，JVM，Dubbo,Redis，Spring全家桶，MySQL，Kafka等面试解析及知识点整理Java分布式高级面试问题解析文档其中都是包括分布式的面试问题解析，内容有分布式消息队列，Redis缓存，分库分表，微服务架构，分布式高可用，读写分离等等！互联网Java程序员面试必备问题解析及文档学习笔记Java架构进阶视频解析合集rn true;/**从循环队列中删除一个元素。如果成功删除则返回真。队头出。
史上最强数据结构----栈和队列相关笔试面试题
m0_57304511的博客
04-11 2363
史上最强数据结构----栈和队列相关笔试面试题
Java数据结构面试题以及答案
星空
08-28 1099
B树和B+树的区别？B树和B+树的优点分别是？HashMap和Hashtable的区别？ConcurrentHashMap的原理？ArrayList和LinkedList的区别？String、StringBuilder和StringBuffer的区别？ArrayList和Vector的区别？Collection下有哪些子类？Comparable和Comparator的区别？
数据结构面试题以及答案整理
weixin_42340902的博客
07-17 4万+
一、什么是数据结构？ 数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。结构包括逻辑结构和物理结构。 数据的逻辑结构包括4种 (1)集合：数据元素之间除了有相同的数据类型再没有其他的关系 (2)线性结构：数据元素之间是一对一的关系 ——线性表、栈、队列 (3)树形结构：数据元素之间是一对多的关系 (4)图状结构：数据元素之间是多对多的关系。 物理结构包括顺序存储结构和链式存储结构。 二、解释一下顺序存储与链式存储 顺序存储结构是用一段连续的存储空间来存储数据元
【数据结构】栈实现队列 & 队列实现栈
qq_42996461的博客
07-11 1355
🏷️力扣地址：🌈232. 用栈实现队列请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作 实现 类：示例1： 💫关键思路：1️⃣pop接口🌠动图解析：👇🏻2️⃣peek接口🌠动图解析：👇🏻3️⃣push接口🌠动图解析：👇🏻4️⃣empty接口💡代码实现： 🏷️力扣地址：🌈225. 用队列实现栈请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（、、 和 ）。实现 类：示例1 🌍解题关键：💫关键思路：那到底是如何实......
数据结构 Java数据结构 --- 栈和队列，2024年最新java特性面试题
2401_84412050的博客
04-21 995
面试成功其实都是必然发生的事情，因为在此之前我做足了充分的准备工作，不单单是纯粹的刷题，更多的还会去刷一些Java核心架构进阶知识点，比如：JVM、高并发、多线程、缓存、Spring相关、分布式、微服务、RPC、网络、设计模式、MQ、Redis、MySQL、设计模式、负载均衡、算法、数据结构、kafka、ZK、集群等。3. 实现出队列: 后进先出的栈实现先进先出的队列,要让A中的所有元素移入B中,先出的的元素就是后进的,此时栈顶就是就是最先进入的元素,B中出栈操作即可。你所使用的语言也许不支持队列。
数据结构与算法MOOC-第三章栈与队列练习题解析汇总
[SZU_Crayon]
08-08 2753
数据结构与算法MOOC-第三章栈与队列练习题解析汇总 1.用队列对扑克牌排序：快速排序-（POJ）用队列对扑克牌排序 2.栈的基本操作：POJ-栈的基本操作 3.stack or queue：POJ-stack or queue 4.双端队列：水题-双端队列 5.等价表达式：转逆波兰表达式-OpenJudge[等价表达式] 7.滑动窗口：Mutiset-(剑指offer-面试题6...
栈和队列的常见面试题-栈实现队列-队列实现栈
ws13575291650的博客
02-05 1万+
栈和队列的常见面试题-栈实现队列-队列实现栈 1) 用栈结构实现队列结构2) 如何用队列结构实现栈结构 ) 1) 用栈结构实现队列结构 解析： 用两个栈：push栈，pop栈 push栈：存储数据 pop  栈：只要本栈数据不为空，便将push栈数据倒出致此，实现队列 public static class TwoStacksQueue { public Stack<Integer> stackPush; public Stack<Integer> stack
爆肝两万字，我爷爷都看的懂的《栈和队列》，建议各位观众姥爷先收藏
热门推荐
wh128341的博客
09-12 7万+
文章目录一、栈???? 栈的概念及结构???? 栈的实现二、队列???? 队列的概念及结构???? 队列的实现三、栈和队面试题四、概念选择题???? 1???? 2 一、栈 ???? 栈的概念及结构 栈：一种特殊的线性表，其只允许在固定的一端插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称库栈底。 栈中的数据元素遵守后进先出LIFO (Last In First Out) 的原则 栈有两个经典的操作 1️⃣ 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。 2️⃣ 出栈：栈的删除操
php面试题_腾讯.doc
08-10
十、面试题解析 本文档最后提供了一些面试题和答案，涵盖了 PHP 中的多个方面，如正则表达式、安全模式、魔术方法、命令行脚本、垃圾收集、对象遍历、双向队列、正则表达式匹配、Socket 编程等。这些面试题可以帮助...
cvte面试题里面包含了许多CVTE面试的真是题目，非常的有用
04-07
* 文件结构尽量简洁，使用等长的指令，借以提高解析速度。 * 尽量扩大只读结构的大小，借以提高跨进程的数据共享。 * dex 的优化，dex 文件的结构是紧凑的，但是如果想提高运行时的性能，就需要对 dex 文件进行...
【数据结构】查找（顺序查找、二分查找、索引顺序查找、二叉排序树、平衡排序树、B树、B+树、哈希表）
ChenZHIHAO_y的博客
06-05 801
查找（顺序查找、二分查找、索引顺序查找、二叉排序树、平衡排序树、B树、B+树、哈希表）
12- Redis 中的 链表 数据结构
YoungSoulwt的博客
06-04 656
Redis 中的 链表 数据结构
【排序算法】计数排序（CountSort）
最新发布
SWsunlight的博客
06-08 324
计数排序
北航数据结构与程序设计第四次作业选填题复习
zxy13149285776的博客
06-05 434
BUAA数据结构与程序设计第4次作业选填题
数据结构栈和队列课后习题头歌
10-18
根据提供的引用内容，我可以为您解答数据结构栈和队列课后习题的相关问题。 根据引用中的内容，我们可以知道栈和队列都是线性结构，栈是一种特殊的线性表，允许插入和删除运算的一端称为栈顶，不允许插入和删除运算...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

华丞臧.

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值