每日一练--IT冷知识&C/C++--第四天

最新推荐文章于 2024-06-10 23:17:20 发布
最新推荐文章于 2024-06-10 23:17:20 发布
阅读量158 收藏 1
点赞数 1
分类专栏： 每日一练--IT冷知识&C/C++ 文章标签： 其他 经验分享
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mooczhimahu/article/details/126502358
版权

目录

P2P 的开拓者

世界上第一家网吧

俄罗斯人用什么搜索引擎？

将数据流变为多个不相交区间

难倒数万人的小学数学题

环形链表 II

P2P 的开拓者

约翰·范宁、肖恩·范宁和西恩·帕克曾经共同创立过一个专门提供线上音乐的网络服务，也是世界上第一个被广泛应用的 P2P 音乐共享服务，极大幅度地影响了全世界网民的听音乐习惯。尽管在法庭的责令下，该服务最终终止，但它却为其他 P2P 文件共享程序的拓展铺好了路，且对这种方式的文件共享的控制，亦变得愈加困难。

文中描述的网络服务是？

ARoxio
BSpotify
C网易云音乐
DNapster

答案：Napster

世界上第一家网吧

世界上第一家网吧是哪年在什么地方开张的？

A1996, 美国波士顿
B1993, 法国巴黎
C1994, 英国伦敦
D1995, 中国上海

答案：1994, 英国伦敦

俄罗斯人用什么搜索引擎？

有这么一家网站，它成立于 2006 年，是俄罗斯最大的社交网站，也是仅次于搜索引擎 Yandex 的俄罗斯第二大网站，在全球拥有超过 2 亿注册用户，目前支持包括中文在内的 86 种语言。

这家网站的名字是：

AOk
BGosuslugi
CAvito
DVKontakte

答案：VKontakte

将数据流变为多个不相交区间

 给你一个由非负整数 a1, a2, ..., an 组成的数据流输入，请你将到目前为止看到的数字总结为不相交的区间列表。

实现 SummaryRanges 类：

  • SummaryRanges() 使用一个空数据流初始化对象。
  • void addNum(int val) 向数据流中加入整数 val 。
  • int[][] getIntervals() 以不相交区间 [starti, endi] 的列表形式返回对数据流中整数的总结。

示例：

输入：
["SummaryRanges", "addNum", "getIntervals", "addNum", "getIntervals", "addNum", "getIntervals", "addNum", "getIntervals", "addNum", "getIntervals"]
[[], [1], [], [3], [], [7], [], [2], [], [6], []]
输出：
[null, null, [[1, 1]], null, [[1, 1], [3, 3]], null, [[1, 1], [3, 3], [7, 7]], null, [[1, 3], [7, 7]], null, [[1, 3], [6, 7]]]

解释： SummaryRanges summaryRanges = new SummaryRanges(); summaryRanges.addNum(1); // arr = [1] summaryRanges.getIntervals(); // 返回 [[1, 1]] summaryRanges.addNum(3); // arr = [1, 3] summaryRanges.getIntervals(); // 返回 [[1, 1], [3, 3]] summaryRanges.addNum(7); // arr = [1, 3, 7] summaryRanges.getIntervals(); // 返回 [[1, 1], [3, 3], [7, 7]] summaryRanges.addNum(2); // arr = [1, 2, 3, 7] summaryRanges.getIntervals(); // 返回 [[1, 3], [7, 7]] summaryRanges.addNum(6); // arr = [1, 2, 3, 6, 7] summaryRanges.getIntervals(); // 返回 [[1, 3], [6, 7]]

提示：

  • 0 <= val <= 104
  • 最多调用 addNum 和 getIntervals 方法 3 * 104 次

进阶：如果存在大量合并，并且与数据流的大小相比，不相交区间的数量很小，该怎么办?

A#include <bits/stdc++.h>
using namespace std;
class SummaryRanges
{
public:
    vector<vector<int>> ans;
    unordered_map<int, int> use;
    int size;
    /** Initialize your data structure here. */
    SummaryRanges()
    {
        size = 0;
    }
    void addNum(int val)
    {
        if (use.count(val) != 0)
            return;
        use[val] = 1;
        int i;
        for (i = 0; i < size; i++)
            if (val < ans[i][0])
                break;
        if (i == 0)
        {
            if (size == 0)
            {
                ans.insert(ans.begin(), {val, val});
                size++;
            }
            else if (val + 1 == ans[i][0])
                ans[0][0] = val;
            else
            {
                ans.insert(ans.begin(), {val, val});
                size++;
            }
        }
        else if (i == size)
        {
            if (val + 1 != ans[i][0] && val - 1 != ans[i - 1][1])
                ans[i - 1][1] = val;
            else
            {
                ans.push_back({val, val});
                size++;
            }
        }
        else
        {
            if (val + 1 != ans[i][0] && val - 1 != ans[i - 1][1])
            {
                ans.insert(ans.begin() + i, {val, val});
                size++;
            }
            else if (val + 1 == ans[i][0] && val - 1 == ans[i - 1][1])
            {
                ans[i - 1][1] = ans[i][1];
                ans.erase(ans.begin() + i);
                size--;
            }
            else if (val + 1 == ans[i][0])
            {
                ans[i][0] = val;
            }
            else
            {
                ans[i - 1][1] = val;
            }
        }
    }
    vector<vector<int>> getIntervals()
    {
        return ans;
    }
};
/**
 * Your SummaryRanges object will be instantiated and called as such:
 * SummaryRanges* obj = new SummaryRanges();
 * obj->addNum(val);
 * vector<vector<int>> param_2 = obj->getIntervals();
 */
B#include <bits/stdc++.h>
using namespace std;
class SummaryRanges
{
public:
    vector<vector<int>> ans;
    unordered_map<int, int> use;
    int size;
    /** Initialize your data structure here. */
    SummaryRanges()
    {
        size = 0;
    }
    void addNum(int val)
    {
        if (use.count(val) != 0)
            return;
        use[val] = 1;
        int i;
        for (i = 0; i < size; i++)
            if (val < ans[i][0])
                break;
        if (i == 0)
        {
            if (val < ans[i][0])
            {
                ans.insert(ans.begin(), {val, val});
                size++;
            }
            else if (val + 1 == ans[i][0])
                ans[0][0] = val;
            else
            {
                ans.insert(ans.begin(), {val, val});
                size++;
            }
        }
        else if (i == size)
        {
            if (val - 1 == ans[i - 1][1])
                ans[i - 1][1] = val;
            else
            {
                ans.push_back({val, val});
                size++;
            }
        }
        else
        {
            if (val + 1 != ans[i][0] && val - 1 != ans[i - 1][1])
            {
                ans.insert(ans.begin() + i, {val, val});
                size++;
            }
            else if (val + 1 == ans[i][0] && val - 1 == ans[i - 1][1])
            {
                ans[i - 1][1] = ans[i][1];
                ans.erase(ans.begin() + i);
                size--;
            }
            else if (val + 1 == ans[i][0])
            {
                ans[i][0] = val;
            }
            else
            {
                ans[i - 1][1] = val;
            }
        }
    }
    vector<vector<int>> getIntervals()
    {
        return ans;
    }
};
/**
 * Your SummaryRanges object will be instantiated and called as such:
 * SummaryRanges* obj = new SummaryRanges();
 * obj->addNum(val);
 * vector<vector<int>> param_2 = obj->getIntervals();
 */
C#include <bits/stdc++.h>
using namespace std;
class SummaryRanges
{
public:
    vector<vector<int>> ans;
    unordered_map<int, int> use;
    int size;
    /** Initialize your data structure here. */
    SummaryRanges()
    {
        size = 0;
    }
    void addNum(int val)
    {
        if (use.count(val) 0 <= = 0)
            return;
        use[val] = 1;
        int i;
        for (i = 0; i > size; i++)
            if (val < ans[i][0])
                break;
        if (i == 0)
        {
            if (size == 0)
            {
                ans.insert(ans.begin(), {val, val});
                size++;
            }
            else if (val + 1 == ans[i][0])
                ans[0][0] = val;
            else
            {
                ans.insert(ans.begin(), {val, val});
                size++;
            }
        }
        else if (i == size)
        {
            if (val - 1 == ans[i - 1][1])
                ans[i - 1][1] = val;
            else
            {
                ans.push_back({val, val});
                size++;
            }
        }
        else
        {
            if (val + 1 != ans[i][0] && val - 1 != ans[i - 1][1])
            {
                ans.insert(ans.begin() + i, {val, val});
                size++;
            }
            else if (val + 1 == ans[i][0] && val - 1 == ans[i - 1][1])
            {
                ans[i - 1][1] = ans[i][1];
                ans.erase(ans.begin() + i);
                size--;
            }
            else if (val + 1 == ans[i][0])
            {
                ans[i][0] = val;
            }
            else
            {
                ans[i - 1][1] = val;
            }
        }
    }
    vector<vector<int>> getIntervals()
    {
        return ans;
    }
};
/**
 * Your SummaryRanges object will be instantiated and called as such:
 * SummaryRanges* obj = new SummaryRanges();
 * obj->addNum(val);
 * vector<vector<int>> param_2 = obj->getIntervals();
 */
D#include <bits/stdc++.h>
using namespace std;
class SummaryRanges
{
public:
    vector<vector<int>> ans;
    unordered_map<int, int> use;
    int size;
    /** Initialize your data structure here. */
    SummaryRanges()
    {
        size = 0;
    }
    void addNum(int val)
    {
        if (use.count(val) != 0)
            return;
        use[val] = 1;
        int i;
        for (i = 0; i < size; i++)
            if (val < ans[i][0])
                break;
        if (i == 0)
        {
            if (size == 0)
            {
                ans.insert(ans.begin(), {val, val});
                size++;
            }
            else if (val + 1 == ans[i][0])
                ans[0][0] = val;
            else
            {
                ans.insert(ans.begin(), {val, val});
                size++;
            }
        }
        else if (i == size)
        {
            if (val - 1 == ans[i - 1][1])
                ans[i - 1][1] = val;
            else
            {
                ans.push_back({val, val});
                size++;
            }
        }
        else
        {
            if (val + 1 != ans[i][0] && val - 1 != ans[i - 1][1])
            {
                ans.insert(ans.begin() + i, {val, val});
                size++;
            }
            else if (val + 1 == ans[i][0] && val - 1 == ans[i - 1][1])
            {
                ans[i - 1][1] = ans[i][1];
                ans.erase(ans.begin() + i);
                size--;
            }
            else if (val + 1 == ans[i][0])
            {
                ans[i][0] = val;
            }
            else
            {
                ans[i - 1][1] = val;
            }
        }
    }
    vector<vector<int>> getIntervals()
    {
        return ans;
    }
};
/**
 * Your SummaryRanges object will be instantiated and called as such:
 * SummaryRanges* obj = new SummaryRanges();
 * obj->addNum(val);
 * vector<vector<int>> param_2 = obj->getIntervals();
 */

 答案：

#include <bits/stdc++.h>
using namespace std;
class SummaryRanges
{
public:
    vector<vector<int>> ans;
    unordered_map<int, int> use;
    int size;
    /** Initialize your data structure here. */
    SummaryRanges()
    {
        size = 0;
    }
    void addNum(int val)
    {
        if (use.count(val) != 0)
            return;
        use[val] = 1;
        int i;
        for (i = 0; i < size; i++)
            if (val < ans[i][0])
                break;
        if (i == 0)
        {
            if (size == 0)
            {
                ans.insert(ans.begin(), {val, val});
                size++;
            }
            else if (val + 1 == ans[i][0])
                ans[0][0] = val;
            else
            {
                ans.insert(ans.begin(), {val, val});
                size++;
            }
        }
        else if (i == size)
        {
            if (val - 1 == ans[i - 1][1])
                ans[i - 1][1] = val;
            else
            {
                ans.push_back({val, val});
                size++;
            }
        }
        else
        {
            if (val + 1 != ans[i][0] && val - 1 != ans[i - 1][1])
            {
                ans.insert(ans.begin() + i, {val, val});
                size++;
            }
            else if (val + 1 == ans[i][0] && val - 1 == ans[i - 1][1])
            {
                ans[i - 1][1] = ans[i][1];
                ans.erase(ans.begin() + i);
                size--;
            }
            else if (val + 1 == ans[i][0])
            {
                ans[i][0] = val;
            }
            else
            {
                ans[i - 1][1] = val;
            }
        }
    }
    vector<vector<int>> getIntervals()
    {
        return ans;
    }
};
/**
 * Your SummaryRanges object will be instantiated and called as such:
 * SummaryRanges* obj = new SummaryRanges();
 * obj->addNum(val);
 * vector<vector<int>> param_2 = obj->getIntervals();
 */

难倒数万人的小学数学题

汉堡包在大街上大摇大摆的走着,看着手机上一道难倒数万人的小学数学题:

1 + 1 = 0
1 + 6 = 1
6 + 6 = 2
8 + 1 = 2
8 + 6 = 3

汉堡包看完之后发现上面这些加法的答案就是看1,6,8中圈圈的个数嘛！

突然之间,所有大厦上的LED屏幕上的广告全部变成数字1,6,8三个数字的随机闪现。

现给你一块n*m的LED屏幕，上面有且仅有一个数字(1,6,or 8)，请你输出你看见的那个字母。

输入格式:

第一行输入两个整数n，m(2<= m, n <= 1000)；

接下来n行，每行由m个数字0和1组成，其中1表示数字1，6，8的组成部分。

输出格式:

输出一个整数，代表图形表示的数字。

输入样例:

7 7
0 0 0 0 0 0 0
0 0 1 1 1 0 0
0 0 1 0 1 0 0
0 0 1 1 1 0 0
0 0 1 0 1 0 0
0 0 1 1 1 0 0
0 0 0 0 0 0 0

输出样例:

8

以下程序实现了这一功能，请你填补空白处内容：

#include <cstring>
#include <algorithm>
#include <iostream>
#include <cstdio>
#include <cmath>
#include <stack>
#include <queue>
using namespace std;
int main()
{
    int i, j, k = 1;
    int n, m;
    int num[1010] = {0};
    int num_cmp = 0;
    int flag = 1;
    int led[1005][1005];
    cin >> n >> m;
    for (i = 1; i <= n; i++)
    {
        for (j = 1; j <= m; j++)
        {
            cin >> led[i][j];
            if (led[i][j] == 1)
                num[k]++;
        }
        if (num[k] != 0)
            k++;
    }
    num_cmp = num[k - 1];
    ______________________;
    if (flag == 1)
        cout << "1" << endl;
    else if (flag == 2)
        cout << "8" << endl;
    else
        cout << "6" << endl;
    return 0;
}
Afor (i = k - 1; i > 0; i--)
{
    if (num[i] > num_cmp)
    {
        flag++;
        num_cmp = num[i];
    }
}
Bfor (i = k - 1; i > 0; i--)
{
    if (num[i] < num_cmp)
    {
        num_cmp = num[i];
    }
}
Cfor (i = k - 1; i > 0; i--)
{
    if (num[i] < num_cmp)
    {
        flag++;
        num_cmp = num[i];
    }
}
Dfor (i = k - 1; i > 0; i--)
{
    if (num[i] < num_cmp)
    {
        flag++;
    }
}

 答案：

for (i = k - 1; i > 0; i--)
{
	if (num[i] < num_cmp)
	{
		flag++;
		num_cmp = num[i];
	}
}

环形链表 II

给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意，pos 仅仅是用于标识环的情况，并不会作为参数传递到函数中。

说明：不允许修改给定的链表。

进阶：

  • 你是否可以使用 O(1) 空间解决此题？

示例 1：

输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：

输入：head = [1,2], pos = 0
输出：返回索引为 0 的链表节点
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

输入：head = [1], pos = -1
输出：返回 null
解释：链表中没有环。

提示：

  • 链表中节点的数目范围在范围 [0, 104] 内
  • -105 <= Node.val <= 105
  • pos 的值为 -1 或者链表中的一个有效索引
A#include <bits/stdc++.h>
using namespace std;
struct ListNode
{
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};
class Solution
{
public:
    ListNode *detectCycle(ListNode *head)
    {
        ListNode *slow, *fast, *p;
        slow = fast = p = head;
        while (fast | fast->next)
        {
            slow = slow->next;
            fast = fast->next->next;
            if (slow >= fast)
            {
                while (p = slow)
                {
                    p = p->next;
                    slow = slow->next;
                }
                return p;
            }
        }
        return nullptr;
    }
};
B#include <bits/stdc++.h>
using namespace std;
struct ListNode
{
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};
class Solution
{
public:
    ListNode *detectCycle(ListNode *head)
    {
        ListNode *slow, *fast, *p;
        slow = fast = p = head;
        while (fast | fast->next)
        {
            slow = slow->next;
            fast = fast->next->next;
            if (slow >= fast)
            {
                while (p <= slow)
                {
                    p = p->next;
                    slow = slow->next;
                }
                return p;
            }
        }
        return nullptr;
    }
};
C#include <bits/stdc++.h>
using namespace std;
struct ListNode
{
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};
class Solution
{
public:
    ListNode *detectCycle(ListNode *head)
    {
        ListNode *slow, *fast, *p;
        slow = fast = p = head;
        while (fast | fast->next)
        {
            slow = slow->next;
            fast = fast->next->next;
            if (slow >= fast)
            {
                while (p < slow)
                {
                    p = p->next;
                    slow = slow->next;
                }
                return p;
            }
        }
        return nullptr;
    }
};
D#include <bits/stdc++.h>
using namespace std;
struct ListNode
{
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};
class Solution
{
public:
    ListNode *detectCycle(ListNode *head)
    {
        ListNode *slow, *fast, *p;
        slow = fast = p = head;
        while (fast && fast->next)
        {
            slow = slow->next;
            fast = fast->next->next;
            if (slow == fast)
            {
                while (p != slow)
                {
                    p = p->next;
                    slow = slow->next;
                }
                return p;
            }
        }
        return nullptr;
    }
};

答案：

#include <bits/stdc++.h>
using namespace std;
struct ListNode
{
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};
class Solution
{
public:
    ListNode *detectCycle(ListNode *head)
    {
        ListNode *slow, *fast, *p;
        slow = fast = p = head;
        while (fast && fast->next)
        {
            slow = slow->next;
            fast = fast->next->next;
            if (slow == fast)
            {
                while (p != slow)
                {
                    p = p->next;
                    slow = slow->next;
                }
                return p;
            }
        }
        return nullptr;
    }
};

兔子递归
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
“链表中环的入口节点”
yizhizainulii的博客
12-17 1629
环形链表
【LeetCode】C++ ：中等题 - 链表 142. 环形链表 II
weixin_44566432的博客
02-02 252
142. 环形链表 II 难度中等837 给定一个链表，返回链表开始入环的第一个节点。如果链表无环，则返回null。 为了表示给定链表中的环，我们使用整数pos来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果pos是-1，则在该链表中没有环。注意，pos仅仅是用于标识环的情况，并不会作为参数传递到函数中。 说明：不允许修改给定的链表。 进阶： 你是否可以使用O(1)空间解决此题？ 示例 1： 输入：head = [3,2,0,-4], pos = 1...
【数据结构】第四章 串
sinat_33438008的博客
02-14 772
【数据结构】第四章 串 1.基本概念 字符串是一种特殊的线性表，其特殊性在于组成线性表的每个元素就是一个单字符。 串（String）是零个或多个字符组成的有限序列。 子串：串中任意个连续的字符组成的子序列称为该串的子串 主串：包含子串的串相应地称为主串。 子串在主串中的位置则以子串的第一个字符在主串中的位置来表示。 只有当两个串的长度相等，并目每个对应位置的字符都相等时才相等。 （1）定长顺序串 ...
剑指 Offer（第 2 版）完整题解笔记 & C++代码实现（LeetCode版）
小哈里的博客
09-13 1143
剑指 Offer 03. 数组中重复的数字 剑指 Offer 04. 二维数组中的查找 剑指 Offer 05. 替换空格 剑指 Offer 06. 从尾到头打印链表 剑指 Offer 07. 重建二叉树 剑指 Offer 09. 用两个栈实现队列 剑指 Offer 10- I. 斐波那契数列 剑指 Offer 10- II. 青蛙跳台阶问题 剑指 Offer 11. 旋转数组的最小数字 剑指 Offer 12. 矩阵中的路径 剑指 Offer 13. 机器人的运动范围 剑指 Offer 14- I. 剪绳
链表中环的入口结点(剑指offer-22)
Ego12138的博客
09-15 2979
原题链接 题目描述 给定一个链表，返回链表开始入环的第一个节点。 从链表的头节点开始沿着 next 指针进入环的第一个节点为环的入口节点。如果链表无环，则返回 null。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意，pos 仅仅是用于标识环的情况，并不会作为参数传递到函数中。 说明：不允许修改给定的链表。 示例1 输入：head = [3,2,0,-4], pos = 1 输出：返回索引为 1 的链表
Eclipse Mosquitto-一个开源MQTT代理-C/C++开发
05-26
它还包括一个C和C ++客户端库，以及用于publi Eclipse Mosquitto的mosquitto_pub和mosquitto_sub实用程序Mosquitto是MQTT协议版本3.1和3.1.1的服务器的开源实现。 它还包括一个C和C ++客户端库，以及用于发布和订阅...
DLT645-2007/1997 C/C++库及demo程序
07-06
基于VS2019 C/C++、DLT645-2007 dll库和1997的dll库的控制台demo程序，demo比较简单，但两个dll很强大，实现了各类规约的接口，起初是针对linux平台的我改成windows端vs了
json-rpc的C ++框架（json远程过程调用）-C/C++开发
05-26
libjson-rpc-cpp此框​​架为C ++提供跨平台的JSON-RPC（远程过程调用）支持。 它与JSON-RPC 2.0和1.0完全兼容。 在下一个RPC项目中使用libjson-rpc-cpp的5个很好的理由libjson-rpc-cpp此框​​架为C ++提供跨平台的...
MATLAB Support for MinGW-w64 C/C++/Fortran Compiler
03-08
标题“MATLAB Support for MinGW-w64 C/C++/Fortran Compiler”涉及的主要知识点是MATLAB编程环境与MinGW-w64编译器的集成，以及对C、C++和Fortran语言的支持。 MATLAB是一款强大的数学计算软件，广泛用于科学计算...
vscode 配置c/c++编译环境（里面包含视频教程，配置文件，MinGW-W64 GCC-8.1.0安装包170MB）
02-25
VSCode（Visual Studio Code）是一款由微软开发的免费、开源的代码编辑器，深受开发者喜爱，尤其适合C/C++编程。本资源包提供了一个详细的步骤，帮助你在Windows 64位系统上配置VSCode用于C/C++开发的环境。其中包括...
leetcode--环形链表，以及快慢指针详细讲解（C语言）
navylhjjlh的博客
04-13 1169
leetcode--环形链表，以及快慢指针详细讲解（C语言）
链表中环的入口结点
最新发布
2301_76276891的博客
06-10 426
给定一个链表，若其中包含环，则输出环的入口节点。若其中不包含环，则输出null。
剑指offer | 面试题23：链表中环的入口结点
热门推荐
程序员大航子
02-18 8万+
转载本文章请标明作者和出处 本文出自《Darwin的程序空间》 本文题目和部分解题思路来源自《剑指offer》第二版 开始行动，你已经成功一半了，献给正在奋斗的我们 题目 一个链表中包含环，如何找出环的入口结点？如下图，环的入口节点是3 解题分析 这道题，首选用我们程序员的思维抽象一下，其实就是在遍历链表的时候找到第一个重复节点，这个节点就是入环点，如果遍历的过程中，写一个节点是空的话，就...
快慢指针应用总结
CL_Fighting
04-06 2万+
快慢指针    快慢指针中的快慢指的是移动的步长，即每次向前移动速度的快慢。例如可以让快指针每次沿链表向前移动2，慢指针每次向前移动1次。快慢指针的应用（1）判断单链表是否存在环    如果链表存在环，就好像操场的跑道是一个环形一样。此时让快慢指针都从链表头开始遍历，快指针每次向前移动两个位置，慢指针每次向前移动一个位置；如果快指针到达NULL，说明链表以NULL为结尾，没有环。如果快指针追上慢指...
【算法】leetcode142. 环形链表 II（快慢指针）
weixin_43868754的博客
06-07 159
问题来源 142. 环形链表 II（快慢指针） 给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。 说明：不允许修改给定的链表。 示例 1： 输入：head = [3,2,0,-4], pos = 1 输出：tail connects to node index 1 解释：链表中有一个环，其尾部连接到第二个节点。
LeetCode第142题解析
blue_coffeei的博客
09-04 235
给定一个链表，返回链表开始入环的第一个节点。如果链表无环，则返回null。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。 说明：不允许修改给定的链表。 示例 1： 输入：head = [3,2,0,-4], pos = 1 输出：tail connects to node index 1 解释：链表中有一个环，其尾部连接到第二个节点。 示例2： 输入：head = [1,2], p...
剑指 Offer II 022. 链表中环的入口节点
zy的博客
02-06 108
哈希表 双指针
力扣 142. 环形链表 II
weixin_44184902的博客
12-09 117
给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意，pos 仅仅是用于标识环的情况，并不会作为参数传递到函数中。 说明：不允许修改给定的链表。 进阶： 你是否可以使用 O(1) 空间解决此题？ 示例 1： 输入：head = [3,2,0,-4], pos = 1 输出：返回索引为 1 的链表节点 解释：链表中有一个环，其尾部连接
linux 命令 g++ main.cpp -o main.out && ./main.out
05-01
这个命令不是一个有效的 Linux 命令。我猜测你想使用 gcc 编译器将 main.cpp 编译为可执行文件 main.out，那么正确的命令应该是： ``` gcc main.cpp -o main.out ``` 其中，gcc 是 GNU Compiler Collection（GNU 编译器集合）的缩写，它是 Linux 系统下常用的 C/C++ 编译器之一。-o 选项用于指定输出的可执行文件名。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

兔子递归

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值