- Intervalle récapitulatif
Étant donné un tableau d'entiers ordonné sans éléments répétés, renvoie le récapitulatif de la plage du tableau.
Une question très simple, il suffit de la parcourir une fois
class Solution {
public:
vector<string> summaryRanges(vector<int>& nums)
{
vector<string> ans;
for (int i = 0; i < nums.size(); i++)
{
string str = to_string(nums[i]);
int pos = i;
while (i < nums.size() - 1 && nums[i] + 1 == nums[i + 1])
{
i++; //数字连续
}
if (pos != i) //若有增加
{
str += "->" + to_string(nums[i]);
}
ans.push_back(str);
}
return ans;
}
};
- Trouvez le mode 2
Étant donné un tableau de taille n, trouvez tous les éléments qui apparaissent plus de ⌊ n / 3 ⌋ fois.
Résolu par le vote de Moore, si un tableau de mappage est utilisé directement, la complexité de l'espace ne répond pas aux exigences
/*
时间复杂度为：O(n)
空间复杂度为：O(1)
*/
class Solution {
public:
vector<int> majorityElement(vector<int>& nums) {
int len = nums.size();
vector<int>res, cands, cnts;
if(len == 0){
//没有元素，直接返回空数组
return res;
}
cands.assign(2, nums[0]);
cnts.assign(2, 0);
//第1阶段 成对抵销
for(auto num: nums){
bool flag = false;
for(int i = 0; i < cands.size(); ++i){
if(num == cands[i]){
++cnts[i];
flag = true;
break;
}
}
if(!flag){
bool flag2 = false;
for(int j = 0; j < cands.size(); ++j){
if(cnts[j] == 0){
flag2 = true;
cands[j] = num;
cnts[j]++;
}
}
if(!flag2){
for(int j = 0; j < cnts.size(); ++j){
--cnts[j];
}
}
}
}
//第2阶段 计数 数目要超过三分之一
cnts[0] = cnts[1] = 0;
if(cands[0] == cands[1])
cands.pop_back();
for(auto num:nums){
for(int i = 0; i < cands.size(); ++i){
if(cands[i] == num){
++cnts[i];
break;
}
}
}
for(int i = 0; i < cands.size(); ++i){
if(cnts[i] > len / 3){
res.push_back(cands[i]);
}
}
return res;
}
};
- Kth
plus petit élément de l'arbre de recherche binaire Étant donné un arbre de recherche binaire, écrivez une fonction kthSmallest pour y trouver le kième élément le plus petit
Le moyen le plus simple est d'utiliser la récursivité ou l'itération pour organiser le parcours d'ordre intermédiaire, prenez simplement le kème élément. Parmi eux, l'itération est meilleure que la récursivité, car l'itération trouve la kième et peut arrêter de revenir immédiatement.
class Solution {
int m_cnt = 0, m_ret = 0;
public:
int kthSmallest(TreeNode* root, int k)
{
__midOrder(root, k);
return m_ret;
}
private:
void __midOrder(TreeNode *root, int k)
{
if (root == NULL) return;
__midOrder(root->left, k);
m_cnt++;
if (m_cnt == k) m_ret = root->val;
__midOrder(root->right, k);
}
};
class Solution {
int m_cnt = 0, m_ret = 0;
public:
int kthSmallest(TreeNode* root, int k)
{
return __midOrder(root, k);
}
private:
int __midOrder(TreeNode *root, int k)
{
stack<TreeNode *> s;
TreeNode *cur = root;
while (s.size() || cur)
{
while (cur)
{
s.push(cur);
cur = cur->left;
}
cur = s.top();
s.pop();
m_cnt++;
if (m_cnt == k) return cur->val;
cur = cur->right;
}
return 0;
}
};
- La puissance de 2 est une
question simple
class Solution {
public:
bool isPowerOfTwo(int n) {
if (n <= 0) return false;
while (n > 1)
{
if (n % 2 != 0)
return false;
else
n = n / 2;
}
return true;
}
};
- Implémenter des files d'attente avec des piles
Tout comme la file d'attente précédente, une seule pile supplémentaire est nécessaire.
class MyQueue {
public:
stack<int> inStack;
stack<int> outStack;
MyQueue() {
}
void push(int x) {
inStack.push(x);
}
int pop() {
cheak();
int a=outStack.top();
outStack.pop();
return a;
}
int peek() {
cheak();
return outStack.top();
}
bool empty() {
return inStack.empty()&&outStack.empty();
}
void cheak()
{
if(outStack.empty())
{
while(!inStack.empty())
{
outStack.push(inStack.top());
inStack.pop();
}
}
}
};
/*
* Your MyQueue object will be instantiated and called as such:
* MyQueue* obj = new MyQueue();
* obj->push(x);
* int param_2 = obj->pop();
* int param_3 = obj->peek();
* bool param_4 = obj->empty();
*/
- Nombre du nombre 1
Étant donné un entier n, comptez le nombre d'occurrences du nombre 1 dans tous les entiers non négatifs inférieurs ou égaux à n.
I est parcouru de 1 à n, est un développement 10 fois de chaque itération i:
(n/(i*10))∗iindique(i*10)le nombre de bits.
min(max((n mod (i*10)} )-i+1, 0), i)})Indique le nombre de(i*10)1 dans les chiffres qui nécessitent des chiffres supplémentaires .
class Solution {
public:
int countDigitOne(int n)
{
int countr = 0;
for (long long i = 1; i <= n; i *= 10) {
long long divider = i * 10;
countr += (n / divider) * i + min(max(n % divider - i + 1, 0LL), i);
}
return countr;
}
};
- Liste chaînée Palindrome
Veuillez évaluer si une liste chaînée est une liste chaînée palindrome. Pouvez-vous résoudre ce problème avec la complexité du temps O (n) et la complexité de l'espace O (1)?
La complexité spatiale O (1) indique que vous ne pouvez pas utiliser le stockage de pile ou la recherche récursive. Par conséquent, l'approche ici consiste à utiliser d'abord les pointeurs rapides et lents pour obtenir les nœuds intermédiaires, inverser la première moitié pendant le mouvement des pointeurs rapides et lents, puis comparer la seconde moitié et la première moitié. Si les valeurs sont égales. Faites attention au jugement de la parité du nœud intermédiaire
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
bool isPalindrome(ListNode* head) {
if(!head || !head->next)
return 1;
ListNode *fast = head, *slow = head;
ListNode *p, *pre = NULL;
while(fast && fast->next){
p = slow;
slow = slow->next; //快慢遍历
fast = fast->next->next;
p->next = pre; //翻转
pre = p;
}
if(fast) //奇数个节点时跳过中间节点
slow = slow->next;
while(p){
//前半部分和后半部分比较
if(p->val != slow->val)
return 0;
p = p->next;
slow = slow->next;
}
return 1;
}
};