栈和队列经典笔试题

news2025/2/28 17:15:33

文章目录

  • 栈和队列的回顾💻
    • 栈🩳
    • 队列👟
  • 栈和队列经典笔试题🔋
    • 有效的括号🎸
    • 用队列实现栈 🕯
    • 用栈实现队列🔭
    • 设计循环队列🧼

安静的夜晚 你在想谁吗

栈和队列的回顾💻

栈🩳

栈是一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。
一般使用数组实现栈在这里插入图片描述

物理图表示入栈和出栈（后进先出）在这里插入图片描述

队列👟

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

入队列：进行插入操作的一端称为队尾 ；出队列：进行删除操作的一端称为队头。 在这里插入图片描述

物理图表示入队和出队（先进先出）
在这里插入图片描述

栈和队列经典笔试题🔋

有效的括号🎸

力扣题目链接：有效的括号
给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

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

下面是几个示例：
在这里插入图片描述

题目分析
本题通俗的来讲，就是判断括号是否是匹配的，即括号的类型是否匹配和数量是否匹配。我们可以使用栈的知识来解决这道题：从给定序列的第一个字符开始遍历，如果遍历遇到左括号，就入栈；如果遍历遇到右括号，则先取栈顶元素，再出栈（因为合适的匹配必须是栈），判断栈顶元素与这个右括号是否匹配。
需要注意的点有：尽量每次循环只遍历一个元素或只对一个元素进行判断，这样可以保证数量匹配的正确性。当遍历一个元素不是左括号的时候，就判断栈中是否为空，如果栈为空，则说明数量是不匹配的；如果栈不为空，则要对这个右括号是否和栈顶的左括号匹配进行判断。
其实本题比较复杂的还是结构的问题，毕竟不用C++的，这个栈的功能需要我们自己去实现。
力扣代码（含栈结构）

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

void STInit(ST* ps);
void STDestroy(ST* ps);
void STPush(ST* ps, STDataType x);
void STPop(ST* ps);
STDataType STtop(ST* ps);
int STsize(ST* ps);
bool STEmpty(ST* ps);
void STInit(ST* ps)
{
	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;
}
void STDestroy(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;
}
void STPush(ST* ps, STDataType x)
{
	assert(ps);
	if (ps->top == ps->capacity)
	{
		int NEWcapacity = (ps->capacity == 0) ? 4 : (ps->capacity * 2);
		//扩容
		STDataType* tmp = realloc(ps->a, sizeof(STDataType) * NEWcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity = NEWcapacity;
	}
	ps->a[ps->top] = x;
	ps->top++;
}
void STPop(ST* ps)
{
	assert(ps);
	assert(ps->top > 0);
	ps->top--;
}
//获取栈顶元素
STDataType STtop(ST* ps)
{
	assert(ps);
	assert(ps->top>0);
	return ps->a[ps->top-1];
}

int STsize(ST* ps)
{
	assert(ps);
	return ps->top;
}

bool STEmpty(ST* ps)
{
	assert(ps);
	return (ps->top == 0);
}

bool isValid(char * s){
    ST st;
		STInit(&st);
		char stack_top;
		while(*s)
		{
			if(*s=='('||*s=='['||*s=='{')
			{
				STPush(&st,*s);
			}	
			else
			{
				if(STEmpty(&st))
				{
					STDestroy(&st);
					return false;
				}
				stack_top=STtop(&st);
				STPop(&st);
				if(*s==')'&&stack_top!='('||
					*s==']'&&stack_top!='['||
					*s=='}'&&stack_top!='{')
					{
						STDestroy(&st);
						return false;
					}
			}
			s++;
		}
		if(!STEmpty(&st))
		{
			STDestroy(&st);
			return false;
		}

    return true;
}

当代码在所有不满足的情况下依旧没有返回 false 的时候，则说明它是满足括号的有效性的。

用队列实现栈 🕯

力扣题目链接：用队列实现栈
在这里插入图片描述
你只能使用队列的基本操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 这些操作。
你所使用的语言也许不支持队列。 你可以使用 list （列表）或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。

范例：
在这里插入图片描述
题目分析及思路
队列是先进先出，要实现一个后进先出的栈，一个队列肯定是不行的，必须使用两个队列来互相导着来实现。例如，我现在要对这个数据结构入4个元素：1 2 3 4
在这里插入图片描述
队列只能 pop 先 push 的元素，而要达到将最后进入的元素 pop 的目的，就需要另一个队列来帮忙了：先将所有元素都push到队列1，取 队列1 头位置的元素，将它 push 到 队列2 中后，再将 队列1 中这个元素 pop 掉。如此往复，直到 队列1 中只剩下一个元素，这就是栈结构中需要 pop 的元素。
在这里插入图片描述

在这里插入图片描述
再将最后这个元素pop掉，就相当于将栈结构里的栈顶元素pop掉了。这样就实现了栈的pop功能。
在上面的例子中，我们可以总结出队列实现栈的一般规律：实现push数据，就往空的队列里push；实现pop数据，先将费控队列的前n-1个元素导入空队列，并pop这n-1个元素，最后将剩下的那个元素pop掉即可实现栈的pop功能。
力扣代码（含结构）

typedef int QDataType;
typedef struct QueueNode {
	QDataType data;
	struct QueueNode* next;
}QNode;
typedef struct Queue {
	QNode* head;
	QNode* tail;
	int size;
}Que;
void QueueInit(Que*pq);
void QueueDestroy(Que* pq);
void QueuePush(Que* pq, QDataType x);
void QueuePop(Que* pq);
QDataType QueueFront(Que* pq);
QDataType QueueBack(Que* pq);
bool QueueEmpty(Que* pq);
int QueueSize(Que* pq);
void QueueInit(Que* pq)
{
	assert(pq);
	pq->head = pq->tail = NULL;
	pq->size = 0;
}
void QueueDestroy(Que* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
}
void QueuePush(Que* pq, QDataType x)
{
	assert(pq);
	QNode* nownode = (QNode*)malloc(sizeof(QNode));
	if (nownode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	nownode->data = x;
	nownode->next = NULL;
	if (pq->tail == NULL)
	{
		pq->head = pq->tail = nownode;
	}
	else
	{
		pq->tail->next = nownode;
		pq->tail = nownode;
	}
	pq->size++;
}
void QueuePop(Que* pq)
{
	assert(pq);
	assert(pq->head != NULL);
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}
	pq->size--;
}
QDataType QueueFront(Que* pq)
{
	assert(pq);
	assert(pq->head != NULL);
	return pq->head->data;
}
QDataType QueueBack(Que* pq)
{
	assert(pq);
	assert(pq->head!=NULL);
	return pq->tail->data;
	
}
bool QueueEmpty(Que* pq)
{
	assert(pq);
	return pq->head == NULL;
}
int QueueSize(Que* pq)
{
	assert(pq);
	return pq->size;
}


typedef struct {
    Que q1,q2;
} MyStack;


MyStack* myStackCreate() {
    MyStack*pst=(MyStack*)malloc(sizeof(MyStack));
    QueueInit(&pst->q1);//->的优先级高于&，其实是&(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) {
    Que*empty=&obj->q1;
    Que*nonEmpty=&obj->q2;
    if(!QueueEmpty(&obj->q1))
    {
        empty=&obj->q2;
        nonEmpty=&obj->q1;
    }
    //把非空队列的前size-1个元素push到空队列
    while(QueueSize(nonEmpty)>1)
    {
        QueuePush(empty,QueueFront(nonEmpty));
        QueuePop(nonEmpty);
    }
    int top=QueueFront(nonEmpty);
    QueuePop(nonEmpty);
    return top;
}

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

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

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

/**
 * 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);
*/

用栈实现队列🔭

力扣题目链接：用栈实现队列
在这里插入图片描述
你 只能 使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。
你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。
范例：
在这里插入图片描述
题目分析及思路
题目要求只使用栈的基本操作实现一个队列，这就需要两个栈进行‘合作’来完成。
例如，现在要往队列中 push 四个数据1，2，3，4。
创建两个栈，一个pushst，一个popst，如图，先将这四个数据push到 pushst 这个栈中。
在这里插入图片描述
现在，如果要实现队列的 pop 操作，就要将数据1 删除，但栈只能pop栈顶元素，所以只能先将pushst中的‘上面’的三个数据先导过来（取栈顶元素，再pop），然后数据1 就变成了 pushst 的栈顶元素，直接pop即可。
在这里插入图片描述
接下来，如果队列还需要 pop 数据的话，只需要在 popst 中 pop 即可。
如果要 push 数据，直接push 到pushst中，再次push后，如果要pop数据，需要将popst中的数据pop完后（直接取栈顶元素），将 pushst 中新push 的 n-1 个数据先导过去，再用上面的方式（出popst中的数据即可）。
总结：定义两个栈，队列需要push数据的时候，先往pushst中push数据（此时栈popst中为空），首次需要pop数据的时候，先将pushst中push的n-1个数据导入popst中，然后将最后一个元素pop掉，这就是队列要pop的头。当将n-1个数据导入popst中后，如果队列再要pop数据，就直接使用栈 popst 进行pop数据，入数据的时候就继续在pushst中压栈，当popst中的数据pop完了直接还要pop的话，就需要再将pushst中的n-1个元素导过去，如此往复…
力扣代码（含结构）

typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;//栈顶位置
	int capacity;//栈空间大小
}ST;
void STInit(ST* ps);
void STPush(ST* ps,STDataType x);
void STPrint(ST* ps);
void STPop(ST* ps);
void STDestroy(ST* ps);
STDataType STTop(ST* ps);
int STSize(ST* ps);
bool STEmpty(ST* ps);

void STInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;
}
void STPush(ST* ps, STDataType x)
{
	assert(ps);
	if (ps->capacity==ps->top)
	{
		int newcapacity = (ps->capacity == 0) ? 4 : ps->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->a, newcapacity * sizeof(ps->a));
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		ps->capacity = newcapacity;
		ps->a = tmp;
	}
	ps->a[ps->top] = x;
	ps->top++;
}
void STPrint(ST* ps)
{
	assert(ps);
	int i = 0;
	for (i = 0; i < ps->top; i++)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}
void STPop(ST* ps)
{
	assert(ps);
	assert(ps->top>0);
	(ps->top)--;
}
void STDestroy(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->top = 0;
}
STDataType STTop(ST* ps)
{
	assert(ps);
	assert(ps->top > 0);
	return ps->a[ps->top - 1];
}
int STSize(ST* ps)
{
	assert(ps);
	return ps->top;
}
bool STEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}


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


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

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

int myQueuePop(MyQueue* obj) {
    int front=myQueuePeek(obj);
    STPop(&obj->popst);
    return front;
}


int myQueuePeek(MyQueue* obj) {
    if(STEmpty(&obj->popst))
    {
        while(STSize(&obj->pushst)>0)
        {
            STPush(&obj->popst,STTop(&obj->pushst));
            STPop(&obj->pushst);
        }
    }
    return STTop(&obj->popst);
}

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

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

设计循环队列🧼

力扣题目链接：设计循环队列
在这里插入图片描述
范例：
在这里插入图片描述
个人理解：当我们使用数组（顺序表）来实现队列的时候，随着出数据的时候队头不断前移，那么队列的容量（队头到队尾）将会越来越小，如下图：
在这里插入图片描述
所以可以采用循环队列的方式来维持队列容量的恒定。
此题需要的空间固定为k，并且要将这些空间重复利用，所以采用用数组实现最为合适。
思路
开辟数组空间的时候‘多开一个’，利用数组的下标来控制队尾和队头的位置。
比如，当队列的长度为4的时候，就开辟5块空间的地址，最后一块空间用来把握队列长度来防止越界。当队头和队尾相等的时候，说明队列为空；当（队尾+1）%（k+1）等于队头的时候，说明队头和队尾之间只有一块空间的地址，说明队列已满。
力扣代码

typedef struct {
        int*a;
        int k;
        int front;
        int rear;
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue*obj=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->a=(int*)malloc(sizeof(int)*(k+1));
    obj->k=k;
    obj->front=obj->rear=0;
    return obj;
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->front==obj->rear;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return (obj->rear+1)%(obj->k+1)==obj->front;
}

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

    obj->rear%=obj->k+1;
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
        return false;
    obj->front++;
    obj->front%=obj->k+1;
    return true;
}

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

int myCircularQueueRear(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
        return -1;
    return obj->a[(obj->rear+obj->k)%(obj->k+1)];
}


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

/**
 * Your MyCircularQueue struct will be instantiated and called as such:
 * MyCircularQueue* obj = myCircularQueueCreate(k);
 * bool param_1 = myCircularQueueEnQueue(obj, value);
 
 * bool param_2 = myCircularQueueDeQueue(obj);
 
 * int param_3 = myCircularQueueFront(obj);
 
 * int param_4 = myCircularQueueRear(obj);
 
 * bool param_5 = myCircularQueueIsEmpty(obj);
 
 * bool param_6 = myCircularQueueIsFull(obj);
 
 * myCircularQueueFree(obj);
*/

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/981240.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

在VR全景中嵌入3D模型有哪些优势？

在VR全景中嵌入3D模型有哪些优势？

现阶段&#xff0c;很多商企都会引入VR全景展示来宣传推广自己的产品、服务以及环境&#xff0c;但是环境展示凸显的沉浸式体验只是 VR全景一部分的价值所在&#xff0c;商企使用VR全景还有一个优势就是互动性&#xff0c;通过丰富多样的互动性&#xff0c;让用户同VR场景中的物…
阅读更多...
Linux下systemd深入指南：如何优化Java服务管理与开机自启配置

Linux下systemd深入指南：如何优化Java服务管理与开机自启配置

&#x1f337;&#x1f341; 博主猫头虎&#xff08;&#x1f405;&#x1f43e;&#xff09;带您 Go to New World✨&#x1f341; &#x1f984; 博客首页——&#x1f405;&#x1f43e;猫头虎的博客&#x1f390; &#x1f433; 《面试题大全专栏》 &#x1f995; 文章图文…
阅读更多...
网络编程day6作业

网络编程day6作业

完成网络聊天室编写 ser #define ERR_MSG(msg) do{\fprintf(stderr,"__%d__",__LINE__);\perror(msg);\ }while(0) #define IP "127.0.0.1" #define PORT 6666 //创建链表 Linklistptr list_create(); Linklistptr node_buy(datatype e); int list_inser…
阅读更多...
【三维重建】【深度学习】【数据集】基于COLMAP制作个人Gen6D测试数据集

【三维重建】【深度学习】【数据集】基于COLMAP制作个人Gen6D测试数据集

【三维重建】【深度学习】【数据集】基于COLMAP制作个人Gen6D测试数据集 提示:最近开始在【三维重建】方面进行研究,记录相关知识点,分享学习中遇到的问题已经解决的方法。 文章目录 【三维重建】【深度学习】【数据集】基于COLMAP制作个人Gen6D测试数据集前言下载安装colmap软…
阅读更多...
龙迅LT86102UX HDMI一进二出，支持分辨率4K60HZ

龙迅LT86102UX HDMI一进二出，支持分辨率4K60HZ

龙迅LT86102UXE 1. 描述 龙迅LT86102UX HDMI2.0 分路器具有符合 HDMI2.0/1.4 规范的 1&#xff1a;2 分路器、最大 6Gbps 高速数据速率、自适应均衡 RX 输入和预强调的 TX 输出&#xff0c;支持长电缆应用&#xff0c;板载无 XTAL&#xff0c;可节省 BOM 成本。 LT86102UX HDM…
阅读更多...
海保人寿：开源治理保障科技与保险融合，助力保险业务数字化改革创新

海保人寿：开源治理保障科技与保险融合，助力保险业务数字化改革创新

海保人寿保险股份有限公司&#xff08;简称“海保人寿”&#xff09;是第一家在海南筹建开业的全国性保险机构。从成立之初&#xff0c;便深耕于数字化创新&#xff0c;在自身多业务环节中实现数字化转型&#xff0c;依托优秀的研发体系与数智融合的业务系统&#xff0c;不断推…
阅读更多...
MAYA材质学习（各种好看的）

MAYA材质学习（各种好看的）

例子2 例子3 例子4 例子5 例子6 例子7
阅读更多...
如何解决GitHub 访问不了？小白教程

如何解决GitHub 访问不了？小白教程

GitHub 是全球最大的代码开源平台&#xff0c;小伙伴们平时都喜欢在那里找一些优质的开源项目来学习&#xff0c;以提升自己的编程技能。 但是很多小白初探GitHub 发现访问不了&#xff0c;不能访问 通过一下方法绕过这堵墙&#xff0c;成功下载 GitHub 上的项目。过程非常简单…
阅读更多...
Ukey连接虚拟前置机，浦银安盛基金用USB Server解决

Ukey连接虚拟前置机，浦银安盛基金用USB Server解决

浦银安盛基金一直使用物理前置机来连接Ukey&#xff0c;物理前置机维护管理不便&#xff0c;严重影响金融交易效率。因此&#xff0c;浦银安盛基金想要推进企业虚拟化&#xff0c;通过在虚拟机中部署前置机程序的方式&#xff0c;将前置机部署到虚拟机中。但虚拟机中的前置机&a…
阅读更多...
SpringCloud整体架构概述

SpringCloud整体架构概述

&#x1f497;wei_shuo的个人主页 &#x1f4ab;wei_shuo的学习社区 &#x1f310;Hello World &#xff01; SpringCloud整体架构概述 SpringCloud对常见的分布式系统模式提供了简单易用的编程模型&#xff0c;帮助开发者构建弹性、可靠、协调的应用程序。 SpringCloud是在Spr…
阅读更多...
在线升级之ICAP,ISP,BIN,HEX,MCS

在线升级之ICAP,ISP,BIN,HEX,MCS

学到了ICAP&#xff0c;做做笔记。 具体可参考&#xff1a;FPGA中ICAP原语的使用——Multiboot功能的实现_朽月的博客-CSDN博客 ICAP是管理内部配置访问端口的原语&#xff0c;于是我学习的第一个原语。对于原语的概念简而言之就是类似IP核的存在&#xff0c;是既成的电路结构&…
阅读更多...
使用Puppeteer爬取地图上的用户评价和评论

使用Puppeteer爬取地图上的用户评价和评论

导语 在互联网时代&#xff0c;获取用户的反馈和意见是非常重要的&#xff0c;它可以帮助我们了解用户的需求和喜好&#xff0c;提高我们的产品和服务质量。有时候&#xff0c;我们需要从地图上爬取用户对某些地点或商家的评价和评论&#xff0c;这样我们就可以分析用户对不同…
阅读更多...
C++内存管理（2）new、delete详解

C++内存管理（2）new、delete详解

目录 new operator&#xff08;new操作&#xff09; new类对象时加不加括号的差别 new工作任务 delete工作任务 new和delete 堆区空间操作&#xff08;对比malloc和free&#xff09; new和delete操作基本类型的空间 new和delete操作基本类型的数组 new和delete操作类的…
阅读更多...
Layui快速入门之第二节布局容器(固定宽度与完整宽度)

Layui快速入门之第二节布局容器(固定宽度与完整宽度)

目录 一&#xff1a;固定宽度 二&#xff1a; 完整宽度 一&#xff1a;固定宽度 将栅格放入一个带有 class"layui-container" 的特定容器中&#xff0c;以便在小屏幕以上的设备中固定宽度&#xff0c;让列可控(两侧有留白效果) <!--固定宽度(两侧有留白效果)--&…
阅读更多...
Layui快速入门之第三节栅格布局

Layui快速入门之第三节栅格布局

目录 一&#xff1a;栅格布局的基本概念 二&#xff1a;栅格布局规则 三&#xff1a;始终等比例水平排列案例 四&#xff1a;响应式规则 五&#xff1a;移动设备、桌面端的组合响应式展现案例 六&#xff1a;移动设备、平板、桌面端的复杂组合响应式展现案例 七&#xf…
阅读更多...
Yalmip使用教程(6)-将约束条件写成矩阵形式

Yalmip使用教程(6)-将约束条件写成矩阵形式

博客中所有内容均来源于自己学习过程中积累的经验以及对yalmip官方文档的翻译&#xff1a;https://yalmip.github.io/tutorials/ 这篇博客将详细介绍如何借助yalmip工具箱将约束条件写成矩阵形式。 1.相关函数介绍 1.1 depends和getvariables函数 depends和getvariables函数都…
阅读更多...
C# Winform 简单排期实现（DevExpress TreeList）

C# Winform 简单排期实现（DevExpress TreeList）

排期的需求在很多任务安排的系统中都有相应的需求&#xff0c;原生的Winform控件并未提供相应的控件&#xff0c;一般都是利用DataGridViewTreeView组合完成相应的需求&#xff0c;实现起来比较麻烦。用过DevExpress控件集的开发者应该知道&#xff0c;DevExpress WinForm提供了…
阅读更多...
数学建模--K-means聚类的Python实现

数学建模--K-means聚类的Python实现

目录 1.算法流程简介 2.1.K-mean算法核心代码 2.2.K-mean算法效果展示 3.1.肘部法算法核心代码 3.2.肘部法算法效果展示 1.算法流程简介 #k-means聚类方法 """ k-means聚类算法流程: 1.K-mean均值聚类的方法就是先随机选择k个对象作为初始聚类中心. 2.这…
阅读更多...
http实现文件分片下载

http实现文件分片下载

文章目录 检测是否支持HTTP Range 语法Range请求cURL示例单一范围多重范围条件式分片请求 Range分片请求的响应文件整体下载文件分片下载文本下载图片下载封装下载方法 HTTP分片异步下载是一种下载文件的技术&#xff0c;它允许将一个大文件分成多个小块&#xff08;分片&#…
阅读更多...
一个新工具 nolyfill

一个新工具 nolyfill

名字的意思&#xff0c; 我自己的理解 no(po)lyfill 正如它的名字, 不要再用补丁了, 当然这里说的是过时的补丁。 polyfill 是补丁的意思 为什么要用这个插件 文档原文: 当您通过安装最新的 Node.js LTS 来接受最新的功能和安全修复时&#xff0c;像eslint-plugin-import、…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023