2024秋招算法

文章目录

  • 参考资料
  • 一 数组
    • 1.1 二分查找
    • 1.2 移除元素
    • 1.3 长度最小的子数组
    • 1.4 螺旋矩阵
    • 1.5 在排序数组中查找元素的第一个和最后一个位置
  • 二 链表
    • 2.1 移除链表元素
    • 2.2 设计链表
    • 2.3 反转链表
    • 2.4 两两交换链表中的节点
    • 2.5 删除链表的倒数第N个节点
    • 2.6 链表相交
    • 2.7 环形链表II
  • 三 哈希表
    • 3.1 有效的字母异位词
    • 3.2 两个数组的交集

参考资料

代码随想录 https://programmercarl.com/
LeetCode https://leetcode.cn/

一 数组

1.1 二分查找

  • 前提
    有序数组，元素唯一（有重复元素，使用二分查找法返回的元素下标可能不是唯一）
  • 思想
    • 定义 target 是在一个在左闭右闭的区间里，也就是[left, right]
    • while (left <= right) 要使用 <= ，因为left == right是有意义的，所以使用 <=
    • if (nums[middle] > target) right 要赋值为 middle - 1，因为当前这个nums[middle]一定不是target，那么接下来要查找的左区间结束下标位置就是 middle - 1
    • 若要通过二分查找确定插入位置，则最后需判断nums[mid] > target，若是则mid为结果，若不是则mid + 1为结果
  • 代码
    // https://leetcode.cn/problems/binary-search/description/
class Solution {public:int search(vector<int>& nums, int target) {int left = 0, right = nums.size() - 1;while (left <= right) {int mid = left + (right - left)/2;if (nums[mid] == target) {return mid;} if (nums[mid] < target) {left = mid + 1;}if (nums[mid] > target) {right = mid - 1;}}return -1;}
};

1.2 移除元素

  • 前提
    O(1)空间，不要求保留原顺序
  • 思想
    将要删除的元素用数组最后面的元素进行替换
  • 代码
    // https://leetcode.cn/problems/remove-element/description/
class Solution {public:int removeElement(vector<int>& nums, int val) {int left = 0, right = nums.size() - 1;while (left <= right) {if (nums[left] == val) {nums[left] = nums[right];right --;} else {left ++;}}// [0, right]为需要保留的元素，长度位right + 1return right + 1;}
};

1.3 长度最小的子数组

  • 前提
    O(1)空间，子数组连续
  • 思想
    定义区间[left, right)，当区间和sum < target时移动right，相反则记录当前区间长度right - left并移动left，直到right > 数组总长度时结束循环
  • 代码
    // https://leetcode.cn/problems/minimum-size-subarray-sum/description/
class Solution {public:int minSubArrayLen(int target, vector<int>& nums) {int left = 0, right = 0; // [left, right)int sum = 0, ans = 0;while (right <= nums.size()) {if (sum < target) {// 此时right指针已达到末尾，且子数组和小于target// 结束循环if (right ==  nums.size()) {break;}sum += nums[right];right ++;} else {int len = right - left;if (ans == 0) {ans = len;} else {ans = ans > len ? len : ans;}sum -= nums[left];left ++;}}return ans;}
};

1.4 螺旋矩阵

  • 思想
    关键在于方向的转换，并且需要记录行和列上还有多少是没有遍历过的，每次方向转换都需要减少一个待遍历的行或列
  • 代码
    // https://leetcode.cn/problems/spiral-matrix-ii/description/
class Solution {
public:vector<vector<int>> generateMatrix(int n) {// direction = 0 => 从左到右，direction = 1 => 从上到下// direction = 2 => 从右到左，direction = 3 => 从下到上int direction = 0;int row_count = n, col_count = n;int i_index = 0, j_index = 0; int num = 1;// 初始化结果vector<vector<int>> res;for (int i = 0; i < n; i ++) {vector<int> r(n);res.push_back(r);}while (num <= n * n) {// printf("direction = %d\n", direction);switch(direction) {case 0:// printf("case0, i = %d, j = %d\n", i_index, j_index);for (int i = 0; i < col_count; i ++) {res[i_index][j_index] = num;j_index ++;num ++;}i_index ++;j_index --;row_count --;break;case 1:// printf("case1, i = %d, j = %d\n", i_index, j_index);for (int i = 0; i < row_count; i ++) {res[i_index][j_index] = num;i_index ++;num ++;}i_index --;j_index --;col_count --;break;case 2:// printf("case2, i = %d, j = %d\n", i_index, j_index);for (int i = 0; i < col_count; i ++) {res[i_index][j_index] = num;j_index --;num ++;}j_index ++;i_index --;row_count --;break;case 3:// printf("case3, i = %d, j = %d\n", i_index, j_index);for (int i = 0; i < row_count; i ++) {res[i_index][j_index] = num;i_index --;num ++;}i_index ++;j_index ++;col_count --;break;}direction ++;direction = direction % 4;// for (int i = 0; i < n; i ++) {//     for (int j = 0; j < n; j ++) {//         cout << res[i][j];//     }//     cout << endl;// }}return res;}
};

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

  • 代码
    // https://leetcode.cn/problems/find-first-and-last-position-of-element-in-sorted-array/
class Solution {
public:vector<int> searchRange(vector<int>& nums, int target) {vector<int> ret(2, -1);// 有效区间[left, right]int left = 0, right = nums.size() - 1, mid;bool tag = false;while (left <= right) {mid = left + (right - left)/2;if (nums[mid] == target) {tag = true;break;} else if (nums[mid] < target) {left = mid + 1;} else {right = mid - 1;}}if (!tag) return ret;// cout << left << " " <<  mid << " " << right  << endl;// [left, mid - 1] 中寻找小于target的元素int l = left, r = mid - 1, from = left;while (l <= r) {int m = l + (r - l)/2;if (nums[m] < target) {from = m;break;} else {r = m - 1;}}// 向右找到第一个等于target的元素while (nums[from] != target) from ++;// [mid + 1, right] 中寻找大于target的元素l = mid + 1;r = right;int to = right;while (l <= r) {int m = l + (r - l)/2;if (nums[m] > target) {to = m;break;} else {l = m + 1;}}// 向左找到第一个等于target的元素while (nums[to] != target) to --;ret[0] = from;ret[1] = to;return ret;}
};

二 链表

2.1 移除链表元素

  • 思想
    移除链表中指定元素的关键在于找到被移除元素的上一个节点
  • 代码
    // https://leetcode.cn/problems/remove-element/description/
class Solution {
public:ListNode* removeElements(ListNode* head, int val) {// 定义虚拟头节点，不需要对第一个节点进行特殊判断ListNode *dummy_head = new ListNode(-1, head);// 定义pre和cur，方便删除元素ListNode *pre = dummy_head;ListNode *cur = dummy_head->next;while (cur != NULL) {if (cur->val == val) {pre->next = cur->next;cur = pre->next;} else {pre = pre->next;cur = cur->next;}}return dummy_head->next;}
};

2.2 设计链表

  • 思想
    • 设计虚拟头节点可以简化对于第一个节点的操作
    • 由题可知，大部分操作都需要找到下标的为index的节点的上一个节点，因此设计了getPre(int index)函数
    • 设计尾节点可以降低addAtTail的时间复杂度，但是在链表变化时需要对其进行维护
  • 代码
    // https://leetcode.cn/problems/design-linked-list/
class MyListNode {    
public:int val;MyListNode *next;MyListNode(int val, MyListNode *next) {this->val = val;this->next = next;}
};class MyLinkedList {
private:MyListNode *dummy_head;MyListNode *tail;int size;// 找到下标为index的上一个节点MyListNode *getPre(int index) {MyListNode *node = dummy_head;while (index > 0) {node = node->next;index --;}return node;}
public:MyLinkedList() {dummy_head = new MyListNode(-1, NULL);tail = NULL;size = 0;}int get(int index) {if (index >= size) {return -1;}MyListNode *node = getPre(index);return node->next->val;}void addAtHead(int val) {MyListNode *node = new MyListNode(val, NULL);node->next = dummy_head->next;dummy_head->next = node;if (tail == NULL) {tail = node;}size ++;}void addAtTail(int val) {if (tail == NULL) {addAtHead(val);   } else {tail->next = new MyListNode(val, NULL);tail = tail->next;size ++;}}void addAtIndex(int index, int val) {// 如果 index 比长度更大，该节点将 不会插入 到链表中if (index > size) {return ;}// 如果 index 等于链表的长度，那么该节点会被追加到链表的末尾if (index == size) {addAtTail(val);} else {MyListNode *node = new MyListNode(val, NULL);MyListNode *p = getPre(index);node->next = p->next;p->next = node;size ++;}}void deleteAtIndex(int index) {if (index >= size) {return ;}MyListNode *p = getPre(index);// 要删除的节点为尾节点，需要修改tailif (p->next == tail) {p->next = NULL;tail = p;} else {p->next = p->next->next;                }size --;}
};

2.3 反转链表

  • 思想
    • 为原链表添加虚拟头节点，删除节点时不需要维护头节点，简化操作（新链表的虚拟头节点同理）
    • 反转链表主要分为节点断开和节点接入，分为两部分实现，可避免思路不清晰，导致链表成环（q->next = NULL可删除）
  • 代码
    // https://leetcode.cn/problems/reverse-linked-list/
class Solution {
public:ListNode* reverseList(ListNode* head) {// 为原链表添加虚拟头节点，方便节点的删除ListNode *dummy_head = new ListNode(-1, head);ListNode *p = dummy_head;// 为新链表添加虚拟头节点ListNode *new_head = new ListNode(-1);while (p->next != NULL) {// 把节点从原链表断开ListNode *q = p->next;p->next = q->next;q->next = NULL;// 把节点接入到新链表的头部q->next = new_head->next;new_head->next = q;}return new_head->next;}
};

2.4 两两交换链表中的节点

  • 思想
    • 多定义变量可一定程度上简化操作（变量不用🪙）
  • 代码
    // https://leetcode.cn/problems/swap-nodes-in-pairs/description/
class Solution {
public:ListNode* swapPairs(ListNode* head) {ListNode *dummy_head = new ListNode(-1, head);ListNode *p = dummy_head;while (p->next != NULL && p->next->next != NULL) {// a和b为要进行交换的节点，c为后面的节点ListNode *a = p->next;ListNode *b = a->next;ListNode *c = b->next;// 将a和b从原链表中断开（为了方便理解，可省略）p->next = NULL;a->next = NULL;b->next = NULL;// 重新拼接p->next = b;b->next = a;a->next = c;p = a;}   return dummy_head->next;}
};

2.5 删除链表的倒数第N个节点

  • 思想
    先让fast跑n步，然后slow和fast再一起跑，fast到达末尾时，slow刚好为倒数第n+1个节点
  • 代码
    // https://leetcode.cn/problems/remove-nth-node-from-end-of-list/description/
class Solution {
public:ListNode* removeNthFromEnd(ListNode* head, int n) {ListNode *dummy_head = new ListNode(-1, head);ListNode *fast = dummy_head;ListNode *slow = dummy_head;while (n > 0) {fast = fast->next;n --;}while (fast->next != NULL) {fast = fast->next;slow = slow->next;}slow->next = slow->next->next;return dummy_head->next;   }
};

2.6 链表相交

  • 代码
    // https://leetcode.cn/problems/intersection-of-two-linked-lists-lcci/
class Solution {
public:ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {// 计算链表A和B的节点数int a_count = 0;int b_count = 0;ListNode *p = headA;while (p != NULL) {a_count ++;p = p->next;}p = headB;while (p != NULL) {b_count ++;p = p->next;}// 若两个链表相差sub个节点，则让长的链表先跑sub步while (a_count > b_count) {headA  = headA->next;a_count --;}while (b_count > a_count) {headB = headB->next;b_count --;}// 两个链表同时往前，此时遇到的第一个相同节点即为结果while (headA != headB) {headA = headA->next;headB = headB->next;}return headA;}
};

2.7 环形链表II

  • 思想
    • 通过快慢指针法确定链表是否存在环，并找到环中的任意一个节点
    • 遍历环，直至将环中的所有节点添加到set集合中
    • 从head开始遍历，当节点存在与set集合中时，即为环的入口节点
  • 代码
    // https://leetcode.cn/problems/linked-list-cycle-ii/
class Solution {
public:ListNode *detectCycle(ListNode *head) {// 通过快慢指针法确定链表是否存在环，并找到环中的任意一个节点ListNode *fast = head;ListNode *slow = head;bool tag = false;while (fast != NULL && fast->next != NULL) {fast = fast->next->next;slow = slow->next;if (fast == slow) {tag = true;break;}}if (tag) {// 此时fast和slow都是环中的节点，遍历环，直至将环中的所有节点添加到`set`集合中set<ListNode*> st;while (st.find(fast) == st.end()) {st.insert(fast);fast = fast->next;}// 从`head`开始遍历，当节点存在与`set`集合中时，即为环的入口节点while (st.find(head) == st.end()) {head = head->next;}return head;} else {return NULL;}}
};
  • 最优解法
    // https://leetcode.cn/problems/linked-list-cycle-ii/solutions/12616/linked-list-cycle-ii-kuai-man-zhi-zhen-shuang-zhi-/
class Solution {
public:ListNode *detectCycle(ListNode *head) {ListNode *fast = head;ListNode *slow = head;bool tag = false;while (fast != NULL && fast->next != NULL) {fast = fast->next->next;slow = slow->next;if (fast == slow) {tag = true;break;}}if (!tag) return NULL;fast = head;while (fast != slow) {fast = fast->next;slow = slow->next;}return fast;}
};

三 哈希表

3.1 有效的字母异位词

  • 思想
    • 两个字符串长度不同，直接返回false
    • 遍历字符串s，使用map统计第一个字符串s中每各字符出现的次数
    • 遍历字符串t，若字符不存在于map中，则返回false；存在则进行减操作，当字符次数减为0时，从map移除
    • map为空则表示两个字符串是字母异位词
    • （进阶）由于题目中说明字符串都由小写字母组成，那么我们可以将所有字符映射到长度为26的数组，简化操作
  • 代码（基础解法）
    // https://leetcode.cn/problems/valid-anagram/description/
class Solution {
public:bool isAnagram(string s, string t) {if (s.length() != t.length()) {return false;}map<char, int> mp;for (int i = 0; i < s.length(); i ++) {char key = s[i];auto it = mp.find(key);if (it != mp.end()) {it->second += 1;} else {mp.insert(pair<char, int>(key, 1));}}for (int i = 0; i < t.length(); i ++) {char key = t[i];auto it = mp.find(key);if (it == mp.end()) {return false;} else {if (it->second == 0) {return false;} else if (it->second == 1) {mp.erase(it);} else {it->second -= 1;}}}return mp.empty();}
};
  • 最优解法
    // https://leetcode.cn/problems/valid-anagram/description/
class Solution {
public:bool isAnagram(string s, string t) {if (s.length() != t.length()) {return false;}vector<int> mp(26, 0);for (char c : s) {mp[c - 'a'] ++;}for (char c : t) {mp[c - 'a'] --;}for (int c : mp) {if (c != 0) return false;}return true;}
};

3.2 两个数组的交集

  • 代码
    // https://leetcode.cn/problems/intersection-of-two-arrays/
class Solution {
public:vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {vector<int> ret;set<int> st;// 将nums1的所有元素添加到set中，会自动去重for (int num : nums1) {st.insert(num);}// 遍历nums2，判断元素是否存在st中，存在则是两个数组的交集，添加到结果数组ret中// 为防止元素重复添加，需要将其从st中移除for (int num : nums2) {if (st.find(num) != st.end()) {ret.push_back(num);st.erase(num);}}return ret;}
};

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

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

相关文章

HIVE：使用get_json_object解析json对象

HIVE：使用get_json_object解析json对象

1 json对象 JSON 对象使用在大括号 {…} 中书写。对象可以包含多个 key/value&#xff08;键/值&#xff09;对。key 必须是字符串&#xff0c;value 可以是合法的 JSON 数据类型&#xff08;字符串, 数字, 对象, 数组, 布尔值或 null&#xff09;。key 和 value 中使用冒号 :…
阅读更多...
力扣爆刷第167天之TOP200五连刷101-105（二叉树序列化、验证IP、LFU）

力扣爆刷第167天之TOP200五连刷101-105（二叉树序列化、验证IP、LFU）

力扣爆刷第167天之TOP200五连刷101-105&#xff08;二叉树序列化、验证IP、LFU&#xff09; 文章目录 力扣爆刷第167天之TOP200五连刷101-105&#xff08;二叉树序列化、验证IP、LFU&#xff09;一、224. 基本计算器二、297. 二叉树的序列化与反序列化三、283. 移动零四、468. …
阅读更多...
【每日一练】python的类型注解和Union类型使用方法

【每日一练】python的类型注解和Union类型使用方法

""" 本节课程内容 函数&#xff08;方法&#xff09;的类型注解 Union类型 1.为函数&#xff08;方法&#xff09;的形参进行类型的注解 2.为函数&#xff08;方法&#xff09;的返回值进行类型的注解 注意&#xff1a;类型注解并非强制性&#xff0c;是提示…
阅读更多...
React 学习——行内样式、外部样式、动态样式

React 学习——行内样式、外部样式、动态样式

三种样式的写法 import "./index.css"; //同级目录下的样式文件 function App() {const styleCol {color: green,fontSize: 40px}// 动态样式const isBlock false;return (<div className"App">{/* 行内样式 */}<span style{{color:red,fontSiz…
阅读更多...
Vue修饰符的使用

Vue修饰符的使用

在 Vue.js 中&#xff0c;修饰符&#xff08;modifiers&#xff09;是一种特殊的后缀&#xff0c;用于指令以特殊方式修改指令的行为。修饰符通过在指令名称后面添加点&#xff08;.&#xff09;及修饰符名称来表示。Vue 提供了一些常用的修饰符&#xff0c;帮助开发者处理事件…
阅读更多...
工程视角：数据结构驱动的应用开发--字典（dictionary），列表（list）与实体

工程视角：数据结构驱动的应用开发--字典（dictionary），列表（list）与实体

这里写目录标题 业务业务场景流程分析 实现数据访问层&#xff08;DAL&#xff09;业务逻辑层&#xff08;BLL&#xff09;用户界面层&#xff08;UI&#xff09;工具类 设计思路为什么抽出工具类关于U层使用字典的好处工程视角 业务 业务场景 在一个金融应用系统中&#xff0c…
阅读更多...
iptables 限制端口仅特定IP访问。

iptables 限制端口仅特定IP访问。

注意&#xff1a; 需要用源地址(-s)&#xff0c;而不是目的地址(-d) 单个IP&#xff1a; iptables -A INPUT -p tcp -m tcp --dport 3306 -s 127.0.0.1 -j ACCEPT iptables -A INPUT -p tcp -m tcp --dport 3306 -j DROP 多个IP&#xff1a; iptables -A INPUT -p tcp -m t…
阅读更多...
LLaVA论文阅读+Colab部署

LLaVA论文阅读+Colab部署

LLaVA &#xff1a;Visual Instruction Tuning 1. Colab上部署LLaVA2. 论文摘要3. 多模态指令跟随数据4. 模型架构5. 模型训练6. 消融实验7. CC3M数据过滤8. 总结 1. Colab上部署LLaVA 代码&#xff1a; https://github.com/Czi24/Awesome-MLLM-LLM-Colab/tree/master/MLLM/LL…
阅读更多...
CUDA编程02 - 数据并行介绍

CUDA编程02 - 数据并行介绍

一：概述 数据并行是指在数据集的不同部分上执行计算工作，这些计算工作彼此相互独立且可以并行执行。许多应用程序都具有丰富的数据并行性，使其能够改造成可并行执行的程序。因此，对于程序员来说，熟悉数据并行的概念以及使用并行编程语言来编写数据并行的代码是非常重要的。…
阅读更多...
2024.7.23总结（东莞入职培训day2)

2024.7.23总结（东莞入职培训day2)

今天写总结也很晚了&#xff0c;但是今天收获特别丰满&#xff0c;必须回顾一下&#xff0c;这些都是宝贵的财富。 1.讲课老师很特别棒 今天的讲课老师特别棒&#xff0c;很是优秀&#xff0c;她讲的课程质量还是非常高的&#xff0c;能够带动学生去深度思考&#xff0c;小伙…
阅读更多...
超大数字四舍五入保留N位小数【没bug】

超大数字四舍五入保留N位小数【没bug】

大部分npm常用的插件四舍五入都是用数值直接去计算四舍五入的存在精度问题&#xff0c;本方法是用用字符串拆分比较整数大小&#xff0c;这样就避开了精度的问题&#xff1b; 该方法可以传入&#xff1a;1.134、99.99、9999999999999999999.99999、.001、12.、0.、00.、类似的…
阅读更多...
.netcore TSC打印机打印

.netcore TSC打印机打印

此文章给出两种打印案例&#xff0c; 第一种是单列打印&#xff0c;第二种是双列打印 需要注意打印机名称的设置&#xff0c;程序中使用的打印机名称为999&#xff0c;电脑中安装打印机时名称也要为999。 以下是我在使用过程中总结的一些问题&#xff1a; 一 TSC打印机使用使…
阅读更多...
【Node.js基础02】fs、path模块

【Node.js基础02】fs、path模块

目录 一&#xff1a;fs模块-读写文件 1 加载fs模块对象 2 读制定文件内容文件 3 向文件中写入内容 二&#xff1a;path模块-路径处理 1 问题引入 2 __dirname内置变量 使用方法 一&#xff1a;fs模块-读写文件 fs模块封装了与本机文件系统交互方法和属性 1 加载fs模块…
阅读更多...
弹性布局 flex layout HTML CSS

弹性布局 flex layout HTML CSS

文章目录 效果图参考文档代码 效果图 其实弹性布局的好处是&#xff1a;当网页大小变化&#xff08;如窗口resize&#xff09;时&#xff0c;处于弹性容器(flex container)中的弹性元素(flex item) 之间的距离也会变化。 需要特别注意的是&#xff1a; 弹性布局的主要CSS如下。…
阅读更多...
生成式AI未来趋势预测

生成式AI未来趋势预测

随着生成式AI技术的不断进步&#xff0c;关于其未来发展方向的讨论也愈发激烈。生成式AI的未来可能会在对话系统&#xff08;Chat&#xff09;中展现智慧&#xff0c;也可能在自主代理&#xff08;Agent&#xff09;中体现能力。以下是具体分析&#xff1a; 1. **技术成熟度**&…
阅读更多...
开源邮箱套件介绍系列2：Roundcube webmail

开源邮箱套件介绍系列2：Roundcube webmail

1. 项目介绍 项目网站&#xff1a;Roundcube – Free and Open Source Webmail Software Roundcube 项目是一个免费的开源网络邮件解决方案&#xff0c;具有类似桌面的用户界面&#xff08;Webmail&#xff09;&#xff0c;易于安装/配置&#xff0c;并且可以在标准的LAMPP服…
阅读更多...
网络安全新视角：2024年威胁 landscape与防护策略

网络安全新视角：2024年威胁 landscape与防护策略

网络安全新视角&#xff1a;2024年威胁 landscape与防护策略 2024年网络安全威胁趋势分析 云集中风险 随着云计算的普及&#xff0c;云服务商集中化趋势明显&#xff0c;企业越来越依赖于少数几家云服务商&#xff0c;导致云集中风险逐渐显现。例如&#xff0c;阿里云在2023…
阅读更多...
PostgreSQL 中如何处理数据的唯一性约束？

PostgreSQL 中如何处理数据的唯一性约束？

&#x1f345;关注博主&#x1f397;️ 带你畅游技术世界&#xff0c;不错过每一次成长机会&#xff01;&#x1f4da;领书&#xff1a;PostgreSQL 入门到精通.pdf 文章目录 PostgreSQL 中如何处理数据的唯一性约束&#xff1f;一、什么是唯一性约束二、为什么要设置唯一性约束…
阅读更多...
SAP第二季度财报和进一步裁员计划

SAP第二季度财报和进一步裁员计划

7月22日公布了截至 2024 年 6 月 30 日的第二季度财务报告。以下位总体指标 当前云计算在手订单达 148 亿欧元&#xff0c;按名义货币和固定汇率计算均增长 28%云收入增长 25%&#xff0c;其中云 ERP 套件收入增长 33%&#xff0c;均按名义货币和固定汇率计算总收入增长 10%&a…
阅读更多...
mysql 先子查询过滤再联合 和 先联合再过滤 执行效率问题

mysql 先子查询过滤再联合 和 先联合再过滤 执行效率问题

执行顺序 先子查询过滤再联合 SELECT XXX FROM(select * from edw_data_dyd.overrun_offsite_info WHERELENGTH( VEHICLE_ID ) > 12 AND CREATED_TIME > DATE_ADD(NOW(),INTERVAL -1 HOUR)AND CREATED_TIME < NOW()AND VEHICLE_ID not like %无车牌%AND VEHICLE_I…
阅读更多...
最新文章

Copyright @ 2022~2023