day1 牛客TOP100：BM 1-10 链表

已于 2023-08-30 10:18:06 修改
阅读量359 收藏
点赞数
分类专栏： C++刷题-LeetCode-牛客 文章标签： c++
于 2023-08-22 14:14:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/uuuuu22/article/details/132390251
版权

文章目录

链表

BM1 反转链表

题目
在这里插入图片描述

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    ListNode* ReverseList(ListNode* head) {
        if(head == nullptr) return head;
        ListNode* cur = head;
        ListNode* pre = nullptr;
        ListNode* temp;
        while(cur)
        {
            temp = cur->next;//保存cur下一个节点
            cur->next = pre;//反转
            pre = cur;
            cur = temp;
        }
        return pre;
    }
};

BM2 链表内指定区间反转

在这里插入图片描述
自己写的时候，思路正确，但是处理不好反转后的拼接

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    ListNode* reverseBetween(ListNode* head, int m, int n) {
        if(m == n) return head;
        ListNode* dummyhead = new ListNode(-1);
        dummyhead->next = head;

        //反转链表的前部分
        ListNode* start = dummyhead;
        for(int i=1; i<m; i++)
            start = start->next;//结点1
        cout << "start: "<< start->val <<endl;
        
        //反转链表的尾巴 第n个结点
        ListNode* right = start->next;
        for(int i=m; i<n; i++)
            right = right->next;//结点4
        cout << "right: "<< right->val <<endl;

        //反转链表的头尾
        ListNode* left = start->next;//2
        ListNode* end = right->next;//5
        
        //切断 left 1 2 3 4
        start->next = nullptr;
        right->next = nullptr;
        reverlist(left);

        //接回原来的链表
        start->next = right;//1->4
        left->next = end;//2->5
        return dummyhead->next;
    }
    void reverlist(ListNode* node)
    {
        ListNode* pre = nullptr;
        ListNode* cur = node;
        ListNode* temp;
        while(cur)
        {
            temp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = temp;
        }
    }
};

写法2

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param head ListNode类 
     * @param m int整型 
     * @param n int整型 
     * @return ListNode类
     */
    ListNode* reverseBetween(ListNode* head, int m, int n) {
        if(m == n) return head;
        ListNode* dummyhead = new ListNode(-1);
        dummyhead->next = head;

        //写法1
        /*//反转链表的前部分
        ListNode* start = dummyhead;
        for(int i=1; i<m; i++)
            start = start->next;//结点1
        cout << "start: "<< start->val <<endl;
        
        //反转链表的尾巴 第n个结点
        ListNode* right = start->next;
        for(int i=m; i<n; i++)
            right = right->next;//结点4
        cout << "right: "<< right->val <<endl;

        //反转链表的头尾
        ListNode* left = start->next;//2
        ListNode* end = right->next;//5
        
        //切断 left 1 2 3 4
        start->next = nullptr;
        right->next = nullptr;
        reverlist(left);

        //接回原来的链表
        start->next = right;//1->4
        left->next = end;//2->5
        return dummyhead->next;*/

        //写法2
        ListNode* pre = dummyhead;
        ListNode* cur = head;
        
        //找到结点m
        for(int i=1; i<m; i++)
        {
            pre = cur;//m-1
            cur = cur->next;//m
        }
        //从m到n反转 依次断掉指向后续的指针，反转指针方向
        ListNode* temp;
        for(int i=m; i<n; i++)
        {
            temp = cur->next;//要反转的结点
            cur->next = temp->next;//指向n
            temp->next = pre->next;//反转
            pre->next = temp;//指向m
        }
        return dummyhead->next;

    }
    void reverlist(ListNode* node)
    {
        ListNode* pre = nullptr;
        ListNode* cur = node;
        ListNode* temp;
        while(cur)
        {
            temp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = temp;
        }
    }
};

BM3 链表中的节点每k个一组翻转

在这里插入图片描述
自己写的乱七八糟，看了解答之后觉得好聪明啊，关键是要找到反转前的局部链表的尾巴，这个也是要返回的链表头，然后建立每一组的连接！！

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        //每一组局部链表的表头 反转前局部链表的尾巴 
        ListNode* tail = head;
        //找到尾巴
        for(int i=0; i<k; i++)
        {
            //如果链表不够长 返回结果
            if(tail == nullptr) return head;
            tail = tail->next;
        }

        //反转局部链表
        ListNode* pre = nullptr;
        ListNode* cur = head;
        ListNode* temp;
        //在到达当前段尾节点前
        while(cur != tail)
        {
            temp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = temp;
        }

        //反转后链表尾部连接下一组表头
        head->next = reverseKGroup(tail, k);
        return pre;
    }
};

模拟的写法，将一条链表分为链表长度/k块链表，如果处不尽则说明后面会有剩下的那一块是不满长度为k的。
最初需要定义虚拟表头dummyhead（最终结果）和局部链表的反转前的表头start。然后遍历每一组局部链表，并反转。反转后需要将start与反转后的局部链表头pre连接（反转前局部链表的尾部），再更新下一组的局部链表的表头，也就是将start更新到最前。

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        if(k<=1) return head;
        if(head == nullptr) return nullptr;

        int len = getLength(head);
        int part = len / k;//分组

        ListNode* dummyhead = new ListNode(-1);
        ListNode* start = dummyhead;//每一组局部链表的表头
        for(int i=0; i<part; i++)
        {
            //局部链表反转后的尾巴
            ListNode* pre = nullptr;
            for(int j=0; j<k; j++)
            {
                ListNode* temp = head->next;
                head->next = pre;
                pre = head;
                head = temp;
            }
            start->next = pre;//链表头连接 反转后的局部链表 的表头
            while(start->next) start = start->next;//更新下一组的表头
        }
        start->next = head;
        return dummyhead->next;

    }
private:
    //获取链表长度
    int getLength(ListNode* node)
    {    
        int len = 0;
        if(node == nullptr) return len;
        while(node)
        {
            len++;
            node = node->next;
        }
        return len;
    }
};

BM4 合并两个排序的链表

在这里插入图片描述

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    ListNode* Merge(ListNode* pHead1, ListNode* pHead2) {
        if(!pHead1 && !pHead2) return nullptr;
        if(!pHead1) return pHead2;
        if(!pHead2) return pHead1;

        ListNode* dummyhead = new ListNode(-1);
        ListNode* cur = dummyhead;
        while(pHead1 && pHead2)
        {
            if(pHead1->val <= pHead2->val)
            {
                cur->next = pHead1;
                pHead1 = pHead1->next;//1->2
                //cout << "   cur:" << cur->next->val << "  pHead1:" << pHead1->val << endl;
            }
            else if(pHead1->val > pHead2->val)
            {
                cur->next = pHead2;
                pHead2 = pHead2->next;
                //cout << "   cur:" << cur->next->val << "  pHead2:" << pHead2->val << endl;
            }
            cur = cur->next;//连接新链表
        }
        //如果还有剩下的结点 单独处理最后一个结点
        cur->next = (pHead2 == nullptr) ? pHead1 : pHead2;
        return dummyhead->next;
    }
};

方法2，取较小的结点

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    ListNode* Merge(ListNode* pHead1, ListNode* pHead2) {
        if(!pHead1 && !pHead2) return nullptr;
        if(!pHead1) return pHead2;
        if(!pHead2) return pHead1;
        ListNode* dummyhead = new ListNode(-1);
        ListNode* cur = dummyhead;
        while(pHead1 && pHead2)
        {
            if(pHead1->val > pHead2->val) swap(pHead1, pHead2);
            cur->next = pHead1;//建立新连接
            pHead1 = pHead1->next;//更新
            cur = cur->next;//更新
        }
        cur->next = (pHead2 == nullptr) ? pHead1 : pHead2;
        return dummyhead->next;
    }
};

BM5 合并k个已排序的链表

在这里插入图片描述

这个写法会把负数的结点吞掉，例如输入：[{-5},{-9,-8,-7,-5,1,1,1,3},{-10,-7,-6,-6,-6,0,1,3,3},{-10,-8,-7,-2,3,3},{-1,4},{-5,-4,-1}]，输出是{-5,0,1,1,1,1,3,3,3,3,3,4}

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        // write code here
        ListNode* dummyhead = new ListNode(-1);
        dummyhead->next = lists[0];
        ListNode* cur = dummyhead;
        for(int i=1; i<lists.size();)
        {
            cur->next = mergeList(lists[i], lists[i+1]);
            cur = cur->next;
            i += 2;
        }
        return dummyhead->next;
    }
    ListNode* mergeList(ListNode* head1, ListNode* head2)
    {
        if(head1 == nullptr) return head2;
        if(head2 == nullptr) return head1;
        ListNode* dummyhead =  new ListNode(0);
        ListNode* cur = dummyhead;
        while(head1 && head2)
        {
            if(head1->val >= head2->val) swap(head1, head2);
            cur->next = head1;
            head1 = head1->next;
            cur = cur->next;
        }
        cur->next = (head1 == nullptr) ? head2 : head1;
        return dummyhead->next;
    }

};

加入并归排序后的，可以输出负数结点了

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        return divideMerge(lists, 0, lists.size()-1);
    }
    //划分合并区间函数
    ListNode* divideMerge(vector<ListNode *> &lists, int left, int right){
        if(left > right)
            return NULL;
        //中间一个的情况
        else if(left == right)
            return lists[left];
        //从中间分成两段，再将合并好的两段合并
        int mid = (left + right) / 2;
        return mergeList(divideMerge(lists, left, mid), divideMerge(lists, mid + 1, right));
    }
    ListNode* mergeList(ListNode* head1, ListNode* head2)
    {
        if(!head1 && !head2) return nullptr;
        if(head1 == nullptr) return head2;
        if(head2 == nullptr) return head1;
        ListNode* dummyhead =  new ListNode(0);
        ListNode* cur = dummyhead;
        while(head1 && head2)
        {
            if(head1->val >= head2->val) swap(head1, head2);
            cur->next = head1;
            head1 = head1->next;
            cur = cur->next;
        }
        cur->next = (head1 == nullptr) ? head2 : head1;
        return dummyhead->next;
    }

};

BM6 判断链表中是否有环

判断给定的链表中是否有环。如果有环则返回true，否则返回false。

思路就是，快慢指针同时出发，慢指针走一步，快指针走两步。快指针肯定先进入环，慢指针后入环，如果两个指针相遇说明有环，如果没有相遇，遍历结束说明没有换。

第一次写的时候，有一组很长的链表没有通过，while循环内没有对fast的下一个结点进行判断，可能会一直在循环里边不终止。加了一个判断，如果fast有下一个结点才更新，否则也是说明链表走到头了。又或者是while的判断条件加上fast->next != null

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool hasCycle(ListNode *head) {
        if(head == nullptr || head->next == nullptr) return false;
        ListNode* fast = head;
        ListNode* slow = head;
        while(fast && slow)
        {
            slow = slow->next;
            //下面这个if-else是改正后的写法
            if(fast->next) fast = fast->next->next;
            else return false;
            if(fast == slow) return true;
        }
        return false;//如果fast先遇到null说明没有环
    }
};

BM7 链表中环的入口结点

在这里插入图片描述
上一题是判断有没有环，这个是有环然后要找到环入口。

思路，也是快慢指针。

  • 首先，快慢指针同时出发，慢指针走一步，快指针走两步。快指针肯定先进入环，慢指针后入环，如果两个指针相遇说明有环，如果没有相遇，遍历结束说明没有环。
  • 然后，第一次相遇时，在这个地方，重新定义两个指针，慢指针从头开始走，快指针在换里边走同时移动一步，如果相遇就找到了环入口，否则返回null。

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
        val(x), next(NULL) {
    }
};
*/
class Solution {
public:
    ListNode* EntryNodeOfLoop(ListNode* pHead) {
        if(pHead == nullptr) return nullptr;
        ListNode* fast = pHead;
        ListNode* slow = pHead;
        while(fast!=nullptr && fast->next != nullptr)
        {
            slow = slow->next;
            fast = fast->next->next;
            if(slow == fast)
            {
                slow = pHead;
                ListNode* entrynode = fast;
                while(entrynode)
                {
                    //先判断 有可能就是一个闭环链表
                    if(entrynode == slow) return entrynode;
                    slow = slow->next;
                    entrynode = entrynode->next;
                }
            }
        }
        return nullptr;
    }
};

BM8 链表中倒数最后k个结点

在这里插入图片描述
思路-快慢指针：

  • 首先，快指针先走K步，在这里要注意两个特殊情况，一个是链表不够长，一个是正好需要返回倒数最后一个结点（第一个结点）。
  • 然后，慢指针从头开始，和快指针同时前进，快指针走到链表尾，慢指针走到第k个结点了。
/**
 * struct ListNode {
 *  int val;
 *  struct ListNode *next;
 *  ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
  public:
    ListNode* FindKthToTail(ListNode* pHead, int k) {
        //空链表
        if (pHead == nullptr) return pHead;
        ListNode* fast = pHead;
        while(k--)
        {
            if(fast->next == nullptr && k>0) return nullptr;//链表不够长
            if(fast->next == nullptr) return pHead;//倒数最后一个
            fast = fast->next;
            //cout << "  fast: " << fast->val;
        }
        while(fast)
        {
            pHead = pHead->next;
            fast = fast->next;
        }
        return pHead;
    }
};

BM9 删除链表的倒数第n个节点

在这里插入图片描述
思路在上一题的基础上，在保存一个倒数第K-1个节点，然后逻辑删除就可以了。

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        if(head == nullptr) return head;
        ListNode* fast = head;
        while(n--)
        {
            if(fast->next==nullptr && n>0) return nullptr;
            if(fast->next==nullptr)
            {
                return head->next;//逻辑删除
            }
            cout << "  fast: " << fast->val;
            fast = fast->next;
        }
        ListNode* slow = head;
        ListNode* temp;
        while(fast)
        {
            temp = slow;//倒数第k-1个结点
            slow = slow->next;//倒数第k个结点
            fast = fast->next;
        }
        temp->next = slow->next;
        return head;
    }
};

BM10 两个链表的第一个公共结点

在这里插入图片描述
思路：统计长度，计算长度差len，长的链表先走len步，然后再和短链表一起走，如果两结点相同说明有公共结点。

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
public:
    ListNode* FindFirstCommonNode( ListNode* pHead1, ListNode* pHead2) {
        if(!pHead1 || !pHead2) return nullptr;
		int len1 = getLenofList(pHead1);
		int len2 = getLenofList(pHead2);
		if(len1 < len2)
		{
			swap(pHead1, pHead2);
			swap(len1, len2);	
		}
		int len = len1 - len2;
		while(len--)
		{
			pHead1 = pHead1->next;
		}
		//cout << pHead1->val<<endl;
		while(pHead1)
		{
			if(pHead1 == pHead2) return pHead1;
			pHead1 = pHead1->next;
			pHead2 = pHead2->next;
		}
		return nullptr;
    }
	int getLenofList(ListNode* head)
	{
		int res = 0;
		if(head == nullptr) return res;
		while(head)
		{
			res++;
			head = head->next;
		}
		return res;
	}
};
虚假自律就会真自律！
关注
专栏目录
day2 牛客TOP100：BM 11-20 链表 二分法 流输入 小美加法
UUUUU22的博客
08-29 361
BM11链表相加(二) BM12单链表的排序 BM13 判断一个链表是否为回文结构 BM14链表的奇偶重排 BM15删除有序链表中重复的元素-Ⅰ BM16删除有序链表中重复的元素-Il JZ35复杂链表的复制 BM17二分查找 BM18二维数组中的查找 BM19寻找峰值 BM20数组中的逆序对 流输入 小美加法
day3 牛客TOP100：BM 21-30 二分法 二叉树
UUUUU22的博客
08-30 362
BM21旋转数组的最小数字 BM22比较版本号 力扣-旋转数组的查找 力扣-两个非空链表逆序相加 BM23二叉树的前序遍历 BM24二叉树的中序遍历 BM25二叉树的后序遍历 BM26求二叉树的层序遍历 BM27按之字形顺序打印二叉树 BM28二叉树的最大深度 BM29 二叉树中和为某一值的路径(一) BM30二叉搜索树与双向链表
牛客top100 - 自刷打卡day1 - 链表
m0_50546235的博客
03-19 738
top100自刷打卡
牛客top100 -自刷打卡day2+3 - 二叉树
m0_50546235的博客
03-21 391
day2+3 自刷打卡 - 二叉树
【牛客面试必刷TOP101】Day21.BM11 链表相加(二)和BM12 单链表的排序
未央的博客哟
02-15 863
一、BM11 链表相加(二)题目描述假设链表中每一个节点的值都在 0 - 9 之间，那么链表整体就可以代表一个整数。给定两个这种链表，请生成代表两个整数相加值的结果链表。数据范围：0≤n,m≤1000000，链表任意值 0≤val≤9要求：空间复杂度 O(n)，时间复杂度 O(n)例如：链表 1 为 9->3->7，链表 2 为 6->3，最后生成新的结果链表为 1->0->0->0。示例1：题目解析解题思路：反转链表法（推荐使用）
【牛客面试必刷TOP101】Day3.BM10两个链表的第一个公共结点和BM13判断一个链表是否为回文结构
未央的博客哟
09-09 575
今天是我们第三天的算法题，今天的内容比较简单，一定要能够熟练掌握和运用！！！
牛客面试必刷TOP101——Day1
瓜是西瓜的瓜的博客
05-10 505
前段时间比较懒散，给自己定下的刷题任务只坚持了几点就被我无限期“鸽置”了，希望使用写文章的方式记录解题过程，记录思路。方便自己倒回来看，也方便自己工作之后，晚上emo的时候倒回来看看曾经自己做过的努力和尝试。这个专栏可能会随便一点吧，主要是作为记录，然后才是笔记。大概就是这样。
【牛客面试必刷TOP101】Day22.BM16 删除有序链表中重复的元素-II和BM21 旋转数组的最小数字
未央的博客哟
02-16 421
一、BM16 删除有序链表中重复的元素-II题目描述给出一个升序排序的链表，删除链表中的所有重复出现的元素，只保留原链表中只出现一次的元素。举例说明：示例1：题目解析二、BM21 旋转数组的最小数字题目描述有一个长度为 n 的非降序数组，比如[1,2,3,4,5]，将它进行旋转，即把一个数组最开始的若干个元素搬到数组的末尾，变成一个旋转数组，比如变成了[3,4,5,1,2]，或者[4,5,1,2,3]这样的。请问，给定这样一个旋转数组，求数组中的最小值。示例1：题目解析。
【牛客面试必刷TOP101】Day4.BM15删除有序链表中重复的元素-I和BM17二分查找-I
未央的博客哟
09-13 790
牛客算法题第四天了，一起坚持下去！！！！！！！
编译器、IDE对C/C++新标准的支持
编程语言技巧经验分享
11-08 654
很遗憾的是，微软VC++对C99的支持直到VS2015才基本完全支持，在VS2012之前，仅仅支持C89. 也正是2015年之前，这么多人骂微软并纷纷转移到其它C语言编译器的原因。VS2019开始才正式宣布支持C11/C17.对于C++标准，VS2013开始支持C++11，VS2017支持C++17, VS2019支持C++20, 显然，微软更偏爱C++.
GitLab 提交 C++ 技巧
nbspzs的专栏
11-08 73
在 GitLab 中提交 C++ 代码时，通常应只提交 源代码文件（例如 .cpp、.h）和 CMake 配置文件（例如 CMakeLists.txt），而不要提交通过 CMake 编译后的中间文件或构建产物。这样，当其他开发者克隆你的项目后，他们可以在自己的机器上使用 cmake 构建项目，而不需要下载编译产物。2. 跨平台兼容性：不同的开发者和平台可能会生成不同的编译产物，提交这些文件会造成不必要的冲突和问题。1. 在 .gitignore 文件中忽略编译生成的文件和目录。
C++builder中的人工智能（15）：C++高斯误差线性单元（GELU）
最新发布
caridle的专栏
11-08 359
激活函数（phi()），也称为转移函数或阈值函数，它根据净输入函数的给定值（sum）确定激活值（a = phi(sum)）。在这里，sum是它们权重中的信号之和，激活函数是这个和的新值，具有给定的函数或条件。换句话说，激活函数是将所有加权信号的和转换为该信号的新激活值的方法。有不同类型的激活函数，通常使用的是线性（恒等）、双极性和逻辑（sigmoid）函数。在C++（以及大多数编程语言）中，你可以创建自己的激活函数。注意，sum是净输入函数的结果，它计算所有加权信号的和。我们将使用这些作为输入函数的结果。
2024年华为OD机试真题-查找充电设备-C++-OD统一考试（E卷）
面试高手的博客
11-08 16
某个充电站，可提供n个充电设备只，每个充电设备均有对应的输出功率任意个充电设备组合的输出功率总和，均构成功率集合P的1个元素功率集合P的最优元素，表示最接近充电站最大输出功率pmax 的元素。每一题都含有详细的解题思路和代码注释，精编c++、JAVA、Python三种语言解法。当充电设备输出功率50、20、20组合时，其输出功率总和为90，最接近充电站最大充电输出功率，因此最优元素为90。所有充电设备的输出功率组合，均大于充电站最大充电输出功率30，此时最优元素值为0。第 2 行为每个充电设备的输出功率。
每日OJ题_牛客_相差不超过k的最多数_滑动窗口_C++_Java
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
11-04 402
每日OJ题_牛客_相差不超过k的最多数_滑动窗口_C++_Java（排序容易想，但是滑动窗口不容易想到，核心思想：使用滑动窗口算法通过动态调整窗口的大小，遍历所有符合条件的连续子序列，求得最大连续子序列的长度。）
算法|牛客网华为机试31-40C++
奇树谦的博客
11-04 724
计算第5次落地后球经过的距离，除了第一次只经过一次，所以距离最后在减去初始长度，高度每次减去一半。for循环遍历一次，从后往前，如果是字符组成单词等遇到空格或者非字母输出。直接用sort函数就是按着ASCII码从小到大排序的。找每行每列的相加差1的数学规律，再每行输出。
C++ 编程基础（4）函数 | 4.1、函数概述
个人技术博客
11-04 227
在C++中，函数通过函数定义来创建，其语法包括返回类型、函数名、参数列表（可选）和函数体。函数指针是指向函数的指针变量。因此函数指针本质上是一个指针变量，只不过该指针变量指向函数。C/C++中，每一个函数都有一个入口地址，函数指针就指向函数的入口地址，可以通过函数指针来调用函数。return 0;// pfnFunc保存的就是func函数地址，pfnFunc与func值是一样的return 0;输出结果0040135000401350。
c++ 分治算法
www_dong的博客
11-08 650
分治算法是一种重要的算法设计范式，其核心思想是将一个复杂的问题分解为多个规模较小的相同问题，逐步解决这些较小的问题，最后将这些问题的解合并成原问题的解。
C语言 流程控制语句
2201_75297369的博客
11-05 484
时间：2024.11.5。
C++面向对象高级开发（C++2.0）
Oafz的博客
11-06 497
autoLambdasUnordered容器arraytupleRegEx。
C++牛客题库项目：高效学习与练习平台设计
资源摘要信息:"基于C++的牛客题库设计源码" 本项目是一个基于C++语言开发的牛客题库系统，旨在提供一个集成多种编程问题及其解决方案的学习和练习平台。通过对源码的分析，可以提炼出以下知识点和相关技术细节。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值