【每日两题集合】Easy难度的8道经典题目（C++）

本文链接：https://blog.youkuaiyun.com/DL_wly/article/details/90744593

本文汇总了8道C++实现的简单级别算法题目，包括反转字符串、二叉树最大深度、查找只出现一次的数字、Fizz Buzz问题、反转链表、移动零、删除链表重复节点及求众数。每道题目均提供了问题描述和示例，适合初学者巩固基础。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

前几天太忙了，没有刷题。今天补一下儿童节之前的题目吧。都是easy难度的经典题目。

344、反转字符串

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。

不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。

class Solution {
public:
    void reverseString(vector<char>& s) {
        int l = 0, r = s.size()-1;
        while(l<r) {
            char temp = s[l];
            s[l] = s[r];
            s[r] = temp;
            l++;r--;
        }
    }
};

104、二叉树的最大深度

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

示例：
给定二叉树 [3,9,20,null,null,15,7]，返回它的最大深度 3 。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int maxDepth(TreeNode* root) {
        if(root==NULL)  return 0;
        return max(maxDepth(root->left),maxDepth(root->right))+1;
    }
};

136、只出现一次的数字

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

说明：你的算法应该具有线性时间复杂度。你可以不使用额外空间来实现吗？

示例 1:

输入: [2,2,1]
输出: 1

示例 2:

输入: [4,1,2,1,2]
输出: 4

class Solution {
public:
    int singleNumber(vector<int>& nums) {
        int res = 0;
        for(int i=0; i<nums.size(); i++) {
            res ^= nums[i];
        }
        return res;
    }
};

412、Fizz Buzz

写一个程序，输出从 1 到 n 数字的字符串表示。

1. 如果 n 是3的倍数，输出“Fizz”；

2. 如果 n 是5的倍数，输出“Buzz”；

3.如果 n 同时是3和5的倍数，输出 “FizzBuzz”。

class Solution {
public:
    vector<string> fizzBuzz(int n) {
        vector<string> res;
        for(int i=1; i<=n; i++) {
            if(i%15 == 0)
                res.push_back("FizzBuzz");            
            else if(i%3 == 0)
                res.push_back("Fizz");
            else if(i%5 == 0)
                res.push_back("Buzz");
            else
                res.push_back(to_string(i));
        }
        return res;
    }
};

206、反转链表

反转一个单链表。

示例:

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head==NULL || head->next==NULL)  return head;
        ListNode* pre = NULL;
        ListNode* cur = head;
        ListNode* lat = head->next;
        while(lat) {
            cur -> next = pre;
            pre = cur;
            cur = lat;
            lat = lat -> next;
        }
        cur -> next = pre;
        return cur;
    }
};

283、移动零

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int i=0, j=0;
        for(int i=0; i<nums.size(); i++) {
            if(nums[i]!=0) {
                nums[j] = nums[i];
                j++;
            }
        }
        while(j < nums.size()){
            nums[j] = 0;
            j++;
        }
    }
};

237、删除链表中的重复节点

class Solution {
public:
    void deleteNode(ListNode* node) {
        node -> val = node -> next -> val;
        node -> next = node -> next -> next;
    }
};

169、求众数

给定一个大小为 n 的数组，找到其中的众数。众数是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素。

你可以假设数组是非空的，并且给定的数组总是存在众数。

示例 1:

输入: [3,2,3]
输出: 3

示例 2:

输入: [2,2,1,1,1,2,2]
输出: 2

class Solution {
public:
    int majorityElement(vector<int>& nums) {
        int cnt = 1;
        int temp = nums[0];
        for(int i=1; i<nums.size(); i++) {
            if(nums[i] == temp)
                cnt++;
            else
                cnt--;
            if(cnt==0){
                cnt = 1;
                temp = nums[i];
            }
        }
        return temp;
    }
};