剑指Offer题解合集
剑指Offer题单及题解
题目顺序为牛客上剑指Offer专题
JZ3、数组中重复的数字
分析
可以直接对数组进行排序，通过判断首末数字大小来判断数字越界情况，注意数组为空的情况。发现 \(0 \leq nums[i] \leq n - 1\), 因此直接开一个数组判断是否有重复数字即可，返回第一个重复数字。
代码实现
class Solution {
public:
int duplicateInArray(vector<int>& nums) {
int n = size(nums);
std::sort(nums.begin(), nums.end());
if (n == 0 || nums.back() > n || nums[0] < 0) {
return -1;
}
std::vector<int> buc(n);
for (auto x : nums) {
buc[x] += 1;
if (buc[x] > 1) {
return x;
}
}
return -1;
}
};
JZ5。替换空格
分析
直接调用std::string中的replace方法替换 即可。
代码实现
class Solution {
public:
string replaceSpaces(string &str) {
for (int i = 0; i < size(str); ++i) {
if (str[i] == ' ') {
str.replace(str.begin() + i, str.begin() + i + 1, "%20");
}
}
return str;
}
};
JZ6、从尾到头打印链表
分析
直接遍历链表，将链表中的数据存入vector，最后reverse一下返回即可。
代码实现
class Solution {
public:
vector<int> printListReversingly(ListNode* head) {
std::vector<int> ans;
while (head != nullptr) {
ans.push_back(head->val);
head = head->next;
}
std::reverse(ans.begin(), ans.end());
return ans;
}
};
JZ7、重建二叉树
分析
前序：根左右
中序：左根右
按照规则两个棵树同时进行递归即可，每次通过前序确定根节点，然后通过中序确定左右子树大小来改变递归范围。
代码实现
class Solution {
public:
TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
int n = size(preorder);
auto dfs = [&](auto &&self, int preL, int preR, int inL, int inR)->TreeNode* {
if (inL > inR) return NULL;
int root = preorder[preL], mid = inL;
// std::cerr << root << ' ' << preL << ' ' << preR << ' ' << inL << ' ' << inR << '\n';
TreeNode *node = new TreeNode(root);
while (mid < inR && inorder[mid] != root) {
mid += 1;
}
node->left = self(self, preL + 1, preL + mid - inL, inL, mid - 1);
node->right = self(self, preL + mid - inL + 1, preR, mid + 1, inR);
return node;
};
return dfs(dfs, 0, n - 1, 0, n - 1);
}
};
JZ8、二叉树的下一个节点
分析
可以分为两种情况讨论：
- 情况1：当前节点的右节点不为空，则下一个节点为其右子树的左子树的最下面的节点
- 情况2：当前节点的右节点为空，则下一个节点为其右子树祖先节点第一个存在右子树节点
代码实现
class Solution {
public:
TreeNode* inorderSuccessor(TreeNode* p) {
if (p->right != nullptr) {
p = p->right;
while (p->left != nullptr) {
p = p->left;
}
return p;
}
while (p->father != nullptr && p->father->right == p) {
p = p->father;
}
return p->father;
}
};
JZ9、用两个栈实现队列
分析
利用栈后进先出的特点，将stk1栈设置为入队栈只执行插入操作，stk2 栈设置为出队栈只执行出队操作，当stk2中元素出队完后，将stk1元素往stk2插即可，此时插过来的元素一定在栈底，满足队列条件。
代码实现
class MyQueue {
public:
/** Initialize your data structure here. */
std::stack<int> stk1, stk2;
MyQueue() {
}
/** Push element x to the back of queue. */
void push(int x) {
stk1.push(x);
}
/** Removes the element from in front of queue and returns that element. */
int pop() {
if (!size(stk2)) {
while (size(stk1)) {
stk2.push(stk1.top());
stk1.pop();
}
}
int ans = stk2.top();
stk2.pop();
return ans;
}
/** Get the front element. */
int peek() {
if (!size(stk2)) {
while (size(stk1)) {
stk2.push(stk1.top());
stk1.pop();
}
}
return stk2.top();
}
/** Returns whether the queue is empty. */
bool empty() {
return !(size(stk1) || size(stk2));
}
};
/**
* Your MyQueue object will be instantiated and called as such:
* MyQueue obj = MyQueue();
* obj.push(x);
* int param_2 = obj.pop();
* int param_3 = obj.peek();
* bool param_4 = obj.empty();
*/
JZ10、斐波那契数列
分析
没什么可说的，\(n \leq 39\)直接暴力即可，甚至不用开long long
代码实现
class Solution {
public:
int Fibonacci(int n) {
int n1 = 0, n2 = 1;
for (int i = 0; i < n; ++i) {
int n3 = n1 + n2;
n1 = n2, n2 = n3;
}
return n1;
}
};
JZ11、旋转数组的最小数字
分析
...直接乱写了，get不到这个题目的考点
代码实现
class Solution {
public:
int findMin(vector<int>& nums) {
if (size(nums) == 0) return -1;
return *min_element(nums.begin(), nums.end());
}
};
JZ12、矩阵中的路径
分析
直接根据枚举起点都搜一遍就行了。
代码实现
class Solution {
public:
bool hasPath(vector<vector<char>>& matrix, string &str) {
if (size(matrix) == 0) return false;
int n = size(matrix), m = size(matrix[0]);
std::vector<std::vector<bool>> vis(n, std::vector<bool>(m));
auto dfs = [&](auto &&self, int u, int x, int y)->bool {
if (u == size(str)) return true;
for (auto [dx, dy] : {std::pair{x, y + 1}, {x, y - 1}, {x - 1, y}, {x + 1, y}}) {
if (dx >= 0 && dx < n && dy >= 0 && dy < m
&& !vis[dx][dy] && str[u] == matrix[dx][dy]) {
vis[dx][dy] = true;
if (self(self, u + 1, dx, dy)) {
return true;
}
vis[dx][dy] = false;
}
}
return false;
};
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (matrix[i][j] == str[0]) {
vis[i][j] = true;
if (dfs(dfs, 1, i, j)) {
return true;
}
vis[i][j] = false;
}
}
}
return false;
}
};
JZ13、机器人的运动范围
分析
直接从起点开始dfs搜一遍，记录哪些点可以到达即可。
代码实现
class Solution {
public:
int movingCount(int threshold, int rows, int cols) {
if (rows == 0 || cols == 0) return 0;
std::vector<std::vector<bool>> vis(rows, std::vector<bool>(cols));
auto calc = [&](int x, int y) {
return x % 10 + x / 10 % 10 + y % 10 + y / 10 % 10;
};
auto dfs = [&](auto &&self, int x, int y)->int {
int cnt = 1;
vis[x][y] = true;
for (auto [dx, dy] : {std::pair{x + 1, y}, {x - 1, y}, {x, y + 1}, {x, y - 1}}) {
if (dx >= 0 && dx < rows && dy >= 0 && dy < cols && !vis[dx][dy] && calc(dx, dy) <= threshold) {
cnt += self(self, dx, dy);
}
}
return cnt;
};
return dfs(dfs, 0, 0);
}
};
JZ14、剪绳子
分析
发现n非常小，因此可以选择直接枚举分成m段，显然的当各个位数越接近时他们的乘积越大
代码实现
class Solution {
public:
int maxProductAfterCutting(int length) {
int ans = 1;
for (int m = 2; m < length; ++m) {
int p = length / m;
std::vector<int> num(m, p);
for (int i = 0; i < length - p * m; ++i) {
num[i] += 1;
}
int mul = 1;
for (auto &x : num) {
mul *= x;
}
ans = std::max(mul, ans);
}
return ans;
}
};
JZ15、二进制中1的个数
分析
__builtin_popcount()直接秒了
代码实现
class Solution {
public:
int NumberOf1(int n) {
// int ans = 0;
// while (n) {
// n &= n - 1;
// ans += 1;
// }
// return ans;
return __builtin_popcount(n);
}
};
JZ16、数值的整数次方
分析
快速幂模拟一下即可，如果exponent为负数最后被1除一下就行了
代码实现
class Solution {
public:
double Power(double base, int exponent) {
using i64 = long long;
bool flag = exponent > 0;
i64 c = std::abs((i64)exponent);
double ans = 1;
while (c) {
if (c & 1) ans *= base;
base *= base;
c >>= 1;
}
if (!flag) {
ans = 1. / ans;
}
return ans;
}
};
JZ17、打印从1到最大的n位数
分析
直接开一个\(10^n - 1\)大小的数组从头开始赋值即可。
代码实现
class Solution {
public:
vector<int> printNumbers(int n) {
std::vector<int> f((int)pow(10, n) - 1);
for (int idx = 1; auto &x : f) {
x = idx++;
}
// std::iota(f.begin(), f.end(), 1);
return f;
}
};
JZ18、在O(1)时间删除链表结点
分析
将当前节点的值拷贝为下一个节点的值，再将下一个节点删除等价于删除当前节点。
代码实现
class Solution {
public:
void deleteNode(ListNode* node) {
ListNode *now = node->next;
node->val = now->val;
node->next = node->next->next;
delete now;
}
};
JZ20、表示数值的字符串
分析
面向样例编程最爽的一集，模拟一下即可。
代码实现
class Solution {
public:
bool isNumber(string s) {
if (s == "") return false;
int pe = -1, pE = -1;
for (int idx = 0; auto &c : s) {
if (!((c >= '0' && c <= '9')
|| c == '+' || c == '-' || c == '.'
|| c == 'E' || c == 'e')) {
return false;
}
if (c == 'e') {
if (pe != -1) {
return false;
} else pe = idx;
}
if (c == 'E') {
if (pE != -1) {
return false;
} else pE = idx;
}
idx += 1;
}
auto check = [&](std::string &t) {
int pAdd = t.rfind('+'), pSub = t.rfind('-');
if (pAdd != -1 && pAdd != 0) return false;
if (pSub != -1 && pSub != 0) return false;
if (std::count(t.begin(), t.end(), '.') > 1) return false;
if (t == "+." || t == "-." || t == ".-" || t == ".+"
|| t == "+" || t == "-" || t == ".") return false;
return true;
};
if (pe != -1 && pE != -1) {
return false;
} else if (pe != -1 || pE != -1) {
int p = pe != -1 ? pe : pE;
std::string s1 = s.substr(0, p), s2 = s.substr(p + 1);
if (s1 == "" || s2 == "" || s2.find('.') != string::npos) return false;
return check(s1) && check(s2);
} else {
return check(s);
}
}
};
JZ21、调整数组顺序使奇数位于偶数前面
分析
直接拿两个数组记录所有奇数和偶数再插入原数组中即可。
代码实现
class Solution {
public:
void reOrderArray(vector<int> &array) {
int n = size(array);
std::vector<int> even, odd;
for (auto x : array) {
x % 2 ? odd.push_back(x) : even.push_back(x);
}
int idx = 0;
for (auto x : odd) {
array[idx++] = x;
}
for (auto x : even) {
array[idx++] = x;
}
}
};
JZ22、链表中倒数最后k个结点
分析
记录两个间距为k的指针，然后同时往后跳到最后即可找到第k个节点
代码实现
class Solution {
public:
ListNode* findKthToTail(ListNode* pHead, int k) {
if (pHead == nullptr) {
return nullptr;
}
ListNode *fast = pHead, *slow = pHead;
while (k--) {
fast = fast->next;
if (fast == nullptr && k > 0) {
return nullptr;
}
}
while (fast != nullptr) {
fast = fast->next;
slow = slow->next;
}
return slow;
}
};
JZ23、链表中环的入口结点
分析
快慢指针，一个指针每次走1步，一个指针每次走两步，如果能够相遇则说明存在环。随后将其中一个指针调到起点，接着走，相遇的节点即位入口节点。
代码实现
class Solution {
public:
ListNode *entryNodeOfLoop(ListNode *pHead) {
if (pHead == nullptr) {
return nullptr;
}
ListNode *fast = pHead, *slow = pHead;
do {
fast = fast->next;
slow = slow->next;
if (fast != nullptr) {
fast = fast->next;
} else return nullptr;
if (fast == slow) {
break;
}
} while (fast != nullptr);
if (fast == nullptr) {
return nullptr;
}
while (pHead != slow) {
slow = slow->next;
pHead = pHead->next;
}
return pHead;
}
};
JZ24、反转链表
分析
每次拿一个中间点转换一下两个点指针方向即可。
代码实现
class Solution {
public:
ListNode* reverseList(ListNode* head) {
if (head == nullptr || head->next == nullptr) {
return head;
}
ListNode *n1 = head, *n2 = head->next;
head->next = nullptr;
while (n2 != nullptr) {
ListNode *n3 = n2->next;
n2->next = n1;
n1 = n2;
n2 = n3;
}
return n1;
}
};
JZ25、合并两个排序的链表
分析
需要用一个新的指针来接受新链表，旧的两个指针每次比较头元素，然后将较小的元素插入新链表即可。
代码实现
class Solution {
public:
ListNode* merge(ListNode* pHead1, ListNode* pHead2) {
if (pHead1 == nullptr) {
return pHead2;
}
if (pHead2 == nullptr) {
return pHead1;
}
ListNode *ans;
if (pHead1->val > pHead2->val) {
std::swap(pHead1, pHead2);
}
ans = pHead1;
while (pHead1->next != nullptr && pHead2 != nullptr) {
// std::cout << pHead1->next->val << ' ' << pHead2->val << "!\n";
if (pHead1->next->val > pHead2->val) {
ListNode *temp = pHead2;
pHead2 = pHead2->next;
temp->next = pHead1->next;
pHead1->next = temp;
}
pHead1 = pHead1->next;
// std::cout << pHead1->val << "?\n";
}
if (pHead1->next == nullptr) {
pHead1->next = pHead2;
}
return ans;
}
};
JZ26、树的子结构
分析
遍历A树，遇到和Bval相等的节点就到B中搜索一下看查是否为子树即可。
代码实现
class Solution {
public:
bool hasSubtree(TreeNode* A, TreeNode* B) {
if (B == NULL) return false;
auto check = [&](auto &&self, TreeNode *a, TreeNode *b)->bool {
if (a == nullptr && b == nullptr) return true;
if (b == nullptr) return true;
if (a == nullptr) return false;
if (a->val != b->val) return false;
return self(self, a->left, b->left) && self(self, a->right, b->right);
};
auto dfs = [&](auto &&self, TreeNode *root)->bool {
if (root == NULL) return false;
if (root->val == B->val) {
if (check(check, root, B)) return true;
}
if (self(self, root->right)) return true;
if (self(self, root->left)) return true;
return false;
};
return dfs(dfs, A);
}
};
JZ27、二叉树的镜像
分析
每次递归完交换左右子树即可
代码实现
class Solution {
public:
void mirror(TreeNode* pRoot) {
auto dfs = [&](auto &&self, TreeNode *root)->void {
if (root == nullptr) return ;
self(self, root->left);
self(self, root->right);
std::swap(root->left, root->right);
};
dfs(dfs, pRoot);
}
};
JZ29、顺时针打印矩阵
分析
模拟，注意判断边界就行了
代码实现
class Solution {
public:
vector<int> printMatrix(vector<vector<int> > matrix) {
if (size(matrix) == 0) return {};
int n = size(matrix), m = size(matrix[0]);
std::array<int, 4> dir{m - 1, n - 1, 0, 1};
std::vector<int> ans;
int x = 0, y = 0, idx = 0;
while (size(ans) != n * m) {
// std::cerr << idx << ' ' << x << ' ' << y << '\n';
if (idx % 4 == 0) {
while (y <= dir[idx % 4]) {
ans.push_back(matrix[x][y++]);
}
dir[idx % 4] -= 1;
y -= 1, x += 1;
} else if (idx % 4 == 1) {
while (x <= dir[idx % 4]) {
ans.push_back(matrix[x++][y]);
}
dir[idx % 4] -= 1;
x -= 1, y -= 1;
} else if (idx % 4 == 2) {
while (y >= dir[idx % 4]) {
ans.push_back(matrix[x][y--]);
}
dir[idx % 4] += 1;
y += 1, x -= 1;
} else {
while (x >= dir[idx % 4]) {
ans.push_back(matrix[x--][y]);
}
dir[idx % 4] += 1;
x += 1, y += 1;
}
idx += 1;
}
return ans;
}
};
JZ30、包含min函数的栈
分析
维护两个栈，其中一个单调存储元素即可。
代码实现
class MinStack {
public:
std::stack<int> stk, stkMin;
MinStack() {
}
void push(int x) {
if (size(stkMin) == 0 || stkMin.top() >= x) {
stkMin.push(x);
}
stk.push(x);
}
void pop() {
if (stkMin.top() == stk.top()) {
stkMin.pop();
}
stk.pop();
}
int top() {
return stk.top();
}
int getMin() {
return stkMin.top();
}
};
JZ30、包含min函数的栈
分析
维护两个栈，其中一个单调存储元素即可。
代码实现
class MinStack {
public:
std::stack<int> stk, stkMin;
MinStack() {
}
void push(int x) {
if (size(stkMin) == 0 || stkMin.top() >= x) {
stkMin.push(x);
}
stk.push(x);
}
void pop() {
if (stkMin.top() == stk.top()) {
stkMin.pop();
}
stk.pop();
}
int top() {
return stk.top();
}
int getMin() {
return stkMin.top();
}
};
JZ31、栈的压入、弹出序列
分析
使用一个栈模拟出入栈即可。
代码实现
class Solution {
public:
bool isPopOrder(vector<int> pushV,vector<int> popV) {
if (size(pushV) != size(popV)) return false;
if (size(pushV) == 0) return true;
std::stack<int> stk;
int puv = 0, pov = 0, n = size(pushV);
while (puv != (int)size(pushV) && pov != (int)size(popV)) {
// std::cerr << size(stk) << ' ' << pov << ' ' << puv << "?\n";
while ((int)size(stk) == 0 || (puv < n && stk.top() != popV[pov])) {
stk.push(pushV[puv++]);
}
while (size(stk) && pov < n && stk.top() == popV[pov]) {
stk.pop();
pov++;
}
if (puv == n && size(stk) != 0 && pov != n) {
return false;
}
}
return true;
}
};
JZ32、从上往下打印二叉树
分析
即二叉树的层序遍历
代码实现
class Solution {
public:
vector<int> printFromTopToBottom(TreeNode* root) {
if (root == nullptr) return {};
std::vector<TreeNode *> q;
std::vector<int> ans;
q.push_back(root);
for (int i = 0; i < (int)size(q); ++i) {
TreeNode *u = q[i];
ans.push_back(u->val);
if (u->left != nullptr) {
q.push_back(u->left);
}
if(u->right != nullptr) {
q.push_back(u->right);
}
}
return ans;
}
};
JZ33、二叉搜索树的后序遍历序列
分析
二叉搜索树的性质：左子树都比右子树小。
并且由于是后续遍历可以直接确定根节点，因此本题可以通过根节点来寻找左右子树边界，最后分别递归判断右子树是否全部大于根节点即可。
代码实现
class Solution {
public:
bool verifySequenceOfBST(vector<int> sequence) {
if (size(sequence) == 0) return true;
int n = size(sequence);
auto dfs = [&](auto &&self, int l, int r)->bool {
if (l >= r) return true;
int root = sequence[r], mid = l;
while (mid < r && sequence[mid] < root) {
mid += 1;
}
// std::cout << l << ' ' << r << ' ' << mid << '\n';
for (int i = mid + 1; i < r; ++i) {
if (sequence[i] < root) return false;
}
return self(self, l, mid - 1) && self(self, mid, r - 1);
};
return dfs(dfs, 0, n - 1);
}
};
JZ35、复杂链表的复制
分析
使用map记录下被映射的节点，如果未创建则需要重新创建一个，最后就是遍历链表并记录新链表。
代码实现
class Solution {
public:
ListNode *copyRandomList(ListNode *head) {
std::map<ListNode *, ListNode *> mp;
mp[nullptr] = nullptr;
ListNode *dup = new ListNode(-1), *tail = dup;
auto dfs = [&](auto &&self, ListNode *root)->void {
if (root == nullptr) return ;
if (!mp.count(root)) {
mp[root] = new ListNode(root->val);
}
if (!mp.count(root->random)) {
mp[root->random] = new ListNode(root->random->val);
}
tail->next = mp[root];
tail->next->random = mp[root->random];
tail = tail->next;
self(self, root->next);
};
dfs(dfs, head);
return dup->next;
}
};
JZ36、二叉搜索树与双向链表
分析
dfs的时候注意记录下父亲节点就行了。
代码实现
class Solution {
public:
TreeNode* convert(TreeNode* root) {
if (root == nullptr) return nullptr;
TreeNode *head = nullptr, *pre = nullptr;
auto dfs = [&](auto &&self, TreeNode *root)->void {
if (root == nullptr) return ;
self(self, root->left);
if (pre == nullptr) {
head = root;
} else {
pre->right = root;
}
root->left = pre;
pre = root;
self(self, root->right);
};
dfs(dfs, root);
return head;
}
};
JZ37、序列化二叉树
分析
使用std::stringstream模拟std::cin和std::cout输入输出前序序列即可。
代码实现
class Solution {
public:
// Encodes a tree to a single string.
string serialize(TreeNode* root) {
std::stringstream cout;
auto dfs = [&](auto &&self, TreeNode *root)->void {
if (root == nullptr) {
cout << (int)1e9 << ' ';
} else {
cout << root->val << ' ';
self(self, root->left);
self(self, root->right);
}
};
dfs(dfs, root);
return cout.str();
}
// Decodes your encoded data to tree.
TreeNode* deserialize(string data) {
std::stringstream cin(data);
auto dfs = [&](auto &&self)->TreeNode* {
int val;
cin >> val;
if (val == 1e9) return nullptr;
TreeNode *node = new TreeNode(val);
node->left = self(self);
node->right = self(self);
return node;
};
return dfs(dfs);
}
};
JZ38、字符串的排列
分析
std::next_permutation秒了
代码实现
class Solution {
public:
vector<string> Permutation(string str) {
std::vector<std::string> ans;
std::sort(str.begin(), str.end());
do {
ans.push_back(str);
} while (std::next_permutation(str.begin(), str.end()));
return ans;
}
};
JZ39、数组中出现次数超过一半的数字
分析
std::unordered_map记录一下所有数字出现次数即可
代码实现
class Solution {
public:
int MoreThanHalfNum_Solution(vector<int>& nums) {
std::unordered_map<int, int> mp;
for (auto x : nums) {
mp[x] += 1;
}
int ans = -1;
for (auto [x, cnt] : mp) {
if (cnt * 2 >= size(nums)) {
ans = x;
break;
}
}
return ans;
}
};
JZ40、最小的K个数
分析
排序一下让后删除最后的\(n-k\)个数即可
代码实现
class Solution {
public:
vector<int> getLeastNumbers_Solution(vector<int> input, int k) {
std::sort(input.begin(), input.end());
input.erase(input.begin() + k, input.end());
return input;
}
};
JZ41、数据流中的中位数
分析
使用两个std::priority_queue分别维护一半的数组，中位数即位两个堆顶的平均数，或者小根堆的堆顶。
代码实现
class Solution {
public:
std::priority_queue<int, std::vector<int>, std::greater<>> pre;
std::priority_queue<int> suf;
void insert(int num){
pre.push(num);
while (size(pre) > size(suf) + 1) {
int a = pre.top();
pre.pop();
suf.push(a);
}
while (size(pre) && size(suf) && pre.top() < suf.top()) {
int a = pre.top(), b = suf.top();
pre.pop(), suf.pop();
suf.push(a), pre.push(b);
}
}
double getMedian(){
if (size(pre) == size(suf)) {
return 1. * (pre.top() + suf.top()) / 2;
} else {
return pre.top();
}
}
};
JZ43、从1到n整数中1出现的次数
分析
枚举每个位置上1出现的次数即可。
代码实现
class Solution {
public:
int numberOf1Between1AndN_Solution(int n) {
int ans = 0, p = 1, x = 0;
while (n) {
int t = n % 10;
if (p == 1) {
ans += n / 10 + (t != 0);
} else {
if (t <= 1) {
ans += n / 10 * p + (x + 1) * t;
} else {
ans += (n / 10 + 1) * p;
}
}
x = p * t + x;
p *= 10, n /= 10;
}
return ans;
}
};
JZ44、数字序列中某一位的数字
分析
优先找到这个下标所属的位数，然后就可以快速定位到是哪一个数字。
代码实现
class Solution {
public:
int digitAtIndex(int n) {
if (n <= 9) return n;
using i64 = long long;
n -= 10;
i64 p = 90, len = 2;
while (n >= p * len) {
n -= p * len;
p *= 10, len += 1;
}
int y = std::pow(10, len - 1) + n / len;
return std::to_string(y)[n % len] - '0';
}
};
JZ45、把数组排成最小的数
分析
直接进行排序即可判断哪两个数相加更小
代码实现
class Solution {
public:
string printMinNumber(vector<int>& nums) {
std::sort(nums.begin(), nums.end(),
[&](const int a, const int b) {
return std::to_string(a) + std::to_string(b) < std::to_string(b) + std::to_string(a);
});
std::string ans;
for (int i = 0; i < (int)size(nums); ++i) {
ans += std::to_string(nums[i]);
}
return ans;
}
};
JZ46、把数字翻译成字符串
代码实现
class Solution {
public:
int getTranslationCount(std::string s) {
int n = size(s);
std::vector<int> f(n);
f[n - 1] = 1;
for (int i = n - 2; i >= 0; --i) {
f[i] = f[i + 1];
if (s[i] == '1' || (s[i] == '2' && s[i + 1] < '6')) {
f[i] += f[i + 2];
}
}
return f[0];
}
};
JZ47、礼物的最大价值
代码实现
class Solution {
public:
int getTranslationCount(std::string s) {
int n = size(s);
std::vector<int> f(n);
f[n - 1] = 1;
for (int i = n - 2; i >= 0; --i) {
f[i] = f[i + 1];
if (s[i] == '1' || (s[i] == '2' && s[i + 1] < '6')) {
f[i] += f[i + 2];
}
}
return f[0];
}
};
JZ47、礼物的最大价值
分析
双指针维护一下集合中字符的重复性即可
代码实现
class Solution {
public:
int longestSubstringWithoutDuplication(std::string s) {
int n = size(s);
std::vector<bool> used(26);
int l = 0, r = 0, ans = 0;
while (r < n) {
while (l < r && used[s[r] - 'a']) {
used[s[l] - 'a'] = false;
l += 1;
}
used[s[r] - 'a'] = true;
r += 1;
ans = std::max(r - l, ans);
}
return ans;
}
};
JZ48、最长不含重复字符的子字符串
分析
双指针维护一下集合中字符的重复性即可
代码实现
class Solution {
public:
int longestSubstringWithoutDuplication(std::string s) {
int n = size(s);
std::vector<bool> used(26);
int l = 0, r = 0, ans = 0;
while (r < n) {
while (l < r && used[s[r] - 'a']) {
used[s[l] - 'a'] = false;
l += 1;
}
used[s[r] - 'a'] = true;
r += 1;
ans = std::max(r - l, ans);
}
return ans;
}
};
JZ49、丑数
分析
优先队列维护未被使用过的最小值并添加到std::set中去重
代码实现
class Solution {
public:
int getUglyNumber(int n) {
std::set<long long> st = {1};
std::priority_queue<long long, std::vector<long long>, std::greater<>> heap;
heap.push(1);
while (size(st) < 3LL * n) {
auto x = heap.top();
heap.pop();
for (auto p : {2, 3, 5}) {
if (!st.count(x * p)) {
heap.push(x * p);
st.insert(x * p);
}
}
}
while (size(st) != n) {
st.erase(prev(st.end()));
}
return *st.rbegin();
}
};
JZ50、第一个只出现一次的字符
代码实现
class Solution {
public:
char firstNotRepeatingChar(string s) {
if (size(s) == 0) return '#';
std::unordered_map<char, std::vector<int>> mp;
for (int i = 0; i < size(s); ++i) {
mp[s[i]].push_back(i);
}
char ans = -1, pos = 1E9;
for (char c = 'a'; c <= 'z'; ++c) {
if (size(mp[c]) == 1) {
if (mp[c][0] < pos) {
ans = c;
pos = mp[c][0];
}
}
}
for (char c = 'A'; c <= 'Z'; ++c) {
if (size(mp[c]) == 1) {
if (mp[c][0] < pos) {
ans = c;
pos = mp[c][0];
}
}
}
if ((int)ans == -1) {
return '#';
} else {
return ans;
}
}
};
JZ51、数组中的逆序对
代码实现
class Solution {
public:
int inversePairs(vector<int>& nums) {
using i64 = long long;
auto mergeSort = [&](auto &&self, int l, int r)->i64 {
if (l >= r) return 0;
int mid = l + r >> 1;
int ans = self(self, l, mid) + self(self, mid + 1, r);
std::vector<int> tmp;
int i = l, j = mid + 1;
while (i <= mid && j <= r) {
if (nums[i] <= nums[j]) {
tmp.push_back(nums[i++]);
} else {
ans += mid - i + 1;
tmp.push_back(nums[j++]);
}
}
while (i <= mid) {
tmp.push_back(nums[i++]);
}
while (j <= r) {
tmp.push_back(nums[j++]);
}
for (int i = 0; i < size(tmp); ++i) {
nums[l + i] = tmp[i];
}
return ans;
};
return mergeSort(mergeSort, 0, size(nums) - 1);
}
};
JZ52、两个链表的第一个公共结点
分析
快慢指针跑一遍即可
代码实现
class Solution {
public:
ListNode* FindFirstCommonNode(ListNode* pHead1, ListNode* pHead2) {
if (pHead1 == nullptr || pHead2 == nullptr) {
return nullptr;
}
ListNode *p1 = pHead1, *p2 = pHead2;
while (p1 != p2) {
p1 = p1->next;
if (p1 == nullptr) {
p1 = pHead2;
pHead2 = nullptr;
}
p2 = p2->next;
if (p2 == nullptr) {
p2 = pHead1;
pHead1 = nullptr;
}
}
return p1;
}
};
JZ53、数字在升序数组中出现的次数
分析
二分至相同数字的左右端点即可
代码实现
class Solution {
public:
int getNumberOfK(vector<int> &nums , int k) {
if (size(nums) == 0) return 0;
int n = size(nums);
int l = 0, r = n - 1;
while (l < r) {
int mid = l + r >> 1;
if (nums[mid] < k) {
l = mid + 1;
} else {
r = mid;
}
}
if (nums[r] != k) {
return 0;
}
int pl = r;
l = 0, r = n - 1;
while (l < r) {
int mid = l + r + 1 >> 1;
if (nums[mid] <= k) {
l = mid;
} else {
r = mid - 1;
}
}
return r - pl + 1;
}
};
JZ54、二叉搜索树的第k个节点
分析
即求前序遍历的第k的点
代码实现
class Solution {
public:
TreeNode* kthNode(TreeNode* root, int k) {
int cnt = 0;
std::vector<TreeNode *> ans;
auto dfs = [&](auto &&self, TreeNode *u)->void {
if (u == nullptr) return ;
self(self, u->left);
ans.push_back(u);
self(self, u->right);
};
dfs(dfs, root);
return ans[k - 1];
}
};
JZ55、二叉树的深度
代码实现
class Solution {
public:
int treeDepth(TreeNode* root) {
int maxDep = 0;
std::vector<TreeNode *> ans;
auto dfs = [&](auto &&self, TreeNode *u, int dep)->void {
if (u == nullptr) return ;
maxDep = std::max(maxDep, dep);
self(self, u->left, dep + 1);
ans.push_back(u);
self(self, u->right, dep + 1);
};
dfs(dfs, root, 1);
return maxDep;
}
};
JZ56、数组中只出现一次的两个数字
代码实现
class Solution {
public:
vector<int> findNumsAppearOnce(vector<int>& nums) {
int n = size(nums), xy = 0;
for (int i = 0; i < n; ++i) {
xy ^= nums[i];
}
int k = 31 - __builtin_clz(xy);
int x = 0;
for (int i = 0; i < n; ++i) {
if ((nums[i] >> k & 1) == 1) {
x ^= nums[i];
}
}
return {x, x ^ xy};
}
};
JZ57、数组中只出现一次的两个数字
分析
对原数组进行排序后枚举每个数字进行二分查找target - nums[i]是否存在。
代码实现
class Solution {
public:
vector<int> findNumbersWithSum(vector<int>& nums, int target) {
std::sort(nums.begin(), nums.end());
for (int i = 0; i < size(nums); ++i) {
auto pos = std::lower_bound(nums.begin(), nums.end(), target - nums[i]);
if (pos != nums.end()) {
if (nums[i] + (*pos) == target) {
return {nums[i], *pos};
}
}
}
return {};
}
};
未完待续...
