leetcode 精选面试题2 c++

已于 2022-05-23 22:26:34 修改
阅读量520 收藏 1
点赞数 1
CC 4.0 BY-SA版权
分类专栏： leetcode记录 文章标签： leetcode c++ 算法
于 2022-05-21 16:29:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/l7_______/article/details/124899948
本文介绍了多种字符串处理的算法实现，包括删除相邻重复项、各位相加、反转元音字母、一次编辑距离、泰波那契数、复原IP地址、省份数量、构造二叉树、字符串排列、分糖果、除自身以外数组的乘积、寻找峰值、反转字符串等。涉及栈、双指针、回溯、DFS、BFS、并查集等多种算法技巧。

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

文章目录

1047. 删除字符串中的所有相邻重复项

栈

class Solution {
public:
    string removeDuplicates(string s) {
        // stack
        stack<char> sk;
        for (char& x : s) {
            if (!sk.empty() && x == sk.top()) {
                sk.pop();
            } else {
                sk.push(x);
            }
        }
        string str;
        while (!sk.empty()) {
            str += sk.top();
            sk.pop();
        }
        reverse(str.begin(), str.end());
        return str;
    }
};

直接在string操作

back() 和 push_back() pop_back()

class Solution {
public:
    string removeDuplicates(string s) {
        string str;
        for (char& x : s) {
            if (!str.empty() && str.back() == x) {
                str.pop_back();
            } else {
                str.push_back(x);
            }
        }
        return str;
    }
};
258. 各位相加
class Solution {
public:
    int addDigits(int num) {
        while (num >= 10) {
            int count = 0;
            while (num > 0) {
                count += num % 10;
                num /= 10;
            }
            num = count;
        }
        return num;
    }
};

class Solution {
public:
    int addDigits(int num) {
        return (num - 1) % 9 + 1;
    }
};
345. 反转字符串中的元音字母

暴力做法，可以省去reverse步骤，将idx从后往前遍历即可。

class Solution {
public:
    bool flag (char& x) {
        return x == 'a' || x == 'e' || x == 'i' || x == 'o' || x == 'u' || x == 'A' || x == 'E' || x == 'I' || x == 'O' || x == 'U';
    }
    string reverseVowels(string s) {
        string str;
        for (char& x : s) {
            if (flag(x)) {
                str += x;
            }
        }
        reverse(str.begin(), str.end());
        int idx = 0;
        for (int i = 0; i < s.length(); ++i) {
            if (flag(s[i])) {
                s[i] = str[idx++];
            }
        }
        return s;
    }
};

双指针

class Solution {
public:

    bool flag (char& x) {
        return x == 'a' || x == 'e' || x == 'i' || x == 'o' || x == 'u' || x == 'A' || x == 'E' || x == 'I' || x == 'O' || x == 'U';
    }

    string reverseVowels(string s) {
        int l = 0, r = s.length() - 1;
        while (l < r) {
            while (l < r && !flag(s[l])) {
                ++l;
            }
            while (l < r && !flag(s[r])) {
                --r;
            }
            swap(s[l++], s[r--]);
        }
        return s;
    }
};
面试题 01.05. 一次编辑

双指针

个人觉得很好的题解：https://leetcode.cn/problems/one-away-lcci/solution/fu-xue-ming-zhu-by-fuxuemingzhu-qswu/

class Solution {
public:
    bool oneEditAway(string first, string second) {
        // two points
        int len1 = first.length(), len2 = second.length();
        if (abs(len1 - len2) > 1) {
            return false;
        }
        if (len1 < len2) return oneEditAway(second, first);
        int i = 0, j = 0;
        int flag = 0;
        while (i < len1 && j < len2) {
            if (first[i] != second[j]) {
                ++flag;
                if (flag > 1) {
                    return false;
                }
                if (len1 != len2) {
                    --j;
                }
            }
            ++i;    ++j;
        }
        return true;
    }
};

这道题也可以用前缀后缀来做

只需要编辑一次的前后缀应该相同

来源：wangYiTiaoYu

class Solution {
public:
    bool oneEditAway(string first, string second) {
        int p1 = 0;
        int q1 = first.size() - 1;
        int p2 = 0;
        int q2 = second.size() - 1;
        while (p1 <= q1 && p2 <= q2) {
            if (first[p1] == second[p1]) {
                ++p1;
                ++p2;
                continue;
            }
            if (first[q1] == second[q2]) {
                --q1;
                --q2;
            } else {
                break;
            }
        }
        return q1 - p1 + q2 - p2 <= 0 && abs(p1 - p2) <= 1 && abs(q1 - q2) <= 1;
    }
};
1137. 第 N 个泰波那契数

不用压栈操作效率会更高

class Solution {
public:
    int tribonacci(int n) {
        // 不用递归了
        int a = 0, b = 1, c = 1;
        if (n < 3) {
            return n == 0 ? 0 : 1;
        }
        for (int i = 3; i <= n; ++i) {
            int temp = c;
            c = a + b + c;
            a = b;
            b = temp;
        }
        return c;
    }
};
93. 复原 IP 地址

回溯做法

边界判断条件：是否有四个ip位，left是否已到最右边

class Solution {
public:
    vector<string> res;
    void DFS(string str, string s, int num, int left) {
        if (left == s.length() && num == 4) {
            res.push_back(str);
            return;
        }
        if (num >= 4 || left >= s.length()) {
            return;
        }
        string temp = (num == 0 ? "" : ".");
        for (int right = left; right < left + 3; ++right) {
            if (s[left] == '0') {
                
                DFS(str + temp + "0", s, num + 1, left + 1);
                break;
            }
            if (stoi(s.substr(left, right - left + 1)) <= 255) {
                DFS(str + temp + s.substr(left, right - left + 1), s, num + 1, right + 1);
            }
        }
        
    }
    vector<string> restoreIpAddresses(string s) {
        int len = s.length();
        if (len > 12)   return res;
        DFS("", s, 0, 0);

        return res;
    }
};
547. 省份数量

深度优先搜索

class Solution {
public:
#define k 200
    // static const int k = 200;
    int vis[k];
    // vector<int> vis;
    void DFS(vector<vector<int>>& isConnected, int i) {
        for (int j = 0; j < isConnected[i].size(); ++j) {
            if (isConnected[i][j] == 1 && vis[j] != 1) {
                vis[j] = 1;
                DFS(isConnected, j);
            }
        }
    }
    int findCircleNum(vector<vector<int>>& isConnected) {
        int n = isConnected.size(), res = 0;
        // vis.resize(n, 0);
        memset(vis, 0, sizeof(vis));
        for (int i = 0; i < n; ++i) {
            if (vis[i] == 0) {
                ++res;
                DFS(isConnected, i);
            }
        }
        return res;
    }
};

广度优先搜索

class Solution {
public:
    int findCircleNum(vector<vector<int>>& isConnected) {
        int n = isConnected.size(), res = 0;
        int vis[200] = {0};
        queue<int> q;

        for (int i = 0; i < n; ++i) {
            if (!vis[i]) {
                q.push(i);
                ++res;
                while (!q.empty()) {
                    int k = q.front();      q.pop();
                    vis[k] = 1;
                    for (int j = 0; j < isConnected[k].size(); ++j) {
                        if (isConnected[k][j] == 1 && vis[j] == 0) {
                            q.push(j);
                        }
                    }
                }
            }
        }
        return res;
    }
};

并查集

class Solution {
public:
    int Find(vector<int>& parent, int idx) {
        if (parent[idx] != idx) {
            parent[idx] = Find(parent, parent[idx]);
        }
        return parent[idx];
    }

    void Union(vector<int>& parent, int idx1, int idx2) {
        parent[Find(parent, idx1)] = Find(parent, idx2);
    }

    int findCircleNum(vector<vector<int>>& isConnected) {
        int n = isConnected.size(), res = 0;
        vector<int> parent(n);
        for (int i = 0; i < n; ++i) {
            parent[i] = i;
        }
        for (int i = 0; i < n; ++i) {
            for (int j = i + 1; j < n; ++j) {
                if (isConnected[i][j] == 1) {
                    Union(parent, i, j);
                }
            }
        }
        for (int i = 0; i < n; ++i) {
            if (parent[i] == i) {
                ++res;
            }
        }
        return res;
    }
};
106. 从中序与后序遍历序列构造二叉树

递归构树，保存中序映射节点，减少遍历次数

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    unordered_map<int, int> mp;
    TreeNode* Build(vector<int>& inorder, vector<int>& postorder, int in_l, int in_r, int post_l, int post_r) {
        if (in_l > in_r || post_l > post_r) {
            return nullptr;
        }
        TreeNode* node = new TreeNode(postorder[post_r]);
        int idx = mp[postorder[post_r]];
        int post_len = idx - in_l;
        node->left = Build(inorder, postorder, in_l, idx - 1, post_l, post_l + post_len - 1);
        node->right = Build(inorder, postorder, idx + 1, in_r, post_l + post_len, post_r - 1);

        return node;
    }

    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        int len = inorder.size();
        for (int i = 0; i < len; ++i) {
            mp[inorder[i]] = i;
        }
        TreeNode* node = Build(inorder, postorder, 0, len - 1, 0, len - 1);
        return node;

    }
};
567. 字符串的排列

暴力超时

class Solution {
public:
    bool flag = false;
    void DFS(string& s2, unordered_map<char, int>& mp, int& len, int idx) {
        if (len == 0 || flag) {
            flag = true;
            return;
        }
        if (mp[s2[idx]]) {
            --mp[s2[idx]];  --len;
            DFS(s2, mp, len, idx + 1);
            ++mp[s2[idx]];  ++len;
        }
    }

    bool checkInclusion(string s1, string s2) {
        int len1 = s1.length(), len2 = s2.length();
        if (len1 > len2)    return false;
        unordered_map<char, int> mp;
        for (char& x : s1) {
            ++mp[x];
        }
        for (int i = 0; i < len2; ++i) {
            DFS(s2, mp, len1, i);
            if (flag)   break;
        }
        return flag;
    }
};

滑动窗口

class Solution {
public:
    bool checkInclusion(string s1, string s2) {
        int len1 = s1.length(), len2 = s2.length();
        if (len1 > len2)    return false;
        vector<int> ans1(26), ans2(26);
        for (int i = 0; i < len1; ++i) {
            ++ans1[s1[i] - 'a'];
            ++ans2[s2[i] - 'a'];
        }
        if (ans1 == ans2)   return true;
        for (int i = len1; i < len2; ++i) {
            --ans2[s2[i - len1] - 'a'];
            ++ans2[s2[i] - 'a'];
            if (ans1 == ans2)   return true;
        }
        return false;
    }
};

双指针

class Solution {
public:
    bool checkInclusion(string s1, string s2) {
        int len1 = s1.length(), len2 = s2.length();
        if (len1 > len2)    return false;
        vector<int> cnt(26);
        for (char& x : s1) {
            --cnt[x - 'a'];
        }
        int left = 0;
        for (int right = 0; right < len2; ++right) {
            int x = s2[right] - 'a';
            ++cnt[x];
            while (cnt[x] > 0) {
                --cnt[s2[left] - 'a'];
                ++left;
            }
            if (right - left + 1 == len1) {
                return true;
            }
        }
        return false;
    }
};
1103. 分糖果 II

推导过程见lt官方题解

基本思想为等差数列求和

class Solution {
public:
    vector<int> distributeCandies(int candies, int num_people) {
        // n * (n + 1) / 2
        int n = num_people;
        int p = (int)(sqrt(2 * candies + 0.25) - 0.5);
        int remaining = candies - p * (p + 1) / 2;
        int rows = p / n, cols = p % n;
        vector<int> dp(n, 0);
        for (int i = 0; i < n; ++i) {
            dp[i] = (i + 1) * rows + n * rows * (rows - 1) / 2;
            if (i < cols)   dp[i] += i + 1 + rows * n;
        }
        dp[cols] += remaining;
        return dp;
    }
};
238. 除自身以外数组的乘积

先写一个开空间的

class Solution {
public:
    vector<int> productExceptSelf(vector<int>& nums) {
        // 不能用除法，先开空间试下
        int len = nums.size();
        vector<int> left(len, 1), right(len, 1);
        // int temp_l = 1, temp_r = 1;
        for (int i = 1; i < len; ++i) {
            left[i] = left[i - 1] * nums[i - 1];
            right[len - 1 - i] = right[len - i] * nums[len - i];
        }
        for (int i = 0; i < len; ++i) {
            left[i] *= right[i];
        }
        return left;
    }
};

按题目要求完成

class Solution {
public:
    vector<int> productExceptSelf(vector<int>& nums) {
        int len = nums.size();
        vector<int> right(len, 1);
        for (int i = len - 2; i >= 0; --i) {
            right[i] = right[i + 1] * nums[i + 1];
        }
        for (int i = 1; i < len; ++i) {
            right[i] = right[i] * nums[i - 1];
            nums[i] *= nums[i - 1];
        }
        return right;
    }
};
162. 寻找峰值

题目默认两边边界都是负无穷

二分往大的一边查找即可

并且题目规定了nums[i] != nums[i + 1]

class Solution {
public:
    int findPeakElement(vector<int>& nums) {
        // log(n)一般是二分
        int l = 0, r = nums.size() - 1, pos = 0;
        while (l <= r) {
            int mid = l + (r - l) / 2;
            if (mid < nums.size() - 1 && nums[mid] < nums[mid + 1]) {
                pos = mid + 1;
                l = mid + 1;
            } else {
                r = mid - 1;
            }
        }
        return pos;
    }
};
541. 反转字符串 II

简单题

class Solution {
public:
    string reverseStr(string s, int k) {
        int len = s.length();
        for (int i = 0; i < len; i += 2 * k) {
            reverse(s.begin() + i, s.begin() + min((i + k), len));
        }
        return s;
    }
};
LeetCode 面试经典 150 题回顾
张彦峰的博客
11-19 7万+
最经典 150 题，掌握面试所有知识点 面试经典 150 题 : 题目分析、解题思路、复杂度分析、代码展示
leetcode的C++答案
09-06
leetcode的C++答案 答案中有编程思路，以及部分题提供多种方法。时间复杂度低，均通过leetcode网站验证。
leetcode 精选面试题1 c++
l7_______的博客
05-09 973
文章目录[73. 矩阵置零](https://leetcode.cn/problems/set-matrix-zeroes/)[202. 快乐数](https://leetcode.cn/problems/happy-number/)[剑指 Offer 04. 二维数组中的查找](https://leetcode-cn.com/problems/er-wei-shu-zu-zhong-de-cha-zhao-lcof/)[131. 分割回文串](https://leetcode.cn/problems/pa
leetcode 70.爬楼梯（c++详细最全解法+补充知识）
最新发布
weixin_45942949的博客
05-07 531
就是利用两个变量循环进行保存前一个结果pre，和前面第二个结果prePre。如果只有一阶台阶，只有一种走法。如果两阶台阶，有1+1和2两种走法。有3种及以上个台阶，那么分以下两种情况，将两者进行相加，即为最终结果。是 C++ STL 中的关联容器，基于哈希表实现，提供快速的键值对查找功能。: 统计特定键的数量（0或1，因为键唯一）1. 1 阶 + 1 阶 + 1 阶。使用哈希表进行存储所有的结果。有两种方法可以爬到楼顶。1. 1 阶 + 1 阶。2. 1 阶 + 2 阶。3. 2 阶 + 1 阶。
LeetCode C++基础面试题汇总附答案（一）
lejian的专栏
02-22 1821
这里整理了leetCode C++的基础面试第一部分，希望对大家有所帮助。
Leetcode——C++突击面试
热门推荐
Stephen
07-16 2万+
C++突击面试1. 编译内存相关1.1. C++ 程序编译过程1.2. C++ 内存管理1.3. 栈和堆的区别1.4. 变量的区别1.5. 全局变量定义在头文件中有什么问题？1.6. 内存对齐1.7. 什么是内存泄露1.8. 怎么防止内存泄漏？内存泄漏检测工具的原理？2. 语言对比3. 面向对象4. 关键字库函数5. 类相关6. 语言特性相关7. 设计模式 1. 编译内存相关 1.1. C++ 程序编译过程 编译过程分为四个过程：编译（编译预处理、编译、优化），汇编，链接。 编译预处理：处理以 # 开头
leetcode-面试题刷题-Tree（C++）
mark_GJ的博客
05-07 318
实现一个函数，检查二叉树是否平衡。在这个问题中，平衡树的定义如下：任意一个节点，其两棵子树的高度差不超过 1。 本题类似于求树的深度，注意定义是每个节点 /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *righ...
LeetCode面试经典150题C++实现，更新中
herobinbin的专栏
11-10 1390
用C++实现下面网址的题目https://leetcode.cn/problems/merge-sorted-array/?envType=study-plan-v2&envId=top-interview-150给你两个按 非递减顺序 排列的整数数组 和 ，另有两个整数 和 ，分别表示 和 中的元素数目。请你 合并 到 中，使合并后的数组同样按 非递减顺序 排列。注意：最终，合并后数组不应由函数返回，而是存储在数组 中。为了应对这种情况， 的初始长度为 ，其中前 个元素表示应合并的元素，
LeetCode算法面试题的C++实现代码分享
LeetCode 是一个在线编程平台，提供大量的编程题目，涵盖算法和数据结构的各个方面，非常适合程序员在准备技术面试时进行练习。题目通常包括基础算法题、数据结构题、动态规划、搜索问题等。LeetCode 还有一个社交...
LeetCode 精选 TOP 面试题（2）1
08-04
在LeetCode精选的TOP面试题中，我们经常会遇到各种算法问题。以下是针对题目描述和标签“leetcode”中涉及的一些知识点的详细解释： 1. **旋转图像（48. Rotate Image）** 这个问题涉及到二维数组的旋转操作。题目...
leetcode题库-LeetCode:LeetCode题库记录C++版本
06-29
LeetCode 是一个在线编程挑战平台，它为程序员提供了一系列的编程题目，旨在提升他们的编程技能，特别是面试准备。本资源是 LeetCode 题库的一个 C++ 版本记录，包含了许多 C++ 实现的解决方案。 LeetCode 提供的...
Leetcode答案(c++版)
04-10
面试刷题必备。一共有200多道题目及相应解法。值得参考。
2. 两数相加
Tzecto
11-25 460
两数相加 给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。 请你将两个数相加，并以相同形式返回一个表示和的链表。 你可以假设除了数字 0 之外，这两个数都不会以 0 开头。 示例 1： 输入：l1 = [2,4,3], l2 = [5,6,4] 输出：[7,0,8] 解释：342 + 465 = 807. 示例 2： 输入：l1 = [0], l2 = [0] 输出：[0] 示例 3： 输入：l1 = [9,9,9,9,9,9,.
LeetCode第2题-两数相加（C++实现）
qq_44486437的博客
04-09 302
大家好，我是一只学弱狗，记录学习的点点滴滴！ 算法才是程序设计的灵魂，每日一题！ 优质文章 一张黄图的故事 JavaSE练习项目 我是菜鸟、我小试牛刀 linux指令太多记不住？小白看这篇就够了！ 优质专栏 数据库就该这样学 爪哇外步篇 刚看到的时候觉得挺难的，因为数据结构忘光了，但是通过不断的尝试，发现其实挺简单的，我大概说下思路吧 首先如果你会求解两个整数相加，那么这道题你就已经成功了一多办了，什么？两个整数相加？这不分分中，哈哈哈，其实我的意思是两个超级长的整数相加，意味着，你是用lo.
(leetcode 2) 两数相加 C++
Hunter Dreamer的博客
10-03 558
做这一题首先要明白，数据在链表中逆序存储，那么我们顺着链表的方向看，就是先低位后高位，这是一件好事。我们用竖式做加法的时候，也是末位对齐，那么我们只要从链表的头部开始加，就是相当于末位对齐加了。其次是进位的处理，最后一次还有进位如何处理，可以在最后判断，也可以在循环的时候就直接处理，有进位我就继续循环做加法，把进位加到最高位。这是leetcode的第二题，两数相加，题目。或者把进位放到最后，改变不大。
链表两数相加
凤凰于飞
07-30 211
给出两个非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照逆序的方式存储的，并且它们的每个节点只能存储一位数字。 如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。 您可以假设除了数字 0 之外，这两个数都不会以 0开头。 示例： 输入：(2 -> 4 -> 3) + (5 -> 6 -> 4) 输出：7 -> 0 -&...
LeetCode——第二题（C++）：两数相加
一七
08-25 601
题目：给出两个非空的链表用来表示两个非负的整数。其中，它们各自的位数是按照逆序的方式储存的，并且它们的每个节点只能储存一位数字。 如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。 您可以假设除了数字0以外，这两个数都不会以0开头。 示例 输入：(2->4->3)+(5->6->4) 输出：7->0->8 原因：342+465=807 提交成功的...
LeetCode第二题：Add Two Numbers（C++）
WangHuanToBeBest
04-09 343
/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ 上面是定义的结构体 class Solution { public: L...
Leetcode 第二题 Add Two Numbers （c++）
lihongjiang1997的博客
04-29 247
首先，这个数组是逆序排序的。。。 我开始想的是按顺序读出链表中的值组成真正的值i,j，然后直接计算i+j。 其中， i=i*10+l1->val； 但是，这个适合正序的，不适合逆序。。。 本来想直接使用进位进行计算，但是逻辑上出现了问题。 首先，最开始想的循环条件是 while(l1!=NULL && l2!=NULL) 然后只剩下l1不为空或者l2不为空...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值