C++相关练习及详细讲解

已于 2024-03-12 15:25:12 修改
阅读量294 收藏 1
点赞数
分类专栏： 练习 文章标签： c++ 算法 习题
于 2023-11-05 17:36:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_49619206/article/details/134230556
版权

目录

面试榜单

NC65 斐波那契数列

题目描述：
在这里插入图片描述

分析：
使用递归求解，当输入参数等于1、2时返回整数1

class Solution {
public:
    int Fibonacci(int n) {
        if(n == 1 || n == 2)
        {
            return 1;
        }
        return Fibonacci(n-1) + Fibonacci(n-2);
    }
};

NC103 反转字符串

题目描述：
在这里插入图片描述

分析：
使用string迭代器逆向打印存入字符串返回

#include<string>
class Solution {
public:
    string solve(string str) {
        string s;
        string::reverse_iterator rit = str.rbegin();
        while(rit != str.rend())
        {
            s.push_back(*rit);
            ++rit;
        }
        return s;
    }
};

NC4 判断链表中是否有环

在这里插入图片描述

分析：
定义两个指针一开始都指向头节点，区别在于步长不同，一快一慢。
slow 指针每次向后移动一个位置，而fast 指针向后移动两个位置。如果链表中存在环，则 fast 指针最终将再次与 slow 指针在环中相遇。
如果不存在环，则fast指针会指向nullptr，则返回false

class Solution {
public:
    int Fibonacci(int n) {
        if(n == 1 || n == 2)
        {
            return 1;
        }
        return Fibonacci(n-1) + Fibonacci(n-2);
    }
};
————————————————
版权声明：本文为CSDN博主「halooy」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/m0_49619206/article/details/134290089

NC141 判断是否为回文字符串

题目描述：
在这里插入图片描述

分析：
先找到首字符strat和最后一个字符end的位置
然后进行比较，如果不相等直接返回false
如果相等，则++start，–end
当start大于等于end时，则正常结束，跳出循环，返回true

class Solution {
public:
    bool judge(string str) {
        //首字符索引
        char start = 0;
        //最后一个字符索引
        char end = str.size()-1;
        while(start < end)
        {
            if(str[start] != str[end])
            {
                return false;
            }
            ++start;
            --end;
        }
        return true;
    }
};

NC151 最大公约数

题目描述：
在这里插入图片描述

分析：
定义一个变量tmp用来存储a，b中较小的数。
然后用a，b对tmp进行取余，如果有余数，则对tmp进行–操作。
直到被a，b两数整除则为a，b的最大公约数。返回该值。

class Solution {
public:
    int gcd(int a, int b) {
        int tmp = (a>b)? b:a;
        while(tmp)
        {
            if(a%tmp == 0 && b%tmp == 0)
            {
                return tmp;
            }
            --tmp;
        }
        return 1;
    }
};

NC7 买卖股票的最好时机(一)

题目描述：
在这里插入图片描述

分析1（动态规划）：

思路：对于每一天都有两个状态：到此为止的最大收益和是否持股。
因此用：
dp[i][0]表示第i天不持股到该天为止的最大收益，
dp[i][1]表示第i天持股，到该天为止的最大收益。
然后对于之后的每一天，都根据前一天的情况进行赋值。
如果当天不持股，有可能是前面的若干天中卖掉了或是还没买，因此到此为止的总收益和前一天相同，也有可能是当天才卖掉；
如果当天持股，有可能是前面若干天中买了股票，当天还没卖，因此收益与前一天相同，也有可能是当天买入，此时收益为负的股价。

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = prices.size();
        vector<vector<int>> dp(n, vector<int>(2, 0));
        //第一天不持股收益
        dp[0][0] = 0;
        //第一天持股收益
        dp[0][1] = -prices[0];

        for(int i = 1; i < n; ++i)
        {
            //第i天不持股最大收益：
            //1.前一天也不持股，前几天卖掉或者没买，收益和前一天相同
            //2.前一天持股，第i天当天抛出，收益为前一天持股加上当天抛出
            dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i]);
            //第i天持股最大收益：
            //1.前一天不持股，第i天当天买入，收益为当天买入价格的负数
            //2.前一天持股，收益和前一天相同
            dp[i][1] = max(-prices[i], dp[i-1][1]);
        }
        //最后一天不持股，到改天为止的最大收益
        return dp[n-1][0];
    }
};

分析2(贪心思想):
思路：如果在某一天卖出了股票，那么要想收益最高，一定是它前面价格最低的那天买入的股票才可以。因此可以利用贪心思想解决，每次都将每日收入与最低价格相减维护最大值。
将第一天看成价格最低，后续遍历的时候遇到价格更低则更新价格最低。
每次都比较最大收益与当日价格减去价格最低的值，选取最大值作为最大收益。

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param prices int整型vector 
     * @return int整型
     */
    int maxProfit(vector<int>& prices) {
        // write code here
        int n = prices.size();
        if(n == 0)
            return 0;
        //最大收益
        int maxProfit;
        //当天最大收益
        int max_td;
        //截至当天最低价格，将第一天看作价格最低
        int lessPrice = prices[0];
        //买入必须是卖出前一天
        maxProfit = 0;
        for(int i = 1; i < n; ++i)
        {
            //第i天的最大收益，当天价格减去先前最低价格
            max_td = prices[i]-lessPrice;
            //如果第i天的最大收益比之前的大，则更新最大收益
            maxProfit = max(maxProfit, max_td);
            //如果先前最低价格大于第i天的价格，则更新最低价格
            //由于买入必须是卖出前一天，因此先计算第i天的最大收益后再更新最低价格
            lessPrice = min(lessPrice, prices[i]);
        }
        return maxProfit;
    }
};

NC9 二叉树中和为某一值的路径(一)

题目描述：
在这里插入图片描述

分析1(递归)：
从根节点遍历到叶子，在根节点每次往下一层的时候，将sum减去节点值，最后检查是否完整等于0。

终止条件： 每当遇到节点为空，意味着过了叶子节点，返回。每当检查到某个节点没有子节点，它就是叶子节点，此时sum减去叶子节点值刚好为0，说明找到了路径。
返回值： 将子问题中是否有符合新目标值的路径层层往上返回。
本级任务： 每一级需要检查是否到了叶子节点，如果没有则递归地进入子节点，同时更新sum值减掉本层的节点值。

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 *	TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @param sum int整型 
     * @return bool布尔型
     */
    bool hasPathSum(TreeNode* root, int sum) {
        // write code here
        if(root == nullptr)
            return false;
        if(root->left == nullptr && root->right == nullptr && sum-root->val == 0)
            return true;

        return hasPathSum(root->left,sum-root->val) || hasPathSum(root->right,sum-root->val);
    }
};

分析2(深度优先搜索dfs):
首先检查空间点，空树没有路径；
栈每次保存一个pair类型数据，包含两个值，一个值记录节点，一个值记录到该节点位置的路径和；
遍历过程中，每次弹出栈顶元素，判断是否是叶子节点并且路径和是否等于目标值；
没有到叶子节点就将左右子节点（如果有）加入栈中，并跟随加入路径和；
如果遍历结束也没有找到路径和，则该二叉树中没有。

/**
 * struct TreeNode {
 *  int val;
 *  struct TreeNode *left;
 *  struct TreeNode *right;
 *  TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
#include <cstdio>
class Solution {
  public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param root TreeNode类
     * @param sum int整型
     * @return bool布尔型
     */
    bool hasPathSum(TreeNode* root, int sum) {
        // write code here
        if (root == nullptr)
            return false;
        //建立栈
        stack<pair<TreeNode*, int>> s;
        //将根节点及根节点的值压入
        s.push({root, root->val});
        while (!s.empty()) 
        {
            //给栈顶元素赋值
            auto temp = s.top();
            //去除栈顶元素
            s.pop();
            //如果栈顶元素的左右子树都空，并且累加值等于sum则返回true
            if (temp.first->left == nullptr && temp.first->right == nullptr && temp.second == sum) 
            {
                return true;
            }
            //如果左子树非空，则将左子树压入，并将左子树的值进行累加
            if (temp.first->left != nullptr) 
            {
                s.push({temp.first->left, temp.second + temp.first->left->val});
            }
            //如果右子树非空，则将右子树压入，并将右子树的值进行累加
            if (temp.first->right != nullptr) 
            {
                s.push({temp.first->right, temp.second + temp.first->right->val});
            }
        }
        return false;
    }
};

NC11 将升序数组转化为平衡二叉搜索树

题目描述：
在这里插入图片描述

分析(递归)：
返回值为当前节点为根节点的平衡二叉树；
由于给定一个升序数组，递归函数的参数应为数据的左右边界；
根节点数值应为给定边界的中点的值；
递归左右子树建树。

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 *	TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param nums int整型vector 
     * @return TreeNode类
     */
     TreeNode* dfs(vector<int>& nums, int left, int right)
     {
        //结束条件：
        if(left > right)
            return nullptr;
        //定义数据中间位置：即根节点
        int mid = (left + right + 1)/2;
        //根据mid值创建根节点
        TreeNode* root = new TreeNode(nums[mid]);
        //遍历左子树
        root->left = dfs(nums, left, mid-1);
        //遍历右子树
        root->right = dfs(nums, mid+1, right);

        return root;
     }
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        // write code here
        int len = nums.size();
        return dfs(nums, 0, len-1);
    }
};

others

输出数组中第k小的数

题目描述：
给定一个数组arr 输出数组中第k小的数
如果不存在 输出-1
输入格式：
第一行输入一个数字n 代表数组arr大小
第二行依次输入n个数
第三行输入一个数字k
输出格式：
输出数组中第k小的数 如果不存在 输出-1
测试样例：
在这里插入图片描述

分析：
根据set容器去重的特性以及set容器内部按照从小到大的顺序排列
将数组内所有元素输入到set容器内，然后对set迭代器进行遍历，如果遍历到第k个元素存在则存在第k小的数，进行输出；如果不存在，也就是迭代器到end的位置，则输出-1。

举例：
数组元素：3 3 2
set容器：2 3
如果k=2，则输出3
如果k=3，此时set迭代器遍历到end()的位置，不存在该数据，则输出-1

#include<iostream>
#include<set>

using namespace std;
int main()
{
	//数组大小
	int n;
	//定义第k小的数
	int kmin;
	cin >> n;
	int *arr = new int[n];
	//给数组元素传值
	for (int i = 0; i < n; ++i)
	{
		cin >> arr[i];
	}
	//数组传入set容器
	set<int> s(arr, arr + n);
	cin >> kmin;
	//用来记录遍历位置
	int count = 1;
	set<int>::iterator it = s.begin();

	while (it != s.end())
	{
		//如果第k小的数存在则输出该值，跳出循环
		if (count == kmin)
		{
			cout << *it;
			break;
		}
		++it;
		++count;
	}
	//如果循环正常结束，则第k个值不存在，输出-1
	if (it == s.end())
	{
		cout << -1 << endl;
	}
	delete[] arr;

	return 0;
}

在数组内找出查找数字在该数组第一次出现的索引

题目描述
给定一个长度为N的单调不递减整数数组 arr，进行Q次询问。对于每次询问，给出一个整数X，要求找出X在arr中第一次出现的下标，如果X未在数组中出现过，则输出-1。
输入格式
第一行输入两个整数N,Q 其中N 代表数组 arr 长度，Q代表询问次数
第二行输入N个整数 用空格分开
第三行输入Q个整数 用空格分开
输出格式
在一行中输出Q次查询的结果 每个整数用空格分开

分析：
用三个数组分别记录要查询的值，被查询的值，值在给定数组的索引。
首先给出最简单遍历的方法，该方法时间复杂度较高

int main()
{

    int n,q;
    cin >> n >> q;
    //数组元素放入arr
    int* arr = new int[n];
    for(int i = 0; i < n; ++i)
    {
        cin >> arr[i];
    }
    
    //查询元素放入arr_q
    int* arr_q = new int[q];
    for(int i = 0; i < q; ++i)
    {
        cin >> arr_q[i];
    }
	//查询结果放入result
    int* result = new int[q];
    for(int i = 0; i < q; ++i)
    {
        int Q = arr_q[i];
        int idx = -1;
        for(int j = 0; j < n; ++i)
        {
            if(arr[j] == Q)
            {
                idx = j;
                break;
            }
        }
        result[i] = idx;
    }

    for(int i = 0; i < q; ++i)
    {
        cout << result[i] << " ";
    }
    cout << endl;
    
	delete[] arr;
    delete[] arr_q;
    delete[] result;
	return 0;
}

方法二：
上述方法在面对数据量大时时间复杂度过高，可以使用二分查找降低查询次数。

#include<iostream>

using namespace std;

int binarySearch(int* arr, int n, int Q)
{
    int left = 0;
    int right = n - 1;
    int idx = -1;

    while(left <= right)
    {
        int mid = (right + left)/2;
        if(arr[mid] == Q)
        {
            idx = mid;
            right = mid - 1;
        }
        else if(arr[mid] > Q)
        {
            right = mid - 1;
        }
        else if(arr[mid] < Q)
        {
            left = mid + 1;
        }
    }
    return idx;
}

int main()
{

    int n,q;
    cin >> n >> q;
    //数组元素放入arr
    int* arr = new int[n];
    for(int i = 0; i < n; ++i)
    {
        cin >> arr[i];
    }
    
    //查询元素放入arr_q
    int* arr_q = new int[q];
    for(int i = 0; i < q; ++i)
    {
        cin >> arr_q[i];
    }

    int* result = new int[q];
    for(int i = 0; i < q; ++i)
    {
        int Q = arr_q[i];
        int idx = binarySearch(arr, n, Q);
        result[i] = idx;
    }

    for(int i = 0; i < q; ++i)
    {
        cout << result[i] << " ";
    }
    cout << endl;
    
    delete[] arr;
    delete[] arr_q;
    delete[] result;

    return 0;
}

计算每个节点的字数包含节点数

题目描述
给定一棵以1为根，包含N个节点的树，每个节点都有一个唯一的编号。请计算每个节点的子树中包含的节点数，包括节点本身。
输入格式
第一行包含一个正整数n，表示树的节点个数。
接下来的n-1行，每行包含一个正整数p，表示节点i的父节点的值。
输出格式
n个整数，每个整数用空格分开
第i个数为节点i的子节点个数（包括他自己）
在这里插入图片描述
在这里插入图片描述

分析：
通过建立二维数组
第一维存储树的每个节点
第二维存放每个节点的子节点
通过遍历树的节点来解决，统计每个节点的子节点数（包括自身）。使用深度优先搜索（DFS）算法。

#include<iostream>
#include<vector>

using namespace std;
//存储每个节点
vector<vector<int>> tree;
//存储每个节点及其子树的个数
vector<int> subtree_size;

void dfs(int node)
{
    subtree_size[node] = 1;

    for(int child : tree[node])
    {
        dfs(child);
        subtree_size[node] += subtree_size[child];
    }
}

int main()
{
    //树的节点个数
    int n;
    cin >> n;
    //存储每个节点
    tree.resize(n+1);
    //存储每个节点及其子树的个数
    subtree_size.resize(n+1);

    int parent;
    for(int i = 2; i <= n; ++i)
    {
        cin >> parent;
        tree[parent].push_back(i);
    }

    dfs(1);

    for(int i = 1; i <= n; ++i)
    {
        cout << subtree_size[i] << " "; 
    }
    cout << endl;

    return 0;
}
halooy
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++考试题库及答案.pdf
02-26
，
企业发放的奖金根据利润提成。利润低于或等于100000元的，奖金可提10%； 利润高于100000元，低于200000元（100000＜I≤200000）时，低于100000元的部分按10％提成，高于
Alive_lei的博客
01-29 3968
企业发放的奖金根据利润提成。利润低于或等于100000元的，奖金可提10%; 利润高于100000元，低于200000元（100000<I≤200000）时，低于100000元的部分按10％提成，高于100000元的部分，可提成 7.5%; 200000<I≤400000时，低于200000元部分仍按上述办法提成，（下同），高于200000元的部分按5％提成； 400000<I≤600000元时，高于400000元的部分按3％提成； 600000<I≤1000000时，高于60000
C++经典150题
最新发布
RuanJian_GC的博客
06-11 1529
时间复杂度为 O((m+n)log(m+n)) （快速排序–对数级时间复杂度）返回你可以从这笔交易中获取的最大利润。你不需要考虑数组中超出新长度后面的元素。你可以假设数组是非空的，并且给定的数组总是存在多数元素。，返回其中的多数元素。设计一个算法来计算你所能获取的最大利润。数组中的每个元素代表你在该位置可以跳跃的最大长度。** 删除重复出现的元素，使得出现次数超过两次的元素。并在使用 O(1) 额外空间的条件下完成。不要使用额外的数组空间，你必须仅使用。** 删除重复出现的元素，使每个元素。
C++题库
shiqifei的博客
10-11 1万+
C++知识点题库
C++期末考试选择题题库100道
m0_63947712的博客
12-15 2万+
1. 对于常数据成员，下面描述正确的是 【 B 】 A. 常数据成员必须被初始化，并且不能被修改 B. 常数据成员可以不初始化，并且不能被修改 C. 常数据成员可以不初始化，并且可以被修改 D. 常数据成员必须被初始化，并且可以被修改 2. 在C++中，使用流进行输入输出，其中用于定义文件输入流对象的类是 【 B 】 A. ios B. ifstream C. ofstream D. istrstream 3. 下列关于异常的叙述错误的是【D 】 A. 只要是编程者认为是异常的都
C++经典练习题（30题带答案）
weixin_72986432的博客
08-23 1万+
1.定义一个学生结构体student，包括学生的学号、姓名、性别、出生日期。出生日期包括年月日。编写程序输出一个学生的所有信息。 2.输入一个字符，如果该字符是英文字母，则打印该英文字母的ASCII码。要求可以输入任意字符。 3.编写程序将成绩分数的百分制转换为等级制，即 A(分数≥90)、B(90>分数≥80)、C(80>分数≥70)、D(70>分数≥60)、E(分数<60)五等。 4.已知一个student结构体，请编写主函数，为stud
C++学习练习 C++资源
07-27
在cpp-master这个资源中，可能包含了各种练习题、示例代码、项目案例和讲解文档，可以帮助学习者深入理解上述知识点，并通过实践提升编程技能。同时，持续关注C++的新特性，如C++11、C++14、C++17、C++20等标准带来...
c++实战练习.zip
12-26
以下是对这些关键知识点的详细解释： 1. **重载（Overloading）**： C++中的函数重载允许我们在同一个作用域内定义多个同名函数，但每个函数的参数列表必须不同（数量、类型或顺序）。这提供了代码的多态性和易用...
9年全国计算机二级C++笔试练习.doc
07-10
下面是对这些知识点的详细解释： 1. 数据结构： - 链式存储结构：在C++中，链表是一种非顺序存储结构，它可以动态地分配和释放内存，适用于存储结构复杂、大小不固定的集合。循环链表是链表的一种变体，它允许元素...
C++编程练习题及答案.doc
10-07
C++编程练习题及答案 本资源是一个C++编程练习题集，包含六个编程练习题，每个题目都提供了完整的代码实现和解释。本资源适合C++初学者和中级开发者，旨在帮助他们提高编程技能和解决问题的能力。 知识点一：编程...
关于C语言和C++的详细解释.zip
06-25
文件"**c-and-c-in-simple-terms-master**"可能是一个教程或项目，它可能包含关于C和C++基础知识的讲解、示例代码、练习和解答。通过学习这些材料，开发者可以深入理解这两种语言的语法、编程原则以及如何在实际项目...
c++的练习
m0_69388510的博客
04-27 3460
c++个人练习记录
CPP----C++练习100题
writ的博客
02-02 7062
C++练习题
30道C++ 基础高频题整理（附答案背诵版）
帅地
12-17 4034
是C++的一个关键字，用于为现有的类型创建一个新的名称（别名）。，那么sizeof(arr)将返回10（因为arr是一个10个字符的数组，每个字符占用1个字节），而strlen(arr)将返回5（因为字符串"hello"的长度是5，不包括终止的空字符）。例如，如果你正在开发一个需要直接访问硬件，或者需要高性能数学计算的应用（比如游戏，图形渲染，科学计算），C++可能是一个更好的选择。通过指针和引用，你可以直接操作内存，这在很多情况下都非常有用，例如，动态内存分配，函数参数传递，数据结构（如链表和树）等等。
C++入门项目必练100题
热门推荐
m0_58054832的博客
01-14 2万+
C++入门练手项目，c++小白快速入门，c++基础项目
C++试题及答案
别逗了好么
06-28 1万+
一、 选择题（每小题1.5分，合计25分） 1、 C++对C语言作了很多改进，下列描述中（　）使得C语言发生了质变，从面向过程变成了面向对象。 A、增加了一些新的运算符； B、允许函数重载，并允许设置缺省参数； C、规定函数说明必须用原型； D、引进了类和对象的概念； 2、 所谓数据封装就是将一组数据和与这组数据有关操作组装在一起，形成一个实体，这实体也就是( )。 A.类 B.
50个C/C++面试题
沙漠中的一粒沙
04-11 1万+
面试题1：变量的声明和定义有什么区别  为变量分配地址和存储空间的称为定义，不分配地址的称为声明。一个变量可以在多个地方声明，但是只在一个地方定义。加入extern修饰的是变量的声明，说明此变量将在文件以外或在文件后面部分定义。  说明：很多时候一个变量，只是声明不分配内存空间，直到具体使用时才初始化，分配内存空间，如外部变量。  面试题2：写出bool 、int、 float、
C++编程最基础练习题(1-10) 小白入门必刷
weixin_46324814的博客
11-27 1万+
50道C++编程练习题 小白记录学习C++的过程~
【C++ 程序设计】实战：C++ 数据类型实践练习题（常量、变量）
顾三殇 —— 博客空间（软件测试）
07-29 1258
数据类型：① 常量：定义、字符常量、有名常量、分数与排名、价格统计、平均分；② 变量：定义、初始化、有符号整型变量、无符号整型变量、实型变量、字符型变量、参数传递、格式说明符、字节数统计、浮点数 float 的最小/大值
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值