秋招得物一面，被问麻了。。。

#include <iostream>
#include <vector>


using namespace std;


class FixedSizeQueue {
private:
    vector<int> data;    // 存储队列元素的数组
    int capacity;        // 队列的固定容量
    int front;           // 队列头指针
    int rear;            // 队列尾指针
    int size;            // 队列当前元素数量


public:
    FixedSizeQueue(int cap) : capacity(cap), front(0), rear(0), size(0) {
        data.resize(capacity);
    }


    // 入队操作，时间复杂度O(1)
    void push(int value) {
        if (isFull()) {
            cout << "队列已满，无法入队。" << endl;
            return;
        }


        data[rear] = value;
        rear = (rear + 1) % capacity;
        size++;
    }


    // 出队操作，时间复杂度O(1)
    void pop() {
        if (isEmpty()) {
            cout << "队列为空，无法出队。" << endl;
            return;
        }


        front = (front + 1) % capacity;
        size--;
    }


    // 获取队列头部元素，时间复杂度O(1)
    int frontValue() {
        if (isEmpty()) {
            cout << "队列为空，无法获取头部元素。" << endl;
            return -1; // 返回一个特殊值表示队列为空
        }


        return data[front];
    }


    // 检查队列是否为空，时间复杂度O(1)
    bool isEmpty() {
        return size == 0;
    }


    // 检查队列是否已满，时间复杂度O(1)
    bool isFull() {
        return size == capacity;
    }
};


int main() {
    int capacity = 5;
    FixedSizeQueue queue(capacity);


    cout << "入队操作：" << endl;
    for (int i = 1; i <= capacity + 1; ++i) {
        if (!queue.isFull()) {
            cout << "入队元素: " << i << endl;
            queue.push(i);
        } else {
            cout << "队列已满，无法入队元素 " << i << endl;
        }
    }


    cout << "出队操作：" << endl;
    while (!queue.isEmpty()) {
        cout << "出队元素: " << queue.frontValue() << endl;
        queue.pop();
    }


    return 0;
}

1. 内存访问越界
1. 由于使用错误的下标，导致数组访问越界；
2. 搜索字符串时，依靠字符串结束符来判断字符串是否结束，但是字符串没有正常的使用结束符；
3. 使用strcpy, strcat, sprintf, strcmp, strcasecmp等字符串操作函数，将目标字符串读/写爆。应该使用strncpy, strlcpy, strncat, strlcat, snprintf, strncmp, strncasecmp等函数防止读写越界。
2. 多线程程序使用了线程不安全的函数。
3. 多线程读写的数据未加锁保护。对于会被多个线程同时访问的全局数据，应该注意加锁保护，否则很容易造成core dump。
4. 非法指针，比如说空指针。。。
5. 堆栈溢出。不要使用大的局部变量（因为局部变量都分配在栈上），这样容易造成堆栈溢出，破坏系统的栈和堆结构，导致出现莫名其妙的错误。

1. 检查指针是否被正确初始化和使用，并确保不越界。
2. 检查代码中是否存在内存泄漏，并在分配内存后及时释放内存。
3. 检查函数调用嵌套层数和在栈上分配的内存大小，避免栈溢出。
4. 使用调试工具，如gdb，在程序崩溃时捕获core dump文件，并分析该文件以确定错误原因。
5. 在程序开发和测试过程中，尽可能使用静态代码分析工具和动态内存分析工具，检查和预防程序错误。

backtrace
或者
bt

info threads

thread <num> 

• 互斥条件：至少有一个资源是排他性的，即一次只能由一个进程（线程）占用。这意味着其他进程无法同时访问该资源。
• 持有与等待条件：一个进程（线程）可以持有一些资源并等待获取其他资源，同时不释放已经持有的资源。
• 不可剥夺条件：资源不能被强制性地从一个进程（线程）中抢占，只能由占用资源的进程主动释放。
• 循环等待条件：一组进程之间存在循环等待资源的关系，每个进程都等待另一个进程所持有的资源。

• 线程A获取资源X，然后进入临界区，执行一些操作，但在操作完成前不会释放资源X。
• 同时，线程B获取资源Y，然后进入临界区，执行一些操作，但在操作完成前不会释放资源Y。
• 线程A现在尝试获取资源Y，但由于线程B已经持有资源Y，所以线程A被阻塞，无法继续执行。
• 同样，线程B也尝试获取资源X，但由于线程A已经持有资源X，所以线程B也被阻塞，无法继续执行。

• 资源分配顺序：一种常见的方法是规定所有线程必须按照相同的顺序请求资源。比方说，如果一个线程需要首先锁定资源A，然后才能请求资源B，那么所有线程都必须按照相同的顺序来请求这两个资源。这种方法可以破坏循环等待条件。
• 超时和重试：允许线程在一段时间内等待资源，但如果等待超过了某个时间限制，线程将放弃等待，并可以选择重试或回退操作。这可以防止线程永久阻塞，尽管它可能会导致一些操作的失败和重试。
• 资源分级：将资源划分为多个级别，每个级别有一个获取的顺序。线程只能请求比它当前拥有的级别更高的资源。这种方法可以减少死锁的可能性。
• 死锁检测和恢复：周期性地检测系统中是否存在死锁。如果检测到死锁，可以采取措施来中断其中一个或多个线程，以解除死锁。这种方法可能会引入一些性能开销，但可以保证系统的可用性。
• 避免共享资源：通过设计避免共享资源，或者尽量减少资源共享，可以降低死锁的可能性。这可以通过使用副本而不是共享数据，或者通过使用消息传递来实现。
• 使用同步工具：使用更高级的同步工具，如信号量、互斥锁、条件变量等，可以更容易地避免死锁。这些工具通常提供了更复杂的同步操作，允许更精细的控制资源的分配和释放。

• 原子性：指的是事务包含的所有操作要么全部成功，要么全部失败回滚，因此事务的操作如果成功就必须要完全应用到数据库，如果操作失败则不能对数据库有任何影响。
• 一致性：指的是事务必须使数据库从一个一致性状态变换到另一个一致性状态，也就是说一个事务执行之前和执行之后都必须处于一致性状态。
• 隔离性：同一时间，只允许一个事务请求同一数据，不同的事务之间彼此没有任何干扰。
• 持久性：事务完成后，事务对数据库的所有更新将被保存到数据库，不能回滚。

• 读未提交：
• 最低的隔离级别，事务中的修改操作对其他事务是可见的，即未提交的修改可以被其他事务读取。
• 存在脏读问题，即一个事务读取到了另一个未提交事务的修改结果。
• 读提交：
• 事务中的修改操作在提交之前对其他事务是不可见的，只有已提交的修改才能被其他事务读取。
• 解决了脏读问题，但可能存在不可重复读问题，即在同一事务内多次读取同一数据可能会得到不同的结果。
• 可重复读：
• 保证在同一事务内多次读取同一数据时，得到的结果始终一致。
• 解决了不可重复读问题，但可能存在幻读问题，即在同一事务内多次执行查询，得到的结果集不一致。
• 串行化：
• 最高的隔离级别，完全隔离事务，确保事务串行执行，避免并发问题。
• 解决了幻读问题，但在高并发情况下会导致性能下降，因为事务需要串行执行。

• 聚簇索引叶子节点存储的是行数据；而非聚簇索引叶子节点存储的是聚簇索引（通常是主键 ID）。
• 聚簇索引查询效率更高，而非聚簇索引需要进行回表查询，因此性能不如聚簇索引。
• 聚簇索引一般为主键索引，而主键一个表中只能有一个，因此聚簇索引一个表中也只能有一个，而非聚簇索引则没有数量上的限制。

SELECT 班级, 
   SUM(CASE WHEN 性别 = '男' THEN 1 ELSE 0 END) AS 男生人数,
   SUM(CASE WHEN 性别 = '女' THEN 1 ELSE 0 END) AS 女生人数
FROM 学生表
GROUP BY 班级;

#include <iostream>
#include <vector>


using namespace std;


void quickSort(vector<int>& nums, int left, int right) {
    if (left >= right) return;


    int pivot = nums[left]; // 选取基准数
    int i = left, j = right;


    while (i < j) {
        // 从右往左找到第一个小于基准数的元素
        while (i < j && nums[j] >= pivot) j--;
        if (i < j) nums[i++] = nums[j]; // 将该元素移到基准数左侧


        // 从左往右找到第一个大于基准数的元素
        while (i < j && nums[i] < pivot) i++;
        if (i < j) nums[j--] = nums[i]; // 将该元素移到基准数右侧
    }


    nums[i] = pivot; // 将基准数放回中间位置


    // 对基准数左侧和右侧的子数组分别递归调用快排
    quickSort(nums, left, i - 1);
    quickSort(nums, i + 1, right);
}


int main() {
    vector<int> nums = { 3, 7, 2, 9, 1, 5, 8, 4, 6 };
    quickSort(nums, 0, nums.size() - 1);


    for (int i = 0; i < nums.size(); i++) {
        cout << nums[i] << " ";
    }
    cout << endl;


    return 0;
}

void quickSort(vector<int>& nums) {
    if (nums.empty()) {
        return;
    }
    stack<int> s;
    int left = 0, right = nums.size() - 1;
    s.push(left);
    s.push(right);
    while (!s.empty()) {
        right = s.top();
        s.pop();
        left = s.top();
        s.pop();
        int pivot = nums[left];
        int i = left, j = right;
        while (i < j) {
            while (i < j && nums[j] >= pivot) {
                j--;
            }
            if (i < j) {
                nums[i++] = nums[j];
            }
            while (i < j && nums[i] < pivot) {
                i++;
            }
            if (i < j) {
                nums[j--] = nums[i];
            }
        }
        nums[i] = pivot;
        if (i - 1 > left) {
            s.push(left);
            s.push(i - 1);
        }
        if (i + 1 < right) {
            s.push(i + 1);
            s.push(right);
        }
    }
}