栈和队列OJ题目——C语言

news2024/10/6 1:45:48

目录

LeetCode 20、有效的括号

题目描述：

思路解析：

解题代码： 

通过代码： 

LeetCode 225、用队列实现栈

题目描述：

思路解析：

解题代码： 

通过代码：

LeetCode 232、用栈实现队列

题目描述：

思路解析：​编辑

解题代码：

通过代码：

LeetCode 622、设计循环队列

题目描述：

思路解析：

解题代码：

通过代码：

LeetCode 20、有效的括号

题目描述：

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

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

示例 1：

输入：s = "()"
输出：true

示例 2：

输入：s = "()[]{}"
输出：true

示例 3：

输入：s = "(]"
输出：false

提示：

  • 1 <= s.length <= 104
  • s 仅由括号 '()[]{}' 组成

OJ题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

思路解析：

利用栈先进后出的特点，让栈内元素依次与新元素比较。 

解题代码： 

我们还是要先拷贝一份栈放在OJ题目上方，并且注意我们需要更改STDataType为char类型，我们要更改的不止这些，我们还要改一下我们的assert，我们要把暴力的判断变成温柔的判断，其中重点是STPop和STTop：

根据思路写出如下代码： 

我们根据我们的思路写出了如上代码，实验后发现通过所有测试案例，在提交时却出现错误，经过调试后发现，当传入一个括号时，会跳过我们判错的代码，直接来到判对：

这就是我们的数量不匹配，我们可以在最后进行一个判空，如果最后栈没空，说明数量不匹配。 

这样一修改就可以啦。

通过代码： 

typedef char STDataType;

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

void STInit(ST* pst);
void STDestroy(ST* pst);

void STPush(ST* pst, STDataType x);
void STPop(ST* pst);
STDataType STTop(ST* pst);

bool STEmpty(ST* pst);
int STSize(ST* pst);

void STInit(ST* pst)
{
	assert(pst);

	pst->a = NULL;
	pst->capacity = 0;

	pst->top = 0;

}

void STDestroy(ST* pst)
{
	assert(pst);

	free(pst->a);
	pst->a = NULL;
	pst->top = pst->capacity = 0;
}


void STPush(ST* pst, STDataType x)
{
	assert(pst);

	if (pst->top == pst->capacity)
	{
		int newcapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(pst->a, sizeof(STDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}

		pst->a = tmp;
		pst->capacity = newcapacity;
	}

	pst->a[pst->top] = x;
	pst->top++;
}

void STPop(ST* pst)
{
	assert(pst);
    if(!pst->top > 0)
    {
        return;
    }
	pst->top--;
}

STDataType STTop(ST* pst)
{
	assert(pst);
    if(!pst->top > 0)
    {
        return 0;
    }
	return pst->a[pst->top - 1];
}

bool STEmpty(ST* pst)
{
	assert(pst);

	return pst->top == 0;
}

int STSize(ST* pst)
{
	assert(pst);

	return pst->top;
}

bool isValid(char* s) 
{
	ST st;
	STInit(&st);
	while (*s)
	{
		if (*s == '(' || *s == '[' || *s == '{')
		{
			STPush(&st, *s);
		}
		else
		{
			char top = STTop(&st);
			STPop(&st);
			if ((*s == ')' && top == '(') 
            || (*s == ']' && top == '[') 
            || (*s == '}' && top == '{'))
			{
				;
			}
			else
			{
				return 0;
			}
		}
		++s;
	}
	bool ans = STEmpty(&st);
	STDestroy(&st);
	return ans;
}

LeetCode 225、用队列实现栈

题目描述：

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

实现 MyStack 类：

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

注意：

  • 你只能使用队列的基本操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 这些操作。
  • 你所使用的语言也许不支持队列。 你可以使用 list （列表）或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。

示例：

输入：
["MyStack", "push", "push", "top", "pop", "empty"]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 2, 2, false]

解释：
MyStack myStack = new MyStack();
myStack.push(1);
myStack.push(2);
myStack.top(); // 返回 2
myStack.pop(); // 返回 2
myStack.empty(); // 返回 False

提示：

  • 1 <= x <= 9
  • 最多调用100 次 push、pop、top 和 empty
  • 每次调用 pop 和 top 都保证栈不为空

进阶：你能否仅用一个队列来实现栈。

OJ题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

思路解析：

首先我们先复习一下栈和队列的性质

此时我们的两个队列，他们的功能分别是存储数据和导出数据 

解题代码： 

此时因为我们需要用到队列，所以我们需要先把我们写的队列拷贝一份在OJ代码上面：

同时也别忘记我们在队列部分写过的函数，我们可以不用自己判空，在插入时哪个不为空我们就插入到哪个队列，此时那个队列是专门用来存储数据的。

在删除时，我们也可以使用QueueSize对队列数据的个数进行判断，用QueueFront进行导入队头操作，此时该队列承担的是导数据的任务， 同时导入队头的同时不要忘记要将队头Pop出去。

在去栈首的时候，我们取到的是队列的最后一个元素，首先想到的肯定是返回我们导完数据后剩的那个元素，直接CV上面的代码，但是我们要能想到在写队列时，我们写过取队尾函数QueueBack，我们可以直接进行判空操作，返回不为空队列的最后一个元素。

当然判空也很简单，我们只需要同时判断两个队列即可。 

最后free时，我们可以直接释放我们malloc的MyStack* pst呢？我们来画张图看一下

所以在free掉栈之前要把两个队列先free，由于不知道哪个为空，所以我们两个都free。

通过代码：

typedef int QDataType;
typedef struct QueueNode
{
    QDataType val;
    struct QueueNode* next;
}QNode;


typedef struct Queue
{
    QNode* phead;
    QNode* ptail;
    int size;
}Queue;


void QueueInit(Queue* pq);
void QueueDestroy(Queue* pq);
void QueuePush(Queue* pq, QDataType x);
void QueuePop(Queue* pq);
QDataType QueueFront(Queue* pq);
QDataType QueueBack(Queue* pq);
bool QueueEmpty(Queue* pq);
int QueueSize(Queue* pq);


void QueueInit(Queue* pq)
{
    assert(pq);
    pq->phead = pq->ptail = NULL;
    pq->size = 0;
}


void QueueDestroy(Queue* pq)
{
    assert(pq);


    QNode* cur = pq->phead;
    while (cur)
    {
        QNode* next = cur->next;
        free(cur);
        cur = next;
    }


    pq->phead = pq->ptail = NULL;
    pq->size = 0;
}


void QueuePush(Queue* pq, QDataType x)
{
    assert(pq);


    QNode* newnode = (QNode*)malloc(sizeof(QNode));
    if (newnode == NULL)
    {
        perror("malloc fail");
        return;
    }


    newnode->val = x;
    newnode->next = NULL;


    if (pq->ptail == NULL)
    {
        pq->ptail = pq->phead = newnode;
    }
    else
    {
        pq->ptail->next = newnode;
        pq->ptail = newnode;
    }


    pq->size++;
}



void QueuePop(Queue* pq)
{
    assert(pq); 
    assert(pq->phead);


    QNode* del = pq->phead;
    pq->phead = pq->phead->next;
    free(del);
    del = NULL;


    if (pq->phead == NULL)
        pq->ptail = NULL;


    pq->size--;
}


QDataType QueueFront(Queue* pq)
{
    assert(pq);
    assert(pq->phead);


    return pq->phead->val;
}


QDataType QueueBack(Queue* pq)
{
    assert(pq);
    assert(pq->ptail);


    return pq->ptail->val;
}


bool QueueEmpty(Queue* pq)
{
    assert(pq);


    return pq->phead == NULL;
}


int QueueSize(Queue* pq)
{
    assert(pq);


    return pq->size;
}


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* noneempty = &obj->q1;//用noneempty指向非空栈
    Queue* empty = &obj->q2;//用empty指向空栈
    if (!QueueEmpty(&obj->q2))
    {
        noneempty = &obj->q2;
        empty = &obj->q1;
    }
    while (QueueSize(noneempty) > 1)
    {
        QueuePush(empty, QueueFront(noneempty));
        QueuePop(noneempty);
    }
    int top = QueueFront(noneempty);
    QueuePop(noneempty);
    return top;
}


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


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


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

LeetCode 232、用栈实现队列

题目描述：

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

实现 MyQueue 类：

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

说明：

  • 你 只能 使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。
  • 你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。

示例 1：

输入：
["MyQueue", "push", "push", "peek", "pop", "empty"]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 1, 1, false]

解释：
MyQueue myQueue = new MyQueue();
myQueue.push(1); // queue is: [1]
myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
myQueue.peek(); // return 1
myQueue.pop(); // return 1, queue is [2]
myQueue.empty(); // return false

提示：

  • 1 <= x <= 9
  • 最多调用 100 次 push、pop、peek 和 empty
  • 假设所有操作都是有效的 （例如，一个空的队列不会调用 pop 或者 peek 操作）

OJ题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

思路解析：

 

解题代码：

我认为代码的唯一难点就是在于什么时候导数据，在哪个函数时要把PushSt中的元素导入PushSt

我们可以在STPeek中导数据，然后可以在STPop时再调用STPeek，再进行STPop

通过代码：

typedef char STDataType;

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

void STInit(ST* pst);
void STDestroy(ST* pst);
void STPush(ST* pst, STDataType x);
void STPop(ST* pst);
STDataType STTop(ST* pst);

bool STEmpty(ST* pst);
int STSize(ST* pst);

void STInit(ST* pst)
{
	assert(pst);

	pst->a = NULL;
	pst->capacity = 0;
	pst->top = 0;

}

void STDestroy(ST* pst)
{
	assert(pst);

	free(pst->a);
	pst->a = NULL;
	pst->top = pst->capacity = 0;
}

void STPush(ST* pst, STDataType x)
{
	assert(pst);

	if (pst->top == pst->capacity)
	{
		int newcapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(pst->a, sizeof(STDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}

		pst->a = tmp;
		pst->capacity = newcapacity;
	}

	pst->a[pst->top] = x;
	pst->top++;
}

void STPop(ST* pst)
{
	assert(pst);
	if (!(pst->top > 0))
	{
		return;
	}
	pst->top--;
}

STDataType STTop(ST* pst)
{
	assert(pst);
	if (!(pst->top > 0))
	{
		return 0;
	}
	return pst->a[pst->top - 1];
}

bool STEmpty(ST* pst)
{
	assert(pst);

	return pst->top == 0;
}

int STSize(ST* pst)
{
	assert(pst);

	return pst->top;
}

typedef struct 
{
	ST PushSt;
	ST PopSt;
} MyQueue;


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

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 (!STEmpty(&obj->PushSt))
		{
			STPush(&obj->PopSt, STTop(&obj->PushSt));
			STPop(&obj->PushSt);
		}
	}
	return STTop(&obj->PopSt);
}

bool myQueueEmpty(MyQueue* obj) 
{
	return obj->PopSt.top == NULL && obj->PushSt.top == NULL;
}

void myQueueFree(MyQueue* obj) 
{
	STDestroy(&obj->PopSt);
	STDestroy(&obj->PushSt);
	free(obj);
	obj = NULL;
}

LeetCode 622、设计循环队列

题目描述：

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

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

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

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

示例：

MyCircularQueue circularQueue = new MyCircularQueue(3); // 设置长度为 3
circularQueue.enQueue(1);  // 返回 true
circularQueue.enQueue(2);  // 返回 true
circularQueue.enQueue(3);  // 返回 true
circularQueue.enQueue(4);  // 返回 false，队列已满
circularQueue.Rear();  // 返回 3
circularQueue.isFull();  // 返回 true
circularQueue.deQueue();  // 返回 true
circularQueue.enQueue(4);  // 返回 true
circularQueue.Rear();  // 返回 4

提示：

  • 所有的值都在 0 至 1000 的范围内；
  • 操作数将在 1 至 1000 的范围内；
  • 请不要使用内置的队列库。

OJ题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台 

思路解析：

 

 

解题代码：

我们先对我们存储容器进行定义，这里我们以数组为例： 

 然后先看一下我们刚才已经解决了的问题的代码块，判空和判满： 

 

对于插入和删除，我们只需要对front和back下标进行操作即可：

 

但是不只只是这样就结束了，我们在很多地方都应该判断队列是否满或者是否空，比如插入时判断是否已满，取头取尾时判断是否为空，具体代码大家可以看通过代码。

通过代码：

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


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

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

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

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) 
{
    if (myCircularQueueIsFull(obj))
    {
        return false;
    }
    obj->a[obj->back] = value;
    obj->back++;
    obj->back %= (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;
    }
    else if (obj->back == 0)
    {
        return obj->a[obj->k];
    }
    else
    {
        return obj->a[obj->back - 1];
    }
}

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

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

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

相关文章

基于微信小程序的员工宿舍报修系统

基于微信小程序的员工宿舍报修系统

项目介绍 随着信息技术和网络技术的飞速发展&#xff0c;人类已进入全新信息化时代&#xff0c;传统管理技术已无法高效&#xff0c;便捷地管理信息。为了迎合时代需求&#xff0c;优化管理效率&#xff0c;各种各样的管理系统应运而生&#xff0c;各行各业相继进入信息管理时…
阅读更多...
路由器DHCP分配IP地址规则

路由器DHCP分配IP地址规则

路由器DHCP分配IP地址的机制&#xff1a; 先设置一个IP地址池&#xff0c;假设是192.168.1.100-192.168.1.199一共100个。 来一个请求&#xff0c;看一下是不是以前请求过的地址&#xff0c;如果是&#xff0c;还是返回以前给过的IP&#xff0c;然后将到期时间(有些路由器默认…
阅读更多...
8款优秀的MYSQL管理工具与应用程序推荐

8款优秀的MYSQL管理工具与应用程序推荐

文章目录 前言介绍InductionPinbaDB NinjaDB Tools ManagerDbeaverMyWebSQLNavicat后言 前言 hello world欢迎来到前端的新世界 &#x1f61c;当前文章系列专栏&#xff1a;Mysql &#x1f431;‍&#x1f453;博主在前端领域还有很多知识和技术需要掌握&#xff0c;正在不断努…
阅读更多...
html实现各种瀑布流(附源码)

html实现各种瀑布流(附源码)

文章目录 1.设计来源1.1 动态响应瀑布流1.2 分页瀑布流1.3 响应瀑布流 2.效果和源码2.1 动态效果2.2 源代码 源码下载 作者&#xff1a;xcLeigh 文章地址&#xff1a;https://blog.csdn.net/weixin_43151418/article/details/134613121 html实现各种瀑布流(附源码)&#xff0c;…
阅读更多...
Web前端 -----【Vue】（vue组件基础）一文带你了解组件的创建、注册、使用（包括组件的嵌套）

Web前端 -----【Vue】（vue组件基础）一文带你了解组件的创建、注册、使用（包括组件的嵌套）

目录 前言 什么是组件 为什么使用组件化开发 组件的使用 组件的使用分为三个步骤 创建组件 为什么配置项中的data不能使用直接对象的形式&#xff0c;必须使用function&#xff08;重点&#xff01;&#xff01;&#xff01;面试喜欢问&#xff09; 注册组件 使用组件 …
阅读更多...
【经验分享】开发问题记录总结(持续更新)

【经验分享】开发问题记录总结(持续更新)

目录 工具开发 界面类继承某自定义界面类时&#xff0c;出现布局混乱或者所有控件集中在左上角&#xff1f; 在继承自定义界面之后&#xff0c;以诸如 on_xxx_clicked() 模式设计的槽函数失效了? 使用pugi接口取出文本数据后&#xff0c;为什么该变量无法进行字符串比较&…
阅读更多...
华硕V4050E笔记本安装Win10不识别硬盘解决方法

华硕V4050E笔记本安装Win10不识别硬盘解决方法

笔记本硬件参数&#xff1a; ASUS VivoBook14 V4050E 型 号 V4050EP1135-0DAKXQ2X10 制造日期 2020-12 12M C P U 11th Gen Intel(R)Core(TM)i5-1135G72.4GHz 2.42GHz 4核心 8线程 L2&#xff1a;5MB L3&#xff1a;8MB 内 存 16.0GB &#xff08;8Gb X2 320…
阅读更多...
多目标水母搜索算法(MOJS)求解微电网优化MATLAB

多目标水母搜索算法(MOJS)求解微电网优化MATLAB

一、微网系统运行优化模型 微电网优化模型介绍&#xff1a; 微电网多目标优化调度模型简介_IT猿手的博客-CSDN博客 二、多目标水母搜索算法MOJS 多目标水母搜索算法&#xff08;Multi-Objective Jellyfish Search algorithm&#xff0c;MOJS&#xff09;由Jui-Sheng Chou等…
阅读更多...
持续增长的背后，艾比森用泛微-千里聆RPA机器人为业务加速

持续增长的背后，艾比森用泛微-千里聆RPA机器人为业务加速

&#xff08;艾比森全球总部&#xff09; 艾比森集团始创于2001年&#xff0c;是全球知名的至真LED显示应用与服务提供商。目前旗下设有深圳总部&#xff0c;艾比森东江智造中心&#xff0c;以及艾比森美国、德国、日本、迪拜、俄罗斯、墨西哥、巴西、中国香港等18家海内外公司…
阅读更多...
css中flex两列布局（一列自适应其他固定）

css中flex两列布局（一列自适应其他固定）

问题 最近写一个布局的时候&#xff0c;遇到一个问题。如下图的布局。在没有图片的时候布局是正常的&#xff0c;如果有图片且设置了width:100%;height: 100%; 则会出现图片将自适应布局撑开的情况。 我的解决方式是让图片不缩放&#xff0c;图片外层再添加一个div元素。形如…
阅读更多...
linux rpm安装软件卸载 以卸载mysql为例

linux rpm安装软件卸载 以卸载mysql为例

查看rpm包 rpm -qa | grep 内容 卸载rpm rpm -e --nodeps rpm名称
阅读更多...
「最优化基础知识2」一维搜索，以及python代码

「最优化基础知识2」一维搜索，以及python代码

最优化基础知识&#xff08;2&#xff09; 无约束优化问题&#xff0c;一维搜索 一、一维搜索 一维搜索的意思是在一个方向上找到最小点。 用数学语言描述&#xff0c;X*Xk tPk&#xff0c;从Xk沿着Pk方向行走t到达最小点X*。 1、收敛速度&#xff1a; 线性收敛&#xff1…
阅读更多...
zookeeper 单机伪集群搭建简单记录

zookeeper 单机伪集群搭建简单记录

1、官方下载加压后&#xff0c;根目录下新建data和log目录&#xff0c;然后分别拷贝两份&#xff0c;分别放到D盘&#xff0c;E盘&#xff0c;F盘 2、data目录下面新建myid文件&#xff0c;文件内容分别为1&#xff0c;2&#xff0c;3.注意文件没有后缀&#xff0c;不能是txt文…
阅读更多...
kolla-ansible 部署OpenStack云计算平台

kolla-ansible 部署OpenStack云计算平台

目录 一、环境 二、安装及部署 三、测试 一、环境 官方文档&#xff1a;https://docs.openstack.org/kolla-ansible/yoga/user/quickstart.html rhel8.6 网络设置&#xff1a; 修改网卡名称 网络IP&#xff1a; 主机名&#xff1a; 网络时间协议 配置软件仓库 vim docke…
阅读更多...
ubuntu 使用webrtc_ros 编译linux webrtc库

ubuntu 使用webrtc_ros 编译linux webrtc库

ubuntu 使用webrtc_ros 编译linux webrtc库 webrtc_ros 使用WebRTC流式传输ROS图像主题 该节点提供了一个WebRTC对等方&#xff0c;可以将其配置为流ROS图像主题并接收发布到ROS图像主题的流。 该节点托管一个提供简单测试页面的Web服务器&#xff0c;并提供可用于创建和配置W…
阅读更多...
torch.nn.batchnorm1d，torch.nn.batchnorm2d，torch.nn.LayerNorm解释：

torch.nn.batchnorm1d，torch.nn.batchnorm2d，torch.nn.LayerNorm解释：

批量归一化是一种加速神经网络训练和提升模型泛化能力的技术。它对每个特征维度进行标准化处理&#xff0c;即调整每个特征的均值和标准差&#xff0c;使得它们的分布更加稳定。 Batch Norm主要是为了让输入在激活函数的敏感区。所以BatchNorm层要加在激活函数前面。 1.torch.…
阅读更多...
万字解析设计模式之策略模式、命令模式

万字解析设计模式之策略模式、命令模式

一、策略模式 1.1概述 先看下面的图片&#xff0c;我们去旅游选择出行模式有很多种&#xff0c;可以骑自行车、可以坐汽车、可以坐火车、可以坐飞机。 策略模式&#xff08;Strategy Pattern&#xff09;是一个行为型设计模式&#xff0c;它定义了一组算法家族&#xff0c;分…
阅读更多...
ubuntu22.04 安装 jupyterlab

ubuntu22.04 安装 jupyterlab

JupyterLab Install JupyterLab with pip: pip install jupyterlabNote: If you install JupyterLab with conda or mamba, we recommend using the conda-forge channel. Once installed, launch JupyterLab with: jupyter lab
阅读更多...
C/C++ 运用Npcap发送UDP数据包

C/C++ 运用Npcap发送UDP数据包

Npcap 是一个功能强大的开源网络抓包库&#xff0c;它是 WinPcap 的一个分支&#xff0c;并提供了一些增强和改进。特别适用于在 Windows 环境下进行网络流量捕获和分析。除了支持通常的网络抓包功能外&#xff0c;Npcap 还提供了对数据包的拼合与构造&#xff0c;使其成为实现…
阅读更多...
83基于matlab 的时钟时间识别GUI

83基于matlab 的时钟时间识别GUI

基于matlab 的时钟时间识别GUI。图像去除背景-转化为二值化图像-找出对应的直线边缘-找到秒针、分针、时针对应的直线&#xff0c;并算出斜率、角度-判断时间&#xff0c;分针与时针 &#xff08;度数&#xff09;。数据可更换自己的&#xff0c;程序已调通&#xff0c;可直接运…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023