【C++八股文】数据结构篇

C语言小火车2025-09-05 20:37

一、单例模式优化实现

原代码问题分析
  1. 内存序重排序风险：双重检查锁在C++中可能因指令重排导致半初始化对象被访问
  2. 锁粒度过大：每次获取实例都需要加锁，影响性能
  3. 线程安全性不足：未考虑C++11前的内存模型问题
改进方案（C++11标准实现）
cpp 复制代码 
class Singleton {
public:
    static Singleton& getInstance() {
        static Singleton instance;  // C++11保证线程安全初始化
        return instance;
    }
private:
    Singleton() = default;
    ~Singleton() = default;
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
};

技术要点​：

  • 利用局部静态变量实现线程安全初始化（Meyers Singleton）
  • 禁用拷贝构造和赋值操作
  • 自动内存管理，无需手动释放

二、排序算法深度解析

1. 快速排序优化版
cpp 复制代码 
void quick_sort(int arr[], int l, int r) {
    if (l >= r) return;
    int pivot = arr[(l + r) / 2];  // 三数取中优化
    int i = l - 1, j = r + 1;
    while (i < j) {
        do i++; while (arr[i] < pivot);
        do j--; while (arr[j] > pivot);
        if (i < j) swap(arr[i], arr[j]);
    }
    quick_sort(arr, l, j);
    quick_sort(arr, j + 1, r);
}

优化点​：

  • 三数取中法选择基准值
  • 循环展开减少分支预测失败
2. 归并排序改进
cpp 复制代码 
void merge_sort(int arr[], int l, int r) {
    if (l >= r) return;
    int mid = l + (r - l) / 2;
    merge_sort(arr, l, mid);
    merge_sort(arr, mid + 1, r);
    
    vector<int> tmp(r - l + 1);
    int i = l, j = mid + 1, k = 0;
    while (i <= mid && j <= r) 
        tmp[k++] = (arr[i] < arr[j]) ? arr[i++] : arr[j++];
    while (i <= mid) tmp[k++] = arr[i++];
    while (j <= r) tmp[k++] = arr[j++];
    copy(tmp.begin(), tmp.end(), arr + l);
}

改进点​：

  • 使用vector临时存储避免全局数组
  • 尾递归优化减少栈空间消耗

三、KMP算法原理与实现

算法核心
  1. 前缀函数构建：
cpp 复制代码 
vector<int> computeLPS(const string& p) {
    int n = p.size();
    vector<int> lps(n, 0);
    for (int i = 1, len = 0; i < n; ) {
        if (p[i] == p[len]) lps[i++] = ++len;
        else if (len) len = lps[len-1];
        else lps[i++] = 0;
    }
    return lps;
}

2.​匹配过程​：

cpp 复制代码 
void kmp(const string& text, const string& pattern) {
    auto lps = computeLPS(pattern);
    int i = 0, j = 0;
    while (i < text.size()) {
        if (text[i] == pattern[j]) {
            i++; j++;
            if (j == pattern.size()) {
                cout << "Found at " << i - j << endl;
                j = lps[j-1];
            }
        } else if (j) j = lps[j-1];
        else i++;
    }
}

技术优势​：

  • 线性时间复杂度O(n+m)
  • 避免主串回溯

四、LRU缓存机制实现

数据结构设计
cpp 复制代码 
class LRUCache {
    struct Node {
        int key, val;
        Node* prev, *next;
        Node(int k, int v) : key(k), val(v), prev(nullptr), next(nullptr) {}
    };
public:
    LRUCache(int capacity) : cap(capacity) {
        head = new Node(-1, -1);
        tail = new Node(-1, -1);
        head->next = tail;
        tail->prev = head;
    }
    
    int get(int key) {
        if (cache.count(key)) {
            auto node = cache[key];
            moveToHead(node);
            return node->val;
        }
        return -1;
    }
    
    void put(int key, int val) {
        if (cache.count(key)) {
            auto node = cache[key];
            node->val = val;
            moveToHead(node);
        } else {
            if (cache.size() == cap) {
                auto last = tail->prev;
                removeNode(last);
                cache.erase(last->key);
                delete last;
            }
            auto newNode = new Node(key, val);
            addToHead(newNode);
            cache[key] = newNode;
        }
    }
private:
    unordered_map<int, Node*> cache;
    Node* head, *tail;
    int cap;
    
    void addToHead(Node* node) { /*...*/ }
    void removeNode(Node* node) { /*...*/ }
    void moveToHead(Node* node) { /*...*/ }
};

实现要点​：

  • 双向链表维护访问顺序
  • 哈希表实现O(1)查找
  • 虚拟头尾节点简化边界处理

五、字符串类安全实现

cpp 复制代码 
class SafeString {
public:
    SafeString(const char* str = "") {
        size_ = strlen(str);
        data_ = new char[size_ + 1];
        strncpy(data_, str, size_);
        data_[size_] = '\0';
    }
    
    SafeString(const SafeString& other) {
        size_ = other.size_;
        data_ = new char[size_ + 1];
        strcpy(data_, other.data_);
    }
    
    SafeString& operator=(const SafeString& other) {
        if (this != &other) {
            delete[] data_;
            size_ = other.size_;
            data_ = new char[size_ + 1];
            strcpy(data_, other.data_);
        }
        return *this;
    }
    
    ~SafeString() { delete[] data_; }
    
    char& operator[](size_t index) {
        if (index >= size_) throw out_of_range("");
        return data_[index];
    }
private:
    char* data_;
    size_t size_;
};

安全改进​：

  • 深拷贝避免浅拷贝问题
  • 边界检查防止越界访问
  • RAII内存管理

六、智能指针实现优化

cpp 复制代码 
template<typename T>
class SharedPtr {
    struct ControlBlock {
        size_t count;
        T* ptr;
        ControlBlock(T* p) : ptr(p), count(1) {}
    };
public:
    explicit SharedPtr(T* ptr = nullptr) 
        : control_(ptr ? new ControlBlock(ptr) : nullptr) {}
    
    SharedPtr(const SharedPtr& other) : control_(other.control_) {
        if (control_) ++control_->count;
    }
    
    SharedPtr& operator=(const SharedPtr& other) {
        if (this != &other) {
            release();
            control_ = other.control_;
            if (control_) ++control_->count;
        }
        return *this;
    }
    
    ~SharedPtr() { release(); }
    
    T* get() const { return control_ ? control_->ptr : nullptr; }
    size_t use_count() const { return control_ ? control_->count : 0; }
private:
    void release() {
        if (control_ && --control_->count == 0) {
            delete control_->ptr;
            delete control_;
        }
    }
    ControlBlock* control_;
};

关键改进​：

  • 控制块独立管理引用计数
  • 线程安全需增加原子操作
  • 支持自定义删除器

>>>C/C++入门及练手项目<<<

七、其他重要知识点补充

  1. ​main前执行函数​：
cpp 复制代码 
class Initializer {
public:
    Initializer() { /* main前执行代码 */ }
};
static Initializer init;

利用静态对象构造顺序特性[用户代码正确]

​2.管道通信优化​：

cpp 复制代码 
int pipefd[2];
if (pipe(pipefd) == -1) handle_error();
pid_t pid = fork();
if (pid == 0) { 
    close(pipefd[1]);  // 子进程关闭写端
    //... 
} else {
    close(pipefd[0]);  // 父进程关闭读端
    //...
}

增加错误处理和资源管理[用户代码正确]

3.​rand7生成rand10优化​：

cpp 复制代码 
int rand10() {
    int a = rand7(), b = rand7();
    int num = (a-1)*7 + b;  // 1-49均匀分布
    return (num <= 40) ? (num % 10 + 1) : rand10();  // 拒绝采样
}

八、技术对比与选型建议

数据结构/算法 时间复杂度 空间复杂度 适用场景 优化方向
快速排序 O(n log n) O(log n) 随机数据 三数取中+尾递归优化
归并排序 O(n log n) O(n) 链表/大文件 自底向上迭代实现
LRU缓存 O(1) O(capacity) 热点数据 多级缓存+预加载
KMP算法 O(n+m) O(m) 字符串匹配 BM算法替代

完整C++后端八股文：>> C++八股文（完整版）<<

相关推荐
Mr_WangAndy12 分钟前
C++设计模式_创建型模式_原型模式Prototype
c++·设计模式·原型模式
歪歪10015 分钟前
如何在SQLite中实现事务处理？
java·开发语言·jvm·数据库·sql·sqlite
奔跑吧邓邓子16 分钟前
【C++实战㊷】C++ 原型模式实战：从概念到高效应用
c++·实战·原型模式
瑶总迷弟19 分钟前
静默安装 Oracle Database 21c on CentOS 7.6
数据库·oracle·centos
LeaderSheepH31 分钟前
常见的排序算法
数据结构·算法·排序算法
奔跑吧邓邓子34 分钟前
【C++实战㊶】C++建造者模式：复杂对象构建的秘密武器
c++·实战·建造者模式
奔跑吧邓邓子1 小时前
【C++实战㊵】C++抽象工厂模式：解锁高效对象创建的密钥
c++·实战·抽象工厂模式
jf加菲猫2 小时前
条款11：优先选用删除函数，而非private未定义函数
开发语言·c++
博睿谷IT99_2 小时前
SQL SELECT 语句怎么用？COMPANY 表查询案例（含条件 / 模糊 / 分页）
数据库·sql·mysql
浅拾光º2 小时前
mysql字符串截取，如何在MySQL备份文件中安全截取敏感字符串？
数据库·mysql·安全
热门推荐
01Multisim使用教程详尽版--(2025最新版)02UV 工具安装与国内镜像源配置指南03GitHub 镜像站点0446个Nano-banana 精选提示词，持续更新中05Spec-Kit 使用指南06UV安装并设置国内源07保姆级教程：手把手教你用Dify实现完美多轮对话（附Chatflow和提示词）08VsCode远程Copilot无法使用Claude Agent问题092025年华为杯研赛数学建模竞赛C题完整参考论文 （含模型、MATLAB和Python代码）10Linux下V2Ray安装配置指南