【C++】OJ习题 篇2

news2024/9/21 0:44:13
头像
🚀个人主页：奋斗的小羊
🚀所属专栏：C++
很荣幸您能阅读我的文章，诚请评论指点，欢迎欢迎 ~

动图描述

目录

    • 💥1、删除有序数组中的重复项
    • 💥2、数组中出现次数超过一半的数字
    • 💥3、最小栈
    • 💥4、栈的压入、弹出序列
    • 💥5、环形链表
    • 💥6、环形链表 II
    • 💥7、用队列实现栈
    • 💥8、用栈实现队列
    • 💥9、设计循环队列

💥1、删除有序数组中的重复项

  • Leetcode——删除有序数组中的重复项

在这里插入图片描述
示例：

在这里插入图片描述

可以用快慢指针，快指针表示遍历数组到达的下标位置，慢指针表示下一个不同元素要填入的下标位置，初始时两个指针都指向下标1，这是为了体现慢指针记录不重复的数据个数。
删除重复项和找不重复的项效果是一样的。

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int slow = 1;
        for (int fast = 1; fast < nums.size(); ++fast)
        {
            if (nums[fast] != nums[fast - 1])
            {
                nums[slow++] = nums[fast];
            }
        }
        return slow;
    }
};

💥2、数组中出现次数超过一半的数字

  • 牛客——数组中超过一半的数字

在这里插入图片描述

方法一：候选法

  • 时间复杂度：O(N)
  • 空间复杂度：O(1)

初始化一个候选目标val和得票数count，遍历数组，如果当前的得票数count为0的话就选当前在数组中拿到的元素为目标，如果得票数count不为0，有和val相等的元素就给它投一票，遇到不相等的就减一票。 遍历完数组后val就是出现次数超过数组长度一般的数。

  • 我们暂且将出现次数超过数组长度一半的数称作众数。数组中如果两个数不相等，就消去这两个数，最坏情况下，每次消去一个众数和一个非众数，那么如果存在众数，最后留下的数肯定是众数
class Solution {
public:
    int MoreThanHalfNum_Solution(vector<int>& numbers) {
        int val = 0;
        int count = 0;
        for (int e : numbers)
        {
            if (0 == count)
            {
                val = e;
                ++count;
            }
            else {
            count = val == e ? ++count : --count;
            }
        }
        return val;
    }
};

方法二：排序法

  • 时间负责度：O(N*logN)
  • 空间负责度：O(1)

既然众数的个数超过了数组长度的一半，那有序数组中间位置的数一定就是众数。

class Solution {
public:
    int MoreThanHalfNum_Solution(vector<int>& numbers) {
        sort(numbers.begin(), numbers.end());
        return numbers[numbers.size() / 2];
    }
};

💥3、最小栈

  • Leetcode——最小栈

在这里插入图片描述
定义一个主栈和辅助栈，主栈支持push、pop、top操作，辅助栈用于存相比于栈顶数据更小的或相等的数，主栈pop时如果栈顶数据和辅助栈栈顶数据相等，辅助栈也跟着pop，那么常数时间内检索到的最小元素就是辅助栈栈顶数据。

在这里插入图片描述

class MinStack {
public:
    MinStack() {}
    
    void push(int val) {
        _st.push(val);
        if (_minst.empty() || val <= _minst.top())
        {
            _minst.push(val);
        }
    }
    
    void pop() {
        if (_st.top() == _minst.top())
        {
            _minst.pop();
        }
        _st.pop();
    }
    
    int top() {
        return _st.top();
    }
    
    int getMin() {
        return _minst.top();
    }
private:
    stack<int> _st;
    stack<int> _minst;
};

💥4、栈的压入、弹出序列

  • 牛客——栈的压入、弹出序列

在这里插入图片描述

定义一个栈用于压入数据，一个下标用于访问弹出序列。将压入序列依次放入栈中，期间如果某次压入的值和弹出序列的第一个数相等，那么就弹出刚压入的这个数，再++下标。
其中弹出栈中的数时要保证栈不为空，当访问完所有的压入数据后，检查栈是否为空，如果为空则返回真，否则返回假。

class Solution {
public:
    bool IsPopOrder(vector<int>& pushV, vector<int>& popV) {
        // write code here
        int i = 0;
        for (int e : pushV)
        {
            _st.push(e);
            while (!_st.empty() && _st.top() == popV[i])
            {
                _st.pop();
                ++i;
            }
        }
        return _st.empty();
    }
private:
    stack<int> _st;
};

💥5、环形链表

  • Leetcode——环形链表

在这里插入图片描述

快慢指针法： 快指针和慢指针初始时指向头节点，当快指针指向和快指针指向节点内的next指针不为空时，快指针一次走两步，慢指针一次走一步，快指针入环后走N圈后慢指针入环，当快指针和慢指针相等时说明存在环，如果出循环则说明不存在环。

关键的地方是快指针一次走两步，慢指针一次走一步，如果存在环则快指针和慢指针一定会相遇。为什么一定会相遇呢？
如果存在环，假设当慢指针入环时快指针距离此时慢指针的位置为N，则接下来每当快指针追赶慢指针一次，它们的距离就减一，直到减为0，此时快慢指针就相遇了。

在这里插入图片描述

bool hasCycle(struct ListNode *head) {
    struct ListNode* fast = head, *slow = head;
    while (fast && fast->next)
    {
        fast = fast->next->next;
        slow = slow->next;
        if (fast == slow)
        {
            return true;
        }
    }
    return false;
}

💥6、环形链表 II

  • Leetcode——环形链表 II

在这里插入图片描述

还是快慢指针，当快慢指针相遇时我们让meet指针指向相遇时的节点，然后让头指针head和meet指针一步步地向后走，当两指针相遇时指向的节点就是链表开始入环的第一个节点。为什么这两个指针一定会相遇在链表开始入环的第一个节点？

假设头指针距离链表开始入环的第一个节点的长度为L，meet指针相距链表开始入环的第一个节点的距离是N，环的长度为C，当慢指针入环时快指针走了x圈，因为快指针的速度是慢指针的2倍，那我们可以得到下面的等式：

  • 2(L + N) = L + X*C + N

化简得：L = X*C - N，由这个等式可以得出head和meet相遇是必然的。
在这里插入图片描述

struct ListNode *detectCycle(struct ListNode *head) {
    struct ListNode* fast = head, *slow = head;
    while (fast && fast->next)
    {
        fast = fast->next->next;
        slow = slow->next;
        if (fast == slow)
        {
            struct ListNode* meet = fast;
            while (head != meet)
            {
                head = head->next;
                meet = meet->next;
            }
            return meet;
        }
    }
    return NULL;
}

💥7、用队列实现栈

  • Leetcode——用队列实现栈

在这里插入图片描述

栈的特点是后进先出，队列的特点是先进先出，用队列实现栈，必须有一个辅助队列在栈数据pop的时候用来导数据，将栈中需要pop的数据放到队列的队头pop。
也就是说用队列实现栈需要两个队列，一个存数据一个导数据，一个为空一个不为空，其中入栈时往不为空的队列中入数据，为空的队列只有一个作用，就是栈pop数据时导数据。
其中队列还有一个重要的特点，就是出队列不会改变数据的相对位置。

在这里插入图片描述

typedef struct {
    Que q1;
    Que 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->q2, x);
    }
    else{
        QueuePush(&obj->q1, x);
    }
}

int myStackPop(MyStack* obj) {
	//假设法
    Que* empty = &obj->q1;
    Que* noempty = &obj->q2;
    if (!QueueEmpty(&obj->q1))
    {
        empty = &obj->q2;
        noempty = &obj->q1;
    }
    while (QueueSize(noempty) > 1)
    {
        QueuePush(empty, QueueFront(noempty));
        QueuePop(noempty);
    }
    int 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) {
    return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}

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

💥8、用栈实现队列

  • Leetcode——用栈实现队列

在这里插入图片描述

用两个栈实现队列，这里有两个方法。
方法一：和用两个队列实现栈类似，其中的一个栈用来导数据，因为栈的特点是后进先出，所以将栈中的数据导过来会让数据的相对位置颠倒，所以最后还需要将数据重新导回来才能保证数据的相对位置不变。

typedef int st_data_type;

typedef struct stack
{
	st_data_type* arr;
	int top;
	int capacity;
}stack;
void stack_init(stack* pst)
{
	assert(pst);
	pst->arr = NULL;
	pst->top = pst->capacity = 0;
}

//入栈
void stack_push(stack* pst, st_data_type x)
{
	assert(pst);
	if (pst->capacity == pst->top)
	{
		int newcapacity = pst->capacity == 0 ? 4 : 2 * pst->capacity;
		st_data_type* tmp = (st_data_type*)realloc(pst->arr, newcapacity * sizeof(st_data_type));
		if (tmp == NULL)
		{
			perror("realloc fail!");
			return;
		}
		pst->arr = tmp;
		tmp = NULL;
		pst->capacity = newcapacity;
	}
	pst->arr[pst->top] = x;
	pst->top++;
}

//出栈
void stack_pop(stack* pst)
{
	assert(pst);
	assert(pst->top > 0);
	pst->top--;
}

//取出栈顶元素
st_data_type stack_top(stack* pst)
{
	assert(pst);
	assert(pst->top > 0);
	return pst->arr[pst->top-1];
}

//销毁
void stack_destroy(stack* pst)
{
	assert(pst);
	free(pst->arr);
	pst->arr = NULL;
	pst->capacity = pst->top = 0;
}

//判空
bool stack_empty(stack* pst)
{
	assert(pst);
	return pst->top == 0;
}

//获取元素个数
int stack_size(stack* pst)
{
	assert(pst);
	return pst->top;
}

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

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

void myQueuePush(MyQueue* obj, int x) {
    if (stack_empty(&obj->st1))
    {
        stack_push(&obj->st2, x);
    }
    else
    {
        stack_push(&obj->st1, x);
    }
}

int myQueuePop(MyQueue* obj) {
    stack* empty = &obj->st1;
    stack* noempty = &obj->st2;
    if (stack_empty(&obj->st2))
    {
        empty = &obj->st2;
        noempty = &obj->st1;
    }
    while (stack_size(noempty) > 1)
    {
        stack_push(empty, stack_top(noempty));
        stack_pop(noempty);
    }
    int top = stack_top(noempty);
    stack_pop(noempty);
    while (!stack_empty(empty))
    {
        stack_push(noempty, stack_top(empty));
        stack_pop(empty);
    }
    return top;
}

int myQueuePeek(MyQueue* obj) {
    stack* empty = &obj->st1;
    stack* noempty = &obj->st2;
    if (stack_empty(noempty))
    {
        empty = &obj->st2;
        noempty = &obj->st1;
    }
    while (!stack_empty(noempty))
    {
        stack_push(empty, stack_top(noempty));
        stack_pop(noempty);
    }
    int top = stack_top(empty);
    while (!stack_empty(empty))
    {
        stack_push(noempty, stack_top(empty));
        stack_pop(empty);
    }
    return top;
}

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

void myQueueFree(MyQueue* obj) {
    stack_destroy(&obj->st1);
    stack_destroy(&obj->st2);
    free(obj);
}

方法二：正是因为栈后进先出的特点，我们可以不用将导过来的数据再导回去，一个栈专门用来入数据，另一个栈专门用来出数据。 很显然这种方法更为简单。

typedef int st_data_type;

typedef struct stack
{
	st_data_type* arr;
	int top;
	int capacity;
}stack;
void stack_init(stack* pst)
{
	assert(pst);
	pst->arr = NULL;
	pst->top = pst->capacity = 0;
}

//入栈
void stack_push(stack* pst, st_data_type x)
{
	assert(pst);
	if (pst->capacity == pst->top)
	{
		int newcapacity = pst->capacity == 0 ? 4 : 2 * pst->capacity;
		st_data_type* tmp = (st_data_type*)realloc(pst->arr, newcapacity * sizeof(st_data_type));
		if (tmp == NULL)
		{
			perror("realloc fail!");
			return;
		}
		pst->arr = tmp;
		tmp = NULL;
		pst->capacity = newcapacity;
	}
	pst->arr[pst->top] = x;
	pst->top++;
}

//出栈
void stack_pop(stack* pst)
{
	assert(pst);
	assert(pst->top > 0);
	pst->top--;
}

//取出栈顶元素
st_data_type stack_top(stack* pst)
{
	assert(pst);
	assert(pst->top > 0);
	return pst->arr[pst->top-1];
}

//销毁
void stack_destroy(stack* pst)
{
	assert(pst);
	free(pst->arr);
	pst->arr = NULL;
	pst->capacity = pst->top = 0;
}

//判空
bool stack_empty(stack* pst)
{
	assert(pst);
	return pst->top == 0;
}

//获取元素个数
int stack_size(stack* pst)
{
	assert(pst);
	return pst->top;
}

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


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

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

int myQueuePop(MyQueue* obj) {
    if (stack_empty(&obj->popst))
    {
        while (!stack_empty(&obj->pushst))
        {
            stack_push(&obj->popst, stack_top(&obj->pushst));
            stack_pop(&obj->pushst);
        }
    }
    int top = stack_top(&obj->popst);
    stack_pop(&obj->popst);
    return top;
}

int myQueuePeek(MyQueue* obj) {
    if (stack_empty(&obj->popst))
    {
        while (!stack_empty(&obj->pushst))
        {
            stack_push(&obj->popst, stack_top(&obj->pushst));
            stack_pop(&obj->pushst);
        }
    }
    return stack_top(&obj->popst);
}

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

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

💥9、设计循环队列

  • Leetcode——设计循环队列

在这里插入图片描述

这里我们用数组来实现循环队列会相对简单一些，让head指向第一个位置，让tail指向最后一个元素的下一个位置。假设队列长度为K，我们开K + 1个空间，多开一个空间是为了方便区分队列为空和队列为满。也可以在结构体中多加一个变量用来计数。因为如果不多开一个空间，队列为空时是head == tail，队列为满时也是head == tail，无法区分。多开一个空间后，队列为满就是head == (tail + 1) % (k + 1).
当tail越界时我们对其模K+1，让tail指向下标为0的位置。
在这里插入图片描述

typedef struct {
    int* a;
    int head;
    int tail;
    int k;
} MyCircularQueue;

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->head == obj->tail;
}

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

MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* pq = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    pq->a = (int*)malloc(sizeof(int)*(k + 1));
    pq->head = pq->tail = 0;
    pq->k = k;
    return pq;
}

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

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

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

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

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

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

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

相关文章

【js逆向专题】2.浏览器调试技巧

【js逆向专题】2.浏览器调试技巧

小节目标: 熟悉 开发者工具的使用熟悉 代码断点的方式熟悉 网页debugger实现方式 一. 浏览器开发者工具 1. element元素面板 展示浏览器渲染之后的页面 2. network网络面板 浏览器请求的数据都会加载在网络面板 3. console控制台面板 可以在控制台调试你对应的代码 4.…
阅读更多...
Call openai-node in the backend or call https in the frontend?

Call openai-node in the backend or call https in the frontend?

题意&#xff1a;在后端调用 openai-node 还是在前端调用 https&#xff1f; 问题背景&#xff1a; I have a web application by ReactJS and Nodejs. This application calls OpenAI APIs. 我有一个使用 ReactJS 和 Node.js 开发的 Web 应用程序。这个应用程序调用 OpenAI …
阅读更多...
分享几个简单的Pandas数据处理函数

分享几个简单的Pandas数据处理函数

文末赠免费精品编程资料~~ 大家好&#xff0c;今天给大家简单分享几个好用的Pandas数据处理函数。 id,category,sub_category,sales,year,var1,var2,age,score,status,quantity 1,A,B,100,2019,50,70,35,85,active,100 2,B,C,120,2020,60,80,28,90,inactive,200 3,A,C,110,20…
阅读更多...
RTX5源码全家桶集成emWin6.40, Modbus主从，含FreeRTOS版, 探讨一种移植第3方组件通用方法以及使用注意事项2024-08-30

RTX5源码全家桶集成emWin6.40, Modbus主从，含FreeRTOS版, 探讨一种移植第3方组件通用方法以及使用注意事项2024-08-30

视频&#xff1a; https://www.bilibili.com/video/BV1tFHuenESf RTX5源码全家桶集成emWin6.40, Modbus主从&#xff0c;含FreeRTOS版, 探讨一种移植第3方组件的通用方法以及多任务使用注意事项 提纲&#xff1a; 参考资料: 1、例程下载 RTX5 All In One(2024-08-30 V2.0).7…
阅读更多...
计算机毕业设计选题推荐-高校实验室教学管理系统-Java/Python项目实战

计算机毕业设计选题推荐-高校实验室教学管理系统-Java/Python项目实战

✨作者主页&#xff1a;IT研究室✨ 个人简介&#xff1a;曾从事计算机专业培训教学&#xff0c;擅长Java、Python、微信小程序、Golang、安卓Android等项目实战。接项目定制开发、代码讲解、答辩教学、文档编写、降重等。 ☑文末获取源码☑ 精彩专栏推荐⬇⬇⬇ Java项目 Python…
阅读更多...
RNN及其变体

RNN及其变体

RNN及其变体 RNN模型定义 循环神经网络:一般接受的一序列进行输入,输出也是一个序列 作用和应用场景: RNN擅长处理连续语言文本,机器翻译,文本生成,文本分类,摘要生成 RNN模型的分类 根据输入与输出结构 N Vs N : 输入和输出等长,应用场景:对联生…
阅读更多...
利用 ChatGPT 快速将界面原型转换为 Vue 代码实现

利用 ChatGPT 快速将界面原型转换为 Vue 代码实现

在现代前端开发中&#xff0c;快速、高效地将设计原型转化为实际可运行的代码是开发人员追求的目标。借助 ChatGPT&#xff0c;这一过程可以显著加速。本文将展示如何通过 ChatGPT 辅助开发&#xff0c;将基于 iView 框架的界面原型在短短 2~3 分钟内转换为 Vue 代码&#xff0…
阅读更多...
影视会员充值API接口如何开发？

影视会员充值API接口如何开发？

影视会员充值 API 接口的开发流程 需求分析 明确接口的功能需求、性能要求和安全标准等 设计规划 确定接口的架构、数据格式、交互方式等 技术选型 选择适合的开发语言、框架和数据库等 编码实现 按照设计进行代码编写和功能实现 测试优化 进行单元测试、集成测试、压力测…
阅读更多...
黄力医生谈健康：掌握这几个秘诀，帮你远离冠心病困扰！

黄力医生谈健康：掌握这几个秘诀，帮你远离冠心病困扰！

随着生活水平的提高&#xff0c;人们的饮食结构和生活习惯发生了显著变化&#xff0c;这使得冠心病的患病率呈现出逐年上升的趋势&#xff0c;且发病年龄也越来越年轻化。面对这一严峻的健康挑战&#xff0c;提高对冠心病的认识&#xff0c;及早进行干预显得尤为重要。今天&…
阅读更多...
【鬼灭之刃学英语 立志篇】2、义勇对炭治郎的怒斥

【鬼灭之刃学英语 立志篇】2、义勇对炭治郎的怒斥

义勇对炭治郎的怒斥 1、不要卑躬屈膝2、脆弱的3、与现在事实相反的虚拟语气4、像你这样的弱者5、别开玩笑了6、弱者没有权利7、无情地被强者碾压8、知道做某事的方法9、尊重意愿10、这就是现实11、那就是你做某事的方式吗12、你为什么不...13、是...导致...1x、本可以做某事 1、…
阅读更多...
OpenCV绘图函数（11）计算文本字符串在特定字体、尺寸和厚度下的大小的函数getTextSize()的使用

OpenCV绘图函数（11）计算文本字符串在特定字体、尺寸和厚度下的大小的函数getTextSize()的使用

操作系统&#xff1a;ubuntu22.04 OpenCV版本&#xff1a;OpenCV4.9 IDE:Visual Studio Code 编程语言&#xff1a;C11 算法描述 计算一个文本字符串的宽度和高度。 函数 cv::getTextSize 计算并返回包含指定文本的矩形框的尺寸。也就是说&#xff0c;下面的代码渲染一些文本…
阅读更多...
Cadence高速板设计技巧（全志H3）[三]

Cadence高速板设计技巧（全志H3）[三]

Cadence绕等长线真的是好用&#xff0c;这一点碾压AD和嘉立创。 这里有一个技巧&#xff0c;在CPU四周的焊盘有时候确实需要过孔换层&#xff0c;但是并不直接在CPU周围打孔&#xff0c;把线拉出去过孔&#xff0c;这样可以防止焊接的时候锡流进过孔造成短路&#xff0c;同时也…
阅读更多...
2.1 程序设计语言与概述

2.1 程序设计语言与概述

以下程序设计语言中&#xff0c;&#xff08; &#xff09;更适合用来进行动态网页处理。 A. HTML B. LISP C. PHP D. JAVA/C 正确答案是 C。 解析 HTML&#xff1a;静态网页 LISP&#xff1a;一种基于入演算的函数式编程语言 PHP&#xff1a;混合了C、Java、Perl以及PHP自创的…
阅读更多...
C#学习笔记（二）安装开发环境、代码编译运行

C#学习笔记（二）安装开发环境、代码编译运行

博主刚开始接触C#&#xff0c;本系列为学习记录&#xff0c;如有错误欢迎各位大佬指正&#xff01;期待互相交流&#xff01; 文章目录 一、安装开发环境二、编写C#代码2.1 打开终端命令窗口2.2 编译运行2.3 清除终端窗口 一、安装开发环境 博主选择安装的是VS Code&#xff0…
阅读更多...
食家巷中秋美食，味蕾上的团圆盛宴

食家巷中秋美食，味蕾上的团圆盛宴

月到中秋分外明&#xff0c;在这个充满温情与思念的节日里&#xff0c;美食成为了人们传递情感、共享团圆的重要载体。而食家巷&#xff0c;以其独特的中秋美食&#xff0c;为这个佳节增添了一抹别样的风味。 走进食家巷&#xff0c;仿佛踏入了一个美食的宝藏之地。这里的传统…
阅读更多...
MES系统在汽车行业的应用

MES系统在汽车行业的应用

1. MES系统在汽车行业的应用背景 1.1 汽车行业生产特点 复杂性&#xff1a;汽车制造涉及成千上万的零部件&#xff0c;需要高度复杂的生产流程和精细的工艺管理。定制化&#xff1a;随着消费者需求的多样化&#xff0c;汽车行业越来越倾向于小批量、多品种的生产模式。质量要…
阅读更多...
实战 element-plus 级联选择器（Cascader）+企微部门架构

实战 element-plus 级联选择器（Cascader）+企微部门架构

先看效果 &#xff1a; 1、部门架构数据来源于企业微信&#xff1b; 2、部门层级关系的展现和勾选&#xff1b; 具体实现&#xff1a; 1、组件官方文档 http://element-plus.org/zh-CN/component/cascader.html 级联选择器组件要求的数据格式&#xff1a; 重点&#xff1a;了…
阅读更多...
一文解决CLion控制台(cmd)问题【超详细】

一文解决CLion控制台(cmd)问题【超详细】

CLion作为jetbrains全家桶中的一员&#xff0c;和其他产品一样都是轻量化&#xff0c;便捷&#xff0c;但有个地方不太方便&#xff0c;那就是控制台&#xff0c;有时候我们需要控制台&#xff0c;有时候又不需要&#xff0c;但在我们需要的时候&#xff0c;如何调出&#xff0…
阅读更多...
QMS质量管理系统：核心功能详解与企业落地实践指南

QMS质量管理系统：核心功能详解与企业落地实践指南

QMS&#xff08;Quality Management System&#xff09;质量管理系统是一种用于规划、实施、监控和持续改进企业质量活动的综合性系统。它涵盖了质量管理的各个方面&#xff0c;旨在确保产品和服务符合质量标准、法规要求及客户期望。以下是QMS质量管理系统的具体功能介绍&…
阅读更多...
零基础Opencv学习（三）

零基础Opencv学习（三）

概述&#xff1a;主要目的是为了在图像中获取所需要的特征信息&#xff0c;比如直线或者圆等 一、标准霍夫变换 cv::Mat midImage, dstImage;/// 边缘检测 转化灰度图cv::Canny(image, midImage, 50, 200, 3);cv::cvtColor(midImage, dstImage, CV_GRAY2BGR);/// 进行霍夫线变…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023