Leetcode做题记录----3

news2025/3/17 8:39:32

1474、删除链表M个节点之后的N个节点

思路：

1、两个循环解决问题 第一个循环移动M个位置，第二个循环确定移动N个位置后的，然后将M位置的节点的next指向，N位置后的节点即可

2、注意边界条件和判空处理

代码实现：

    public class Solution
    {
        public ListNode DeleteNodes(ListNode head, int m, int n)
        {
            //定义一个虚拟头结点 也叫哑节点
            //后面我们直接用这个dummy就不会担心找不到头结点了
            ListNode dummy = new ListNode();
            dummy.next = head;

            ListNode curr = dummy;

            while (curr != null)
            {
                if(curr==null)
                    break;
                //往后移动M个位置
                for (int i = 0; i < m &&curr!=null; i++)
                {
                    curr = curr.next;
                }
                //此时的current就是M节点
                //记录下他的下一个即next
                ListNode delStartNode = curr.next;
                //这里是用来寻找到移动N个节点后的
                //注意不能用Current这个后面还会利用的 不要破坏
                for (int i = 0; i < n &&delStartNode!=null; i++)
                {
                    delStartNode = delStartNode.next;
                }
                //赋过来就是删除了
                curr.next = delStartNode;
            }
            //最后返回头结点
            return dummy.next;

        }
    }

2011、执行操作后的变量值 

思路：

遍历字符串数组，比较每一个字符串的含义，然后利用条件分支语句执行即可

代码

    public class Solution
    {
        public int FinalValueAfterOperations(string[] operations)
        {
            int res = 0;
            for (int i = 0; i < operations.Length; i++)
            {
                switch (operations[i])
                {
                    case "X++":
                    case "++X":
                        res += 1;
                        break;
                    case "X--":
                    case "--X":
                        res -= 1;
                        break;
                    default:
                        break;
                }
            }
            return res;

        }
    }

202、快乐数

思路：

1、想办法获取到每个位置上的数字，怎么获取呢，首先我们是从右边开始获取数字的，所以用%10获取最后一位数字，然后使用/10就将整体减少了最后一位数字，就可以得到每个位置上的数字了

2、看到循环和一个固定的结果，我们就要想到，利用快慢指针进行算法的实现，当快指针和慢指针汇合时或者快指针为1，则说明题目已经完成了。

2160、拆分数位后四位数字的最小和 

思路：这道题很简单，将获得的整数，通过/10和%10获得每一位，然后通过排序就行了 

public class Solution {
    public int MinimumSum(int num) {
            string s = num.ToString();
            char[] chars = s.ToCharArray();
            //对于字符数组进行排序
            Array.Sort(chars);
            //强转为整型
            int n1 = int.Parse (chars[0].ToString());
            int n2 = int.Parse (chars[1].ToString());
            int n3 = int.Parse (chars[2].ToString());
            int n4 = int.Parse(chars[3].ToString());
            //计算得出结果
            return (n1 + n2)*10 + (n3+n4);
        
    }
}

2520、统计能整除数字的位数 

 

思路：这个也很简单，通过不断的%10找尾数，然后再让自身去除，看能否整除，能的话，计数器就加一，不能就直接进入下一轮。要注意一下输入的输入的情况，可能他输入个0整你

代码实现： 

public static int CountDigits(int num)
{
    if(num ==0)
        return 0;
    //计数器
    int counter = 0;
    while (num > 0)
    {
        int last = num % 10;

        if (last == 0) continue;
        if (num % last == 0)
        {
            counter++;
        }
        num /= 10;
    }
    return counter;
}

496、下一个更大元素

思路：

先对nums2进行预处理， 构建一个严格单调递减栈，然后将 每个“对”存到一个字典中，处理完之后，如果栈中还有剩余元素，就按照题目要求，配置他的另一半为-1.然后在遍历nums1,寻找字典中的键，然后返回结果。

代码：

    public class Solution
    {
        public int[] NextGreaterElement(int[] nums1, int[] nums2)
        {
            //构建单调栈
            Stack<int> stack = new Stack<int>();
            //创建字典 用于存当前元素后面的第一个比自己的元素
            Dictionary<int ,int> nextGreater = new Dictionary<int ,int>();
            //遍历nums2预处理
            foreach (var num in nums2)
            {
                //只要栈不为空，当前栈顶的元素小于下一个元素就直接加入字典
                //那么就是(当前元素，当前元素的下一个更大值)
                while (stack.Count != 0 && stack.Peek() < num)
                {
                    nextGreater[stack.Pop()] = num;
                }
                //反之压入
            stack.Push(num);
            }

            while (stack.Count != 0)
            {
                //处理栈中剩余的元素
                nextGreater[stack.Pop()] = -1;
            }
            //结果数组
            int[] res = new int[nums1.Length];

            for (int i = 0; i < nums1.Length; i++)
            {
                res[i] = nextGreater[nums1[i]];
            }
            return res;

        }
    }

633、平方数之和

思路：双指针思路，一个指针指向0，一个指针指向sqrt(c)。然后二者的平方和如果小于c那么a++，反之b--

代码： 

    public class Solution
    {
        public bool JudgeSquareSum(int c)
        {

            int a = 0;
            int b =(int)Math.Sqrt(c);

            while (a <= b)
            {
                int sum = a * a + b * b;
                if (sum == c)
                    return true;
                else if (sum < c)
                {
                    a++;
                }
                else if (sum > c)
                {
                    b--;
                }
            }
                return false;



            //for (int a = 0; a < Math.Sqrt(c); a++)
            //{
            //    for (int b = (int)Math.Sqrt(c); b > a; b++)
            //    {
            //        if(b*b + a*a == c*c)
            //            return true;
            //    }
            //}
            //return false;
        }
    }

注释的部分是会超时算法

520、检测大写字母

思路：

分析题目，无非三种正常情况。

首字母大写后面小写，全部大写，全部小写。那么是不是可以这样想，只有首字母小写加第二个字母大写是不合理的，但是只要后续字母和第一个字母是状态相同的话，是不是就是一个正确的单词组合。

代码：

    public class Solution
    {
        public bool DetectCapitalUse(string word)
        {
            //return (word == word.ToUpper())|| (word == word.ToLower())
            //    || (char.IsUpper(word[0]) && (word.Substring(1).ToLower() == word.Substring(1)));

            if (word.Length >= 2 && (word[0] == char.ToLower(word[0])) && (word[1] == char.ToUpper(word[1])))
            {
                return false;
            }
            for (int i = 2; i < word.Length; i++)
            {
                if (char.IsLower(word[i]) ^ char.IsLower(word[1]))
                {
                    return false;
                }
            }
            return true;
        }
    }

二分查找

思路：

典型的二分查找，设置两个指针，一个指向最左边，一个指向最右边，然后从中间开始查找，注意这里会有左闭右闭，和左闭右开的两种写法。
左闭右闭：说明左右都可以取到，那么循环条件就是左边<=右边，然后里面就是正常的，目标值大于中间值，就左边界移动为mid+,反之右边界为mid-1.

左闭右开：那么说明取不到右边，则循环条件为左边界<右边界，里面就是左边等于mid+1，右边界变化就是直接为mid即可

本道题的代码实现：

    public class Solution
    {
        public int Search(int[] nums, int target)
        {
            int left = 0;
            int right = nums.Length - 1;
            while (left <= right)
            {
                int mid  = left + (right - left) / 2;
                if (nums[mid] < target)
                {
                    left = mid + 1;
                }
                else if (nums[mid] > target) 
                {
                    right = mid - 1;
                }
                else return nums[mid];
            }
            return -1;
        }
    }

另外两种写法

//左闭右闭
public class Solution
{
    public int Search(int[] nums, int target)
    {
        int left = 0;
        int right = nums.Length - 1;
        while (left <= right)
        {
            int mid = (right - left) / 2 + left;
            if (nums[mid] == target)
            {
                return mid;
            }
            else if (nums[mid] < target)
            {
                left = mid + 1;
            }
            else if (nums[mid] > target)
            {
                right = mid - 1;
            }
        }
        return -1;
    }
}

//左闭右开
public class Solution
{
    public int Search(int[] nums, int target)
    {
        int left = 0;
        int right = nums.Length;
        while (left < right)
        {
            int mid = (right - left) / 2 + left;
            if (nums[mid] == target)
            {
                return mid;
            }
            else if (nums[mid] < target)
            {
                left = mid + 1;
            }
            else if (nums[mid] > target)
            {
                right = mid;
            }
        }
        return -1;
    }
}

和二分查找类似的相关题目：

34、在排序数组中查找元素的第一个和最后一个位置

思路：先找到左边界，然后重新设置右边界。同样是利用二分查找的方式寻找左边界。经过二分查找后，那么最左边的下标一定就是目标值所在的位置，如果这个位置的元素和目标元素不一样的话，那么就不存在这个目标元素。

代码实现：

    public class Solution
    {
        public int[] SearchRange(int[] nums, int target)
        {
            int left = 0;
            int right = nums.Length - 1;
            //定义结果数组
            int[] result = new int[] { -1, -1 };
            //如果为空直接返回
            if(nums.Length==0) return result;

            //为什么是<呢，因为这是一个区间就算为一也不能左右相等，因为不是同一个
            while (left < right)
            {
                //防止溢出
                int mid = left + (right - left) / 2;
                //设置左边界
                if (nums[mid] < target) left = mid + 1;
                //设置右边界
                else right = mid;
            }
            if (nums[left]!=target) return result;
            result[0] = left;
            //重置 开始找右边界
            right = nums.Length - 1;
            while (left < right)
            {
                int mid = left + (right - left +1) / 2;
                if(nums[mid] > target) right = mid - 1;
                else left = mid;
            }
            //装结果
            result[1] = right;
            return result;
        }
    }

34、在排序数组中查找元素的第一个和最后一个位置

    public class Solution
    {
        public int[] SearchRange(int[] nums, int target)
        {
            int left = 0;
            int right = nums.Length - 1;
            //定义结果数组
            int[] result = new int[] { -1, -1 };
            //如果为空直接返回
            if(nums.Length==0) return result;

            //为什么是<呢，因为这是一个区间就算为一也不能左右相等，因为不是同一个
            while (left < right)
            {
                //防止溢出
                int mid = left + (right - left) / 2;
                //设置左边界
                if (nums[mid] < target) left = mid + 1;
                //设置右边界
                else right = mid;
            }
            if (nums[left]!=target) return result;
            result[0] = left;
            //重置 开始找右边界
            right = nums.Length - 1;
            while (left < right)
            {
                int mid = left + (right - left +1) / 2;
                if(nums[mid] > target) right = mid - 1;
                else left = mid;
            }
            //装结果
            result[1] = right;
            return result;
        }
    }

35、搜索插入位置

思路：继续二分查找即可，这个是左闭右闭的区间。

public class Solution {
    public int SearchInsert(int[] nums, int target) {
                    int left = 0;
            int right = nums.Length - 1;
            while (left <= right)
            {
                int mid = left + (right - left)/2;
                if (nums[mid] < target)
                {
                    left = mid + 1;
                }
                else if (nums[mid] > target)
                {
                    right = mid - 1;
                }
                else return mid;
            }
            return left;
    }
}

69、x的平方根

思路：同理继续二分查找就行，只不过注意的是最后的结果是mid.

代码实现：

    public class Solution
    {
        public int MySqrt(int x)
        {
            int left = 1;
            int right = x;
            while (left <= right)
            {
                int mid = left + (right - left) / 2;
                if (mid > x / mid) right = mid - 1;
                else left = mid + 1;
            }
            return left - 1;
        }
    }

367、有效的完全平方数

思路：这道题得单独的将0和1拿出来考虑，这样会比较的方便处理。然后就是可能会数据溢出，所以得拿个大的容器去装我们的mid*mid，然后如果大于num的话，就需要进行左移，那么就是改变有边界。小于的话，就需要右移，那么就改左边界。

代码实现：

    public class Solution
    {
        public bool IsPerfectSquare(int num)
        {
            long left = 1;
            long right = num;
            if(num == 0||num==1) return true;

            while (left <= right)
            {
                long mid = (left + right) / 2;
                long square = mid * mid;
                if(square==num) return true;
                else if(square<num) left = mid +1;
                else right = mid - 1;
            }
            return false;
        }
    }

双指针

26删除有序数组中的重复项

思路：定义一个指针用来进行维护答案的数组，然后另外一个指针负责移动，然后在移动的时候，注意题目条件的处理，即可得解。

    public class Solution
    {
        public int RemoveDuplicates(int[] nums)
        {
            //判空
            if(nums.Length==0) return 0;

            //维护的数组下标
            int netIndex = 0;
            for (int i = 1; i < nums.Length; i++)
            {
                //如果当前元素还没有出现过 就加进来
                //如果当前元素已经出现过，那么 一个指针一直往后移动
                //直到遇到下一个没有出现过的元素
                //然后将这个新元素 赋值到维护数组的下一个位置
                if (nums[i] != nums[netIndex])
                {
                    netIndex++;
                    nums[netIndex] = nums[i];
                }
            }
            //你维护的是数组的下标
            //返回的是长度
            return netIndex + 1;
        }
    }

27、移除元素

思路和上题目一样：

代码实现：

public class Solution {
    public int RemoveElement(int[] nums, int val) {
                    int slow = 0;
            for (int i = 0; i < nums.Length; i++)
            {
                if (nums[i] != val)
                {
                    nums[slow++] = nums[i];
                }
            }
            return slow;
    }
}

283、移动零

思路：先把不为零的数字往前移动，一个贴一个，最后补0即可

代码实现：

    public class Solution
    {
        public void MoveZeroes(int[] nums)
        {
            int nextNonZero = 0;
            //移位
            for (int i = 0; i < nums.Length; i++)
            {
                if (nums[i] != 0)
                {
                    //注意是先移动了已经存好的数组的下标
                    //因为下一个元素为0
                    nextNonZero++;
                    nums[nextNonZero] = nums[i];
                }
            }
            //补零
            for (int i = nextNonZero; i < nums.Length; i++)
            {
                nums[i] = 0;
            }
        }
    }

977、有序数组的平方

思路：

①全部平方完以后，排序得解。

②利用双指针，因为这个数组本就是一个有序数组，那么平方一定是两侧的最大，你可以反复比较左右的元素的平方，然后你再加到你的结果数组中去就行

代码实现：

public class Solution {
    public int[] SortedSquares(int[] nums) {
                    int[] result = new int[nums.Length];
            int k =nums.Length-1;
            for (int i = 0, j = nums.Length - 1; i <= j;)
            {
                if (nums[i] * nums[i] > nums[j] * nums[j])
                {
                    result[k] = nums[i] *nums[i];
                    i++;
                    k--;
                }
                else
                {
                    result[k] = nums[j] *nums[j];
                    j--;
                    k--;
                }
            }
            return result;
    }
}

844、比较含空格的字符串

思路：注意其中一个指针的移动位置就好。

代码实现：

    public class Solution
    {
        public bool BackspaceCompare(string s, string t)
        {
            int kongge_1 = 0;
            int kongge_2 = 0;
            char[] schars = s.ToCharArray();
            char[] tchars = t.ToCharArray();
            foreach (char c in schars)
            {
                if (c != '#')
                {
                    schars[kongge_1] = c;
                    kongge_1++;
                }
                else
                {
                    if(kongge_1 > 0)
                        kongge_1--;
                }
            }
            foreach(char c in tchars)
            {
                if (c != '#')
                {
                    tchars[kongge_2] = c;
                    kongge_2++;
                }
                else
                {
                    if (kongge_2 > 0)
                        kongge_2--;
                }
            }
            if(kongge_1-kongge_2!=0)
                return false;
            for (int i = 0; i < kongge_2; i++)
            {
                if (schars[i] != tchars[i]) return false;
            }
            return true;
        }
    }

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

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

相关文章

React（二）：JSX语法解析+综合案例

React（二）：JSX语法解析+综合案例

事件绑定 this绑定方式 问题&#xff1a;在事件执行后&#xff0c;需获取当前类的对象中相关属性&#xff0c;此时需要this——当打印时&#xff0c;发现this为undefined,这又是为啥&#xff1f; 假设有一个btnClick函数&#xff0c;但它并不是我们主动调用的&#xff0c;而是…
阅读更多...
Gitee重新远程连接仓库（Linux）

Gitee重新远程连接仓库（Linux）

Gitee重新远程连接仓库&#xff08;Linux&#xff09; 因为虚拟机重新安装了一回&#xff0c;所以需要重新和远程仓库连接&#xff0c;在网上找了很久没有找到相关操作&#xff0c;自己实操成功&#xff0c;记录下本博客&#xff0c;帮助有需要的人 确保新虚拟机安装Git 在新虚…
阅读更多...
Vitis HLS中的Array Partition与Array Reshape详解

Vitis HLS中的Array Partition与Array Reshape详解

Vitis HLS中的Array Partition与Array Reshape详解 引言 在高层次综合(HLS)设计中&#xff0c;数组是最常用的数据结构之一&#xff0c;但默认情况下&#xff0c;HLS会将数组映射到单个BRAM块&#xff0c;这会限制并行访问能力&#xff0c;成为性能瓶颈。为了克服这一限制&am…
阅读更多...
Centos离线安装openssl

Centos离线安装openssl

文章目录 Centos离线安装openssl1. openssl是什么&#xff1f;2. openssl下载地址3. openssl-devel安装4. 安装结果验证5. 版本查看 Centos离线安装openssl 1. openssl是什么&#xff1f; OpenSSL 是一个开源的、跨平台的 加密工具库 和 命令行工具集&#xff0c;广泛用于实现…
阅读更多...
protobuf安装

protobuf安装

安装 github官方链接 https://github.com/protocolbuffers/protobuf/ 以protobuf21为例 https://github.com/protocolbuffers/protobuf/releases/download/v21.11/protobuf-all-21.11.zip windows 解压好文件夹后,使用cmake,vs,qt creator等工具打开该项目,进行编译,编译需…
阅读更多...
《基于超高频RFID的图书馆管理系统的设计与实现》开题报告

《基于超高频RFID的图书馆管理系统的设计与实现》开题报告

一、研究背景与意义 1.研究背景 随着信息化时代的到来&#xff0c;运用计算机科学技术实现图书馆的管理工作已成为优势。更加科学地管理图书馆会大大提高工作效率。我国的图书管理体系发展经历了三个阶段&#xff1a;传统图书管理模式、现代图书管理模式以及基于无线射频识别&…
阅读更多...
小程序渲染之谜：如何解决“加载中...”不消失的 Bug（glass-easel）

小程序渲染之谜：如何解决“加载中...”不消失的 Bug（glass-easel）

&#x1f389; 小程序渲染之谜&#xff1a;如何解决“加载中…”不消失的 Bug &#x1f389; 引言 在小程序开发中&#xff0c;渲染问题总能让人抓狂。&#x1f62b; 这次&#xff0c;我遇到了一个奇怪的 bug&#xff1a;产品详情页的内容已经正常显示&#xff0c;但页面却一…
阅读更多...
网络原理之HTTPS（如果想知道网络原理中有关HTTPS的知识，那么只看这一篇就足够了！）

网络原理之HTTPS（如果想知道网络原理中有关HTTPS的知识，那么只看这一篇就足够了！）

前言&#xff1a;随着互联网安全问题日益严重&#xff0c;HTTPS已成为保障数据传输安全的标准协议&#xff0c;通过加密技术和身份验证&#xff0c;HTTPS有效防止数据窃取、篡改和中间人攻击&#xff0c;确保通信双方的安全和信任。 ✨✨✨这里是秋刀鱼不做梦的BLOG ✨✨✨想要…
阅读更多...
五子棋小游戏-简单开发版

五子棋小游戏-简单开发版

一、需求分析 开发一个基于 Pygame 库的五子棋小游戏&#xff0c;允许两名玩家在棋盘上轮流落子&#xff0c;当有一方达成五子连珠时游戏结束&#xff0c;显示获胜信息&#xff0c;并提供退出游戏和重新开始游戏的操作选项。 1.棋盘显示 &#xff1a; 显示一个 15x15 的五子棋…
阅读更多...
2025中国科技大学少年班/创新试点班·初试备考测试卷（数学）

2025中国科技大学少年班/创新试点班·初试备考测试卷（数学）

本卷考查内容&#xff1a;高中课程内容及拓展。 本卷考查形式&#xff1a;书面作答&#xff08;客观题18小题解答题4题&#xff09;。 卷首语&#xff1a;中科大少年班、创新班每年大规模招录在数理成绩优异的中学学生。其中初试数学题在高考基础上略有拓展&#xff0c;难度又低…
阅读更多...
即时通讯平台测试报告

即时通讯平台测试报告

1.项目概述 项目名称&#xff1a;即时通讯平台 版本号&#xff1a;V1.0.0 测试周期&#xff1a;2025年2月25日--2025年3月15日 测试目标&#xff1a;验证核心功能&#xff08;登录、注册、消息收发、用户管理、群组功能等&#xff09;的稳定性和性能指标。 2. 测试范围 功…
阅读更多...
如何记录Matlab程序运行过程中所占用的最大内存

如何记录Matlab程序运行过程中所占用的最大内存

有些时候&#xff0c;我们需要分析Matlab程序运行过程中所占用的最大内存。如果只是得到程序运行到当前位置所占用的内存&#xff0c;可以简单在程序当前位置插入memory命令即可&#xff1a; user memory; MemUsed_now user.MemUsedMATLAB; 但如果我们想要的是整个程序在运行…
阅读更多...
WIN11开发环境变量记录

WIN11开发环境变量记录

这里写自定义目录标题 总图JAVA环境变量配置GIT环境变量配置NODEJS环境变量配置 总图 JAVA环境变量配置 新建系统变量。变量名&#xff1a;JAVA_HOME&#xff0c;变量值&#xff08;可以选择浏览目录&#xff0c;JAVA的根目录&#xff0c;本处为D:\Java\jdk1.8.0_251&#xff…
阅读更多...
易语言模拟真人鼠标轨迹算法

易语言模拟真人鼠标轨迹算法

一.简介 鼠标轨迹算法是一种模拟人类鼠标操作的程序&#xff0c;它能够模拟出自然而真实的鼠标移动路径。 鼠标轨迹算法的底层实现采用C/C语言&#xff0c;原因在于C/C提供了高性能的执行能力和直接访问操作系统底层资源的能力。 鼠标轨迹算法具有以下优势&#xff1a; 模拟…
阅读更多...
洛谷P9950 [USACO20FEB] Mad Scientist B

洛谷P9950 [USACO20FEB] Mad Scientist B

P9950 [USACO20FEB] Mad Scientist B - 洛谷 代码区&#xff1a; #include <iostream> #include <string>using namespace std; int main() {int n;cin>> n;string a;string b;cin >> a >> b;int flag,step0,i,t;for ( i 0; i < a.length(…
阅读更多...
prometheus自定义监控(pushgateway和blackbox)和远端存储VictoriaMetrics

prometheus自定义监控(pushgateway和blackbox)和远端存储VictoriaMetrics

1 pushgateway采集 1.1 自定义采集键值 如果自定义采集需求时&#xff0c;就可以通过写脚本 定时任务定期发送数据到 pushgateway 达到自定义监控 1.部署 pushgateway&#xff0c;以 10.0.0.42 节点为例 1.下载组件 wget https://github.com/prometheus/pushgateway/relea…
阅读更多...
C++相关基础概念之入门讲解（上）

C++相关基础概念之入门讲解（上）

1. 命名空间 C中的命名空间&#xff08;namespace&#xff09;是用来避免命名冲突问题的一种机制。通过将类、函数、变量等封装在命名空间中&#xff0c;可以避免不同部分的代码中出现相同名称的冲突。在C中&#xff0c;可以使用namespace关键字来定义命名空间。 然后我们在调…
阅读更多...
【大模型】Transformer、GPT1、GPT2、GPT3、BERT 的论文解析

【大模型】Transformer、GPT1、GPT2、GPT3、BERT 的论文解析

前言 在自然语言处理&#xff08;NLP&#xff09;和深度学习的快速发展中&#xff0c;Transformer模型和 GPT系列模型扮演了至关重要的角色。本篇博客旨在对这些开创性的论文进行介绍&#xff0c;涵盖它们的提出时间、网络结构等关键信息&#xff0c;能够快速的理解这些模型的设…
阅读更多...
【Java 优选算法】分治-归并排序

【Java 优选算法】分治-归并排序

欢迎关注个人主页&#xff1a;逸狼 创造不易&#xff0c;可以点点赞吗~ 如有错误&#xff0c;欢迎指出~ 数组分块如二叉树的前序遍历, 而归并排序就如二叉树的后序遍历 912. 排序数组 解法 使用归并算法 根据中间点划分区间, mid (right left ) / 2将左右区间排序合并两个有…
阅读更多...
三格电子Modbus TCP转CANOpen网关相关问答

三格电子Modbus TCP转CANOpen网关相关问答

型号&#xff1a;SG-TCP-COE-210 Q1: Modbus TCP转CANOpen网关的主要功能是什么&#xff1f; A1: 该网关的核心功能是实现 Modbus TCP协议与CANOpen协议之间的双向数据转换&#xff0c;使支持Modbus TCP的工业设备&#xff08;如PLC、HMI&#xff09;能够与基于CANOpen协议的设…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023