Kerolt's Blog

发表于 分类于 标签 Disqus： 本文字数： 415 阅读时长 ≈ 2 分钟

想写这篇博客的原因是在刷力扣的 347. 前 K 个高频元素 一题时，需要使用到优先队列priority_queue，其定义如下：

1
2
3
4
5
template<
    class T,
    class Container = std::vector<T>,
    class Compare = std::less<typename Container::value_type>
> class priority_queue;

第三个参数是一个可以自定义的比较类型，其必须满足二元谓词，通常可以使用如下两种方法：

  1. 使用自定义的函数对象
  2. lambda表达式
  3. 使用std::greater或std::less（这里就不介绍这种方法了）
阅读全文 »

发表于 分类于 标签 Disqus： 本文字数： 311 阅读时长 ≈ 1 分钟

一般来说，如果我们在C++程序中要使用mysql的库，最简单的就是

1
g++ server.cpp -o server -lmysqlclient

但要是在大一点的项目中，在数不清的源文件下使用g++命令来完成，怕是不太现实。

阅读全文 »

发表于 分类于 标签 Disqus： 本文字数： 970 阅读时长 ≈ 4 分钟

前言

在Vue3项目中，如果我们想上传图片一般可以利用element-ui中的el-upload，为了避免代码的重复，我们可以自己封装一个图片上传组件。

其中，主要实现思想为前端利用el-upload组件选择上传的图片，并利用其http-request属性来自定义函数来实现文件上传请求：该请求函数使用七牛云的对象存储，在通过后端得到的上传凭证token后来实现文件上传。

阅读全文 »

发表于 分类于 Disqus： 本文字数： 392 阅读时长 ≈ 1 分钟

https://leetcode.cn/problems/palindrome-linked-list/

（1）将链表转化为数组进行比较

比较呆板的做法，空间复杂度为O(n)​。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Solution {
public:
    bool isPalindrome(ListNode* head) {
        vector<int> arr;
        ListNode* p = head;
        while (p) {
            arr.push_back(p->val);
            p = p->next;
        }
    
        int n = arr.size();
        for (int i = 0, j = n - 1; i < j; i++, j--) {
            if (arr[i] != arr[j])
                return false;
        }
        return true;
    }
};

（2）递归

链表也具有递归性质，二叉树也不过是链表的衍生。

利用后序遍历的思想：

先保存头结点（left，全局变量），然后递归至最后（最深）的结点（right），然后比较left​和right​的值；如果相等，由递归栈返回上一层（也即right向左走），再操作left向右走，这样就实现了left和right的双向奔赴。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Solution {
private:
    ListNode* left_ = nullptr;
  
    bool Traverse(ListNode* right) {
        if (!right)
            return true;
        bool res = Traverse(right->next);
        res = res && (left_->val == right->val);
        left_ = left_->next;
        return res;
    }

public:
    bool isPalindrome(ListNode* head) {
        left_ = head;
        return Traverse(head->next);
    }
};

（3）优化递归

利用方法二，看似是没有使用到额外空间了，但实际上还有递归所带来的函数调用栈的开销，其空间复杂度也为O(n)​。

因此可以利用双指针的思想，找到链表的中间结点后，将其后面的结点反转。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
using ListNodePtr = ListNode*;

class Solution {
private:
    ListNode* Reverse(ListNode* head) {
        ListNodePtr cur = head, pre = nullptr;
        while (cur) {
            ListNodePtr ne = cur->next;
            cur->next = pre;
            pre = cur;
            cur = ne;
        }
        return pre;
    }

public:
    bool isPalindrome(ListNode* head) {
        ListNodePtr fast = head, slow = head;
        while (fast && fast->next) {
            slow = slow->next;
            fast = fast->next->next;
        }
        if (fast)
            slow = slow->next;
    
        ListNodePtr left = head;
        ListNodePtr right = Reverse(slow);
        while (right) {
            if (left->val != right->val)
                return false;
            left = left->next;
            right = right->next;
        }
        return true;
    }
};
0%