【leecode】5-双指针法

已于 2022-12-06 21:54:50 修改
阅读量210 收藏
点赞数
分类专栏： 春招 文章标签： leetcode
于 2022-12-04 11:56:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chongdada/article/details/128170242
版权

5-双指针法


刷题参考：《代码随想录》

1-移除元素

链接: 27

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并原地修改输入数组。 元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
示例 1: 给定 nums = [3,2,2,3], val = 3, 函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。
示例 2: 给定 nums = [0,1,2,2,3,0,4,2], val = 2, 函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。

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

解法一：相向双指针

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int left = 0, right = nums.size() - 1; 
        while(left <= right)
        {
            if(nums[left] != val)
            {
                left++;
            }
            else
            {
                nums[left] = nums[right];
                right--;
            }
        }
        return left;
    } 
};

解法二：快慢指针

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int slowIndex = 0;
        for (int fastIndex = 0; fastIndex < nums.size(); fastIndex++) {
            if (val != nums[fastIndex]) {
                nums[slowIndex++] = nums[fastIndex];
            }
        }
        return slowIndex;
    }
};

2-反转字符串

链接: 344

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。
不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。
示例 1： 输入：[“h”,“e”,“l”,“l”,“o”] 输出：[“o”,“l”,“l”,“e”,“h”]

  • 时间复杂度：O(n)，其中 n 为字符数组的长度。一共执行了 n/2 次的交换。
  • 空间复杂度：O(1)。只使用了常数空间来存放若干变量。
class Solution {
public:
    void reverseString(vector<char>& s) {
        int left  = 0;
        int right = s.size() - 1; 
        while(left <= right)
        {
        	//swap(s[i],s[j]);
            char tmp = s[left];
            s[left]  = s[right];
            s[right] = tmp;
            left++;
            right--;
        }
        return;
    }
};

3-替换空格

链接: 剑指Offer 05

请实现一个函数，把字符串 s 中的每个空格替换成"%20"。
示例 1： 输入：s = “We are happy.”，输出：“We%20are%20happy.”
从前向后填充就是O(n^2)的算法了，因为每次添加元素都要将添加元素之后的所有元素向后移动。

其实很多数组填充类的问题，都可以先预先给数组扩容带填充后的大小，然后在从后向前进行操作。这么做有两个好处：

  1. 不用申请新数组。
  2. 从后向前填充元素，避免了从前向后填充元素时，每次添加元素都要将添加元素之后的所有元素向后移动的问题。
  • 时间复杂度：O(n) ，遍历统计、遍历修改皆使用O(n) 时间。
  • 空间复杂度：O(1)，由于是原地扩展 s 长度，因此使用 O(1) 额外空间。
class Solution {
public:
    string replaceSpace(string s) {
        int count = 0; // 统计空格的个数
        int sOldSize = s.size();
        for (int i = 0; i < s.size(); i++) {
            if (s[i] == ' ') {
                count++;
            }
        }
        // 扩充字符串s的大小，也就是每个空格替换成"%20"之后的大小
        s.resize(s.size() + count * 2);
        int sNewSize = s.size();
        // 从后先前将空格替换为"%20"
        for (int i = sNewSize - 1, j = sOldSize - 1; j < i; i--, j--) {
            if (s[j] != ' ') {
                s[i] = s[j];
            } else {
                s[i] = '0';
                s[i - 1] = '2';
                s[i - 2] = '%';
                i -= 2;
            }
        }
        return s;
    }
};

4-翻转字符串里的单词

链接: 151

给定一个字符串，逐个翻转字符串中的每个单词。
示例 1： 输入: “the sky is blue” 输出: “blue is sky the”
示例 2： 输入: " hello world! " 输出: “world! hello”
解释:输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。 示例 3： 输入: “a good example” 输出: “example good a”
解释: 如果两个单词间有多余的空格，将反转后单词间的空格减少到只含一个。

  • 时间复杂度：O(n)。
  • 空间复杂度：O(1)。
class Solution {
public:
    void reverse(string& s, int start, int end){ //翻转，区间写法：左闭又闭 []
        for (int i = start, j = end; i < j; i++, j--) {
            swap(s[i], s[j]);
        }
    }

    void removeExtraSpaces(string& s) {//去除所有空格并在相邻单词之间添加空格, 快慢指针。
        int slow = 0;  
        for (int i = 0; i < s.size(); ++i) { 
            if (s[i] != ' ') 
            { //遇到非空格就处理，即删除所有空格。
                if (slow != 0) s[slow++] = ' '; //手动控制空格，给单词之间添加空格。slow != 0说明不是第一个单词，需要在单词前添加空格。
                while (i < s.size() && s[i] != ' ') 
                { //补上该单词，遇到空格说明单词结束。
                    s[slow++] = s[i++];
                }
            }
        }
        s.resize(slow); //slow的大小即为去除多余空格后的大小。
    }

    string reverseWords(string s) {
        removeExtraSpaces(s); //去除多余空格，保证单词之间之只有一个空格，且字符串首尾没空格。
        reverse(s, 0, s.size() - 1);
        int start = 0; //removeExtraSpaces后保证第一个单词的开始下标一定是0。
        for (int i = 0; i <= s.size(); ++i) {
            if (i == s.size() || s[i] == ' ') { //到达空格或者串尾，说明一个单词结束。进行翻转。
                reverse(s, start, i - 1); //翻转，注意是左闭右闭 []的翻转。
                start = i + 1; //更新下一个单词的开始下标start
            }
        }
        return s;
    }
};

5-反转链表

链接: 206

题意：反转一个单链表。 示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL

解法一：双指针法

  • 时间复杂度：O(n)，其中 n 是链表的长度。需要遍历链表一次。
  • 空间复杂度：O(1)。
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* temp; // 保存cur的下一个节点
        ListNode* cur = head;
        ListNode* pre = NULL;
        while(cur) {
            temp = cur->next;  // 保存一下 cur的下一个节点，因为接下来要改变cur->next
            cur->next = pre; // 翻转操作
            // 更新pre 和 cur指针
            pre = cur;
            cur = temp;
        }
        return pre;
    }
};

解法二：递归法

  • 时间复杂度：O(n)。
  • 空间复杂度：O(n)。
class Solution {
public:
    ListNode* reverse(ListNode* pre,ListNode* cur){
        if(cur == NULL) return pre;
        ListNode* temp = cur->next;
        cur->next = pre;
        // 可以和双指针法的代码进行对比，如下递归的写法，其实就是做了这两步
        // pre = cur;
        // cur = temp;
        return reverse(cur,temp);
    }
    ListNode* reverseList(ListNode* head) {
        // 和双指针法初始化是一样的逻辑
        // ListNode* cur = head;
        // ListNode* pre = NULL;
        return reverse(NULL, head);
    }

};

解法三：递归法

  • 时间复杂度：O(n)。
  • 空间复杂度：O(n)。
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if (head == NULL || head->next == NULL) {
            return head;
        }
        ListNode* ret = reverseList(head->next);
        head->next->next = head;
        head->next = NULL;
        return ret;
    }
};

6-删除链表的倒数第 N 个结点

链接: 19

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。 进阶：你能尝试使用一趟扫描实现吗？
示例 1： 输入：head = [1,2,3,4,5], n = 2 输出：[1,2,3,5]
示例 2： 输入：head = [1], n = 1 输出：[]
示例 3： 输入：head = [1,2], n = 1 输出：[1]

  • 时间复杂度：O(L)，其中 L 是链表的长度。
  • 空间复杂度：O(1)。
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode* slow = dummyHead;
        ListNode* fast = dummyHead;
        while(n-- && fast != NULL) {
            fast = fast->next;
        }
        fast = fast->next; // fast再提前走一步，因为需要让slow指向删除节点的上一个节点
        while (fast != NULL) {
            fast = fast->next;
            slow = slow->next;
        }
        slow->next = slow->next->next; 
        
        // ListNode *tmp = slow->next;  C++释放内存的逻辑
        // slow->next = tmp->next;
        // delete nth;
        
        return dummyHead->next;
    }
};

7-链表相交

链接: 面试题 02.07

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。
题目数据 保证 整个链式结构中不存在环。注意，函数返回结果后，链表必须 保持其原始结构 。

解法一： 双指针

  • 时间复杂度：O(m+n)，其中 m 和 n 是分别是链表headA 和headB 的长度。两个指针同时遍历两个链表，每个指针遍历两个链表各一次。
  • 空间复杂度：O(1)。
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        if (headA == nullptr || headB == nullptr) {
            return nullptr;
        }
        ListNode *pA = headA, *pB = headB;
        while (pA != pB) {
            pA = pA == nullptr ? headB : pA->next;
            pB = pB == nullptr ? headA : pB->next;
        }
        return pA;
    }
};

解法二：哈希表

  • 时间复杂度：O(m+n)，其中 m 和 n 是分别是链表 headA 和 headB 的长度。需要遍历两个链表各一次。
  • 空间复杂度：O(m)，其中 m 是链表headA 的长度。需要使用哈希集合存储链表 headA 中的全部节点。
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        unordered_set<ListNode *> visited;
        ListNode *temp = headA;
        while (temp != nullptr) {
            visited.insert(temp);
            temp = temp->next;
        }
        temp = headB;
        while (temp != nullptr) {
            if (visited.count(temp)) {
                return temp;
            }
            temp = temp->next;
        }
        return nullptr;
    }
};

解法三：双指针法

  • 时间复杂度：O(m+2n)，其中 m 和 n 是分别是链表headA 和headB 的长度。两个指针同时遍历两个链表，每个指针遍历两个链表各一次。
  • 空间复杂度：O(1)。
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* curA = headA;
        ListNode* curB = headB;
        int lenA = 0, lenB = 0;
        while (curA != NULL) { // 求链表A的长度
            lenA++;
            curA = curA->next;
        }
        while (curB != NULL) { // 求链表B的长度
            lenB++;
            curB = curB->next;
        }
        curA = headA;
        curB = headB;
        // 让curA为最长链表的头，lenA为其长度
        if (lenB > lenA) {
            swap (lenA, lenB);
            swap (curA, curB);
        }
        // 求长度差
        int gap = lenA - lenB;
        // 让curA和curB在同一起点上（末尾位置对齐）
        while (gap--) {
            curA = curA->next;
        }
        // 遍历curA 和 curB，遇到相同则直接返回
        while (curA != NULL) {
            if (curA == curB) {
                return curA;
            }
            curA = curA->next;
            curB = curB->next;
        }
        return NULL;
    }
};

8-环形链表II

链接: 142

题意： 给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。 为了表示给定链表中的环，使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。 说明：不允许修改给定的链表。

快慢指针

思路

设开始位置到入环为a，环为b，相遇处距环入口为x，慢指针每次走1步，走s，快指针每次走2步，走f

  1. f = 2s；
  2. f = a + nb + x
  3. s = a + x //快指针相对慢指针每次走1，因此在慢指针走完一圈前一定能被追上
    ----> a + x = nb //n为相遇前快指针多走的圈数
  4. 环入口：a + mb //m为任意整数
    ----> 快慢指针相遇后再走a即可到达环入口
  • 时间复杂度 O(n) ：第二次相遇中，慢指针须走步数 a<a+b；第一次相遇中，慢指针须走步数a+b−x<a+b，其中 x 为双指针重合点与环入口距离；因此总体为线性复杂度；
  • 空间复杂度 O(1) ：双指针使用常数大小的额外空间。
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode* fast = head;
        ListNode* slow = head;
        while(fast != NULL && fast->next != NULL) {
            slow = slow->next;
            fast = fast->next->next;
            // 快慢指针相遇，此时从head 和 相遇点，同时查找直至相遇
            if (slow == fast) {
                ListNode* index1 = fast;
                ListNode* index2 = head;
                while (index1 != index2) {
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index2; // 返回环的入口
            }
        }
        return NULL;
    }
};

9-三数之和

链接: 15

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0
？请你找出所有满足条件且不重复的三元组。 注意： 答案中不可以包含重复的三元组。 示例：给定数组 nums = [-1, 0, 1,
2, -1, -4]，满足要求的三元组集合为： [ [-1, 0, 1], [-1, -1, 2] ]

  • 时间复杂度：O(n2)，数组排序O(NlogN)，遍历数组 O(n)，双指针遍历 O(n)，总体O(NlogN)+O(n)∗O(n)，O(n2)
  • 空间复杂度：O(1)
class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> result;
        sort(nums.begin(), nums.end());
        // 找出a + b + c = 0
        // a = nums[i], b = nums[left], c = nums[right]
        for (int i = 0; i < nums.size(); i++) {
            // 排序之后如果第一个元素已经大于零，那么无论如何组合都不可能凑成三元组，直接返回结果就可以了
            if (nums[i] > 0) {
                return result;
            }
            // 错误去重a方法，将会漏掉-1,-1,2 这种情况
            //我们要做的是不能有重复的三元组，但三元组内的元素是可以重复的！
            /*
            if (nums[i] == nums[i + 1]) {
                continue;
            }
            */
            // 正确去重a方法
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }
            int left = i + 1;
            int right = nums.size() - 1;
            while (right > left) {
                // 去重复逻辑如果放在这里，0，0，0 的情况，可能直接导致 right<=left 了，从而漏掉了 0,0,0 这种三元组
                /*
                while (right > left && nums[right] == nums[right - 1]) right--;
                while (right > left && nums[left] == nums[left + 1]) left++;
                */
                if (nums[i] + nums[left] + nums[right] > 0) right--;
                else if (nums[i] + nums[left] + nums[right] < 0) left++;
                else {
                    result.push_back(vector<int>{nums[i], nums[left], nums[right]});
                    // 去重逻辑应该放在找到一个三元组之后，对b 和 c去重
                    while (right > left && nums[right] == nums[right - 1]) right--;
                    while (right > left && nums[left] == nums[left + 1]) left++;

                    // 找到答案时，双指针同时收缩
                    right--;
                    left++;
                }
            }

        }
        return result;
    }
};

10-四数之和

链接: 18

题意：给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。 注意：答案中不可以包含重复的四元组。
示例：给定数组 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。
满足要求的四元组集合为： [ [-1, 0, 0, 1], [-2, -1, 1, 2], [-2, 0, 0, 2] ]

  • 时间复杂度：O(n3)，其中 n 是数组的长度。排序的时间复杂度是O(nlogn)，枚举四元组的时间复杂度是 O(n3)，因此总时间复杂度为O(n3+nlogn)=O(n3)。
  • 空间复杂度：O(n)，其中 n 是数组的长度。空间复杂度主要取决于排序额外使用的空间。此外排序修改了输入数组 nums，实际情况中不一定允许，因此也可以看成使用了一个额外的数组存储了数组nums 的副本并排序。
class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> result;
        sort(nums.begin(), nums.end());
        for (int k = 0; k < nums.size(); k++) {
            // 剪枝处理,target可能为负
            if (nums[k] > target && nums[k] >= 0) {
            	break; // 这里使用break，统一通过最后的return返回
            }
            // 对nums[k]去重
            if (k > 0 && nums[k] == nums[k - 1]) {
                continue;
            }
            for (int i = k + 1; i < nums.size(); i++) {
                // 2级剪枝处理
                if (nums[k] + nums[i] > target && nums[k] + nums[i] >= 0) {
                    break;
                }
                // 对nums[i]去重
                if (i > k + 1 && nums[i] == nums[i - 1]) {
                    continue;
                }
                int left = i + 1;
                int right = nums.size() - 1;
                while (right > left) {
                    // nums[k] + nums[i] + nums[left] + nums[right] > target 会溢出
                    if ((long) nums[k] + nums[i] + nums[left] + nums[right] > target) {
                        right--;
                    // nums[k] + nums[i] + nums[left] + nums[right] < target 会溢出
                    } else if ((long) nums[k] + nums[i] + nums[left] + nums[right]  < target) {
                        left++;
                    } else {
                        result.push_back(vector<int>{nums[k], nums[i], nums[left], nums[right]});
                        // 对nums[left]和nums[right]去重
                        while (right > left && nums[right] == nums[right - 1]) right--;
                        while (right > left && nums[left] == nums[left + 1]) left++;

                        // 找到答案时，双指针同时收缩
                        right--;
                        left++;
                    }
                }
            }
        }
        return result;
    }
};
chongdada
关注
专栏目录
leetcode 两数之和(双指针法)
^.^
06-13 1408
题目链接：1. 两数之和 做几个小笔记吧： c++实现哈希可以使用map，查找map里是否含有某个元素时，使用find方法。时间复杂度logN。判断方法：mmp.find(……)！=mmp.end() python实现哈希可以使用字典dict。查找dict里是否有某个元素时，使用get()方法。时间复杂度O1.判断方法：dict.get(……)!=none class Solution {//两遍哈希 public: vector<int> twoSum(vector<..
称最多水的容器 多解 (java)（暴力枚举+剪枝)（双指针法）
weixin_61672734的博客
04-08 203
leecode的一道中档题 11. 盛最多水的容器 难度中等3382收藏分享切换为英文接收动态反馈 给定一个长度为n的整数数组height。有n条垂线，第i条线的两个端点是(i, 0)和(i, height[i])。 找出其中的两条线，使得它们与x轴共同构成的容器可以容纳最多的水。 返回容器可以储存的最大水量。 说明：你不能倾斜容器。 示例 1： 输入：[1,8,6,2,5,4,8,3,7] 输出：49 解释：图中垂直线代表输入数组 [1,8,6,2,...
九章算法之两根指针(Two Pointers)
01-10
九章算法之两根指针(Two Pointers) 多看多思考，5493897
相向双指针
m0_53302824的博客
01-30 110
冲
相向双指针-习题
weixin_47166787的博客
02-21 557
1. List 与 Arraylist 2. heap 3. HashMap底层实现 getOrDefault()方法 4.链表
【算法】双指针算法 ( 双指针算法分类 | 相向双指针 | 有效回文串 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
07-25 1848
一、双指针算法分类、 二、相向双指针示例 ( 有效回文串 )、
算法套路二:相向双指针
Pistachiout的学习博客
03-06 668
相向双指针故套路如下: 比较 s = numbers[left] + numbers[right]与**固定值target**（关键为找到该固定值） 如果s > target，right-- 如果s < target，left++
leecode常见代码收集
03-21
例如，反转链表、实现栈的压入弹出、双指针法处理队列等。 5. **字符串处理**：涉及到字符串的遍历、比较、模式匹配和操作，如KMP算法、Z Algorithm等。 6. **图论**：包括深度优先遍历、广度优先遍历、最短路径...
Leecode 题集
lena blog
02-21 1240
题目 给定一个二进制数组， 计算其中最大连续 1 的个数。 解答： class Solution { public int findMaxConsecutiveOnes(int[] nums) { int sum=0; for(int i=0;i<nums.length;i++){ if(nums[i]==1){ sum++; }else{ if(
lee_code(两数之和)_leecode_乐扣题目_乐扣编程_
10-02
2. 练习不同类型的解题思路，比如双指针法，也可以解决这个问题。 3. 多做LeetCode上的编程题目，提高编程能力和算法理解。 4. 针对不同场景优化算法，例如在内存有限的情况下，可以考虑使用其他数据结构或算法。 ...
相向双指针：寻找数据中的和谐旋律
master_chenchen的博客
07-09 1045
相向双指针，顾名思义，是指在数据结构（通常是数组或列表）的两端分别设置两个指针，它们向中心移动，直到满足某种条件或相遇为止。这种技术在处理排序或部分排序的数据时特别有效，因为它能够避免不必要的比较，从而达到较高的效率。
双指针在解题中的应用：同向双指针；相向双指针
个人工作中学到的专业技术与职业发展知识笔记
06-18 719
1、同向双指针： 2、相向双指针：
[算法学习01]相向双指针的使用
weixin_45066884的博客
12-04 1027
暂时没什么想说的，继续努力吧。
双指针技巧——初级
jdjhsj的博客
07-16 539
双指针入门
[零基础算法入门①] 双指针法
罅隙的博客
12-08 1439
????????零基础算法入门系列——双指针法
算法思想：双指针
oXiaoBuDing的博客
11-26 4011
双指针主要用于遍历数组，两个指针指向不同的元素，从而协同完成任务。双指针可以从不同的方向向中间逼近也可以朝着同一个方向遍历。 在LeedCode中有很多题目可以通过双指针的思想来解答。其中包括： 1、有序数组的 Two Sum Leetcode ：167. Two Sum II - Input array is sorted (Easy) Input: numbers={2, 7, 11, 15}...
【基础算法系列】相向双指针
weixin_45070267的博客
01-03 964
如果我们移动高度较大的一端，那么前者「两端最小高度」不会增加，而后者「两端之间的距离」会减小，那么这个乘积会减小。能接的雨水量还是取决于高度小的一端，而每根柱子所在位置能接多少雨水，又是取决于其高度较短一端的高度最大值。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。输入：height = [0,1,0,2,1,0,1,3,2,1,2,1]以数组 [0,1,0,2,1,0,1,3,2,1,2,1] 为具体例子来看。以数组 [1, 8, 6, 2, 5, 4, 8, 3, 7] 为例。
知识点 相向双指针
m0_64219374的博客
01-09 444
8.在解决三个或多个元素的问题时，利用了整体的思想，将多个元素视为一个整体，多次判断，多次移动，如先判断（元素1）和（元素2、元素3）的关系，移动指针，再判断（元素2）和（元素3）的关系。2.算法思路：将数组有序排列，初始时，双指针分别位于“最大”和“最小”的元素，然后判断两个指针哪个移动。5.每个元素相当于指针指一遍，只需要几个变量而已，时间复杂度为O(n)，空间复杂度为O(1)。1.基于数组等有序的特点，优化暴力解法，用O(1)的时间做O(n)的事，提升算法的执行效率。
【力扣 + 牛客 | SQL题 | 每日5题】牛客SQL热题216，217，223
最新发布
2301_80912559的博客
10-30 1006
你正在搭建一个用户活跃度的画像，其中一个与活跃度相关的特征是“最长连续登录天数”， 请用SQL实现“2023年1月1日-2023年1月31日用户最长的连续登录天数”一句话：两个记录的日期的差值如果等于两记录的排名差值，说明中间一直是连续的。使用join查询方式找出没有分类的电影id以及其电影名称。这不一眼窗口函数么。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值