深入解析内省排序：C++实现混合排序算法的终极指南

最新推荐文章于 2025-11-30 21:05:18 发布
原创 最新推荐文章于 2025-11-30 21:05:18 发布 · 795 阅读 · 10 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #排序算法

引言

在计算机科学中，排序算法是基础且至关重要的组成部分。面对不同的数据特性和规模，如何选择最合适的排序算法一直是个挑战。内省排序（IntroSort）应运而生，它由David Musser于1997年提出，巧妙地结合了三种经典排序算法的优势，成为C++ STL中std::sort的实现基础。

本文将深入剖析内省排序的核心原理，通过详细的C++实现解析，帮助中级开发者全面理解这一高效算法的内部机制。我们将从算法思想出发，逐步分析代码实现，并探讨其性能特性和实际应用价值。

算法原理详解

核心思想

内省排序是一种"三合一"的混合排序算法，其核心智慧在于根据不同的数据情况动态选择最优的排序策略：

  1. 快速排序为主力：在大多数情况下使用快速排序，利用其优秀的平均性能
  2. 堆排序为保险：当递归深度过大时切换到堆排序，避免快速排序的最坏情况
  3. 插入排序优化小数组：对于小规模数据使用插入排序，减少递归开销

算法执行流程

function introSort(arr, low, high, maxDepth):
    size = high - low + 1
    
    if size <= 16:
        insertionSort(arr, low, high)      # 小数组使用插入排序
        return
    
    if maxDepth == 0:
        heapSort(arr, low, high)           # 递归过深使用堆排序
        return
    
    pivotIndex = partition(arr, low, high) # 快速排序分区
    introSort(arr, low, pivotIndex-1, maxDepth-1)
    introSort(arr, pivotIndex+1, high, maxDepth-1)

这种智能的切换机制确保了算法在各种情况下都能保持优异的性能。

C++实现逐行解析

公共接口设计

template<typename T>
static void sort(T arr[], int size) {
    if (size <= 1) return;
    
    // 计算最大递归深度限制：2 * log2(n)
    int maxDepth = 2 * static_cast<int>(std::log2(size));
    
    // 调用内省排序的核心递归函数
    introSort(arr, 0, size - 1, maxDepth);
}

设计考量：

  • 模板设计支持泛型编程，可排序任意可比较类型
  • 递归深度限制公式 2 * log₂(n) 经过实践验证，能有效平衡性能
  • 边界情况处理：数组大小≤1时直接返回

核心递归函数

template<typename T>
static void introSort(T arr[], int low, int high, int maxDepth) {
    int size = high - low + 1;
    
    // 小数组优化：插入排序的常数因子更小
    if (size <= 16) {
        insertionSort(arr, low, high);
        return;
    }
    
    // 递归深度保护：避免快速排序的最坏情况
    if (maxDepth == 0) {
        heapSort(arr, low, high);
        return;
    }
    
    // 快速排序分区
    int pivotIndex = partition(arr, low, high);
    
    // 递归处理子数组，深度减1
    introSort(arr, low, pivotIndex - 1, maxDepth - 1);
    introSort(arr, pivotIndex + 1, high, maxDepth - 1);
}

关键技巧：

  • 阈值16的选择基于大量实验，在小数组上插入排序效率更高
  • 每次递归深度减1，确保算法不会无限递归

快速排序分区实现

template<typename T>
static int partition(T arr[], int low, int high) {
    // Lomuto分区方案：选择最后一个元素作为基准
    T pivot = arr[high];
    
    // i指向小于基准的元素的边界
    int i = low - 1;
    
    for (int j = low; j < high; j++) {
        if (arr[j] <= pivot) {
            i++;
            std::swap(arr[i], arr[j]);
        }
    }
    
    // 将基准元素放到正确的位置
    std::swap(arr[i + 1], arr[high]);
    return i + 1;
}

Lomuto分区特点：

  • 实现简单，逻辑清晰
  • 相比Hoare分区，可能进行更多交换操作
  • 基准选择策略可以优化（如三数取中）

插入排序优化小数组

template<typename T>
static void insertionSort(T arr[], int low, int high) {
    for (int i = low + 1; i <= high; i++) {
        T key = arr[i];
        int j = i - 1;
        
        // 将大于key的元素向后移动
        while (j >= low && arr[j] > key) {
            arr[j + 1] = arr[j];
            j--;
        }
        
        // 插入key到正确位置
        arr[j + 1] = key;
    }
}

优势分析：

  • 小数组上常数因子小，实际运行速度快
  • 对于部分有序数组表现优异
  • 原地排序，空间复杂度O(1)

堆排序保障最坏情况

template<typename T>
static void heapSort(T arr[], int low, int high) {
    int size = high - low + 1;
    
    // 构建最大堆：从最后一个非叶子节点开始调整
    for (int i = low + size / 2 - 1; i >= low; i--) {
        heapify(arr, low, high, i);
    }
    
    // 逐个提取堆顶元素
    for (int i = high; i > low; i--) {
        std::swap(arr[low], arr[i]);  // 将最大值移到末尾
        heapify(arr, low, i - 1, low); // 调整剩余堆
    }
}

堆化函数关键点：

template<typename T>
static void heapify(T arr[], int low, int high, int root) {
    int largest = root;
    // 计算左右子节点索引，考虑子数组偏移
    int left = 2 * (root - low) + 1 + low;
    int right = 2 * (root - low) + 2 + low;
    
    // 找到根、左、右中的最大值
    if (left <= high && arr[left] > arr[largest])
        largest = left;
    if (right <= high && arr[right] > arr[largest])
        largest = right;
    
    // 如果需要调整，递归堆化
    if (largest != root) {
        std::swap(arr[root], arr[largest]);
        heapify(arr, low, high, largest);
    }
}

复杂度分析

时间复杂度

  • 最好情况：O(n log n)

    • 快速排序在理想分区情况下的表现
    • 插入排序在小数组上的优秀性能

  • 平均情况：O(n log n)

    • 快速排序的平均情况主导
    • 混合策略确保不会退化

  • 最坏情况：O(n log n)

    • 堆排序保障了性能下限
    • 避免了快速排序的O(n²)最坏情况

空间复杂度

  • 总体空间：O(log n)

    • 主要来自快速排序的递归调用栈
    • 堆排序和插入排序都是原地排序

  • 递归深度：受限于2 * log₂(n)，确保栈空间可控

优势与局限性

优势

  1. 性能稳定：结合三种算法优点，在各种情况下表现良好
  2. 避免最坏情况：堆排序作为安全网，防止性能急剧下降
  3. 实用性强：被C++标准库采用，经过充分实践检验
  4. 自适应能力：根据数据特征自动选择最优策略

局限性

  1. 实现复杂：需要维护三种排序算法，代码量较大
  2. 常数因子：相比纯快速排序，在某些情况下可能有稍大的常数开销
  3. 递归开销：深度递归可能在某些环境下造成栈溢出

总结与扩展

核心要点回顾

内省排序代表了混合排序算法的设计哲学：没有完美的算法，只有合适的策略。通过智能地结合快速排序、堆排序和插入排序，它实现了在理论保证和实际性能之间的完美平衡。

扩展思考

  1. 优化方向：

    • 改进基准选择策略（三数取中、随机化）
    • 动态调整插入排序的阈值
    • 实现迭代版本避免递归开销

  2. 与其他算法比较：

    • 相比Timsort：内省排序更通用，Timsort对现实世界数据更优化
    • 相比纯快速排序：牺牲少量平均性能换取稳定性
    • 相比归并排序：空间效率更高，但稳定性稍差

  3. 实践建议：

    • 在不确定数据特性时，内省排序是安全选择
    • 对于特定模式的数据，可考虑专门优化的算法
    • 理解算法原理有助于在实际中做出更好的选择

内省排序的智慧启示我们：在工程实践中，有时最好的解决方案不是寻找"完美"的算法，而是构建能够根据情况自适应调整的智能系统。这种思想不仅适用于排序算法，也适用于更广泛的软件工程领域。

#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>

/**
 * @class IntroSort
 * @brief 实现内省排序算法的类
 * 
 * 内省排序（IntroSort）是一种混合排序算法，由David Musser于1997年提出。
 * 它结合了快速排序、堆排序和插入排序的优点，在各种情况下都能保持良好的性能。
 * 
 * 内省排序的核心思想：
 * 1. 主要使用快速排序进行分区
 * 2. 当递归深度过大时（可能遇到最坏情况），切换到堆排序
 * 3. 对于小数组（通常小于16个元素），使用插入排序
 * 
 * 算法流程：
 * 1. 检查数组大小，如果很小则使用插入排序
 * 2. 计算最大递归深度限制（通常为 2 * log2(n)）
 * 3. 调用内省排序的核心递归函数
 * 4. 在递归过程中，如果深度超过限制，切换到堆排序
 * 5. 否则使用快速排序进行分区
 * 
 * 时间复杂度分析：
 * - 最好情况：O(n log n) - 快速排序的平均情况
 * - 最坏情况：O(n log n) - 切换到堆排序保证
 * - 平均情况：O(n log n)
 * 
 * 空间复杂度：O(log n) - 递归栈空间
 * 
 * 优点：
 * - 避免快速排序的最坏情况 O(n²)
 * - 在实际应用中性能优秀
 * - 是C++ STL中std::sort的实现基础
 */

 /**
    1.根节点存储在索引 0 的位置。
    2.对于数组中任意一个索引为 i 的节点：
      它的左子节点的索引为：2 * i + 1
      它的右子节点的索引为：2 * i + 2
      它的父节点的索引为：floor((i - 1) / 2) （在整数除法下，等同于 (i - 1) // 2）
  */
class IntroSort {
public:
    /**
     * @brief 使用内省排序算法对数组进行排序（升序）
     * @tparam T 数组中元素的类型（必须支持比较运算符）
     * @param arr 要排序的数组
     * @param size 数组的大小
     */
    template<typename T>
    static void sort(T arr[], int size) {
        if (size <= 1) return;
        
        // 计算最大递归深度限制：2 * log2(n)
        int maxDepth = 2 * static_cast<int>(std::log2(size));
        
        // 调用内省排序的核心递归函数
        introSort(arr, 0, size - 1, maxDepth);
    }

    /**
     * @brief 使用内省排序算法对向量进行排序（升序）
     * @tparam T 向量中元素的类型（必须支持比较运算符）
     * @param vec 要排序的向量
     */
    template<typename T>
    static void sort(std::vector<T>& vec) {
        if (vec.size() <= 1) return;
        
        int size = vec.size();
        int maxDepth = 2 * static_cast<int>(std::log2(size));
        
        introSort(vec, 0, size - 1, maxDepth);
    }

    /**
     * @brief 打印数组的元素
     * @tparam T 数组中元素的类型
     * @param arr 要打印的数组
     * @param size 数组的大小
     */
    template<typename T>
    static void printArray(const T arr[], int size) {
        for (int i = 0; i < size; i++) {
            std::cout << arr[i];
            if (i < size - 1) std::cout << ", ";
        }
        std::cout << std::endl;
    }

    /**
     * @brief 打印向量的元素
     * @tparam T 向量中元素的类型
     * @param vec 要打印的向量
     */
    template<typename T>
    static void printVector(const std::vector<T>& vec) {
        for (size_t i = 0; i < vec.size(); i++) {
            std::cout << vec[i];
            if (i < vec.size() - 1) std::cout << ", ";
        }
        std::cout << std::endl;
    }

private:
    /**
     * @brief 内省排序的核心递归函数（数组版本）
     * @tparam T 元素的类型
     * @param arr 要排序的数组
     * @param low 当前子数组的起始索引
     * @param high 当前子数组的结束索引
     * @param maxDepth 最大递归深度限制
     * 
     * 算法步骤：
     * 1. 如果子数组很小，使用插入排序
     * 2. 如果递归深度为0，切换到堆排序
     * 3. 否则使用快速排序进行分区
     */
    template<typename T>
    static void introSort(T arr[], int low, int high, int maxDepth) {
        // 计算当前子数组的大小
        int size = high - low + 1;
        
        // 如果子数组很小，使用插入排序（阈值通常设为16）
        if (size <= 16) {
            insertionSort(arr, low, high);
            return;
        }
        
        // 如果递归深度为0，切换到堆排序以避免最坏情况
        if (maxDepth == 0) {
            heapSort(arr, low, high);
            return;
        }
        
        // 使用快速排序进行分区
        int pivotIndex = partition(arr, low, high);
        
        // 递归排序左半部分和右半部分，深度减1
        introSort(arr, low, pivotIndex - 1, maxDepth - 1);
        introSort(arr, pivotIndex + 1, high, maxDepth - 1);
    }

    /**
     * @brief 内省排序的核心递归函数（向量版本）
     * @tparam T 元素的类型
     * @param vec 要排序的向量
     * @param low 当前子向量的起始索引
     * @param high 当前子向量的结束索引
     * @param maxDepth 最大递归深度限制
     */
    template<typename T>
    static void introSort(std::vector<T>& vec, int low, int high, int maxDepth) {
        int size = high - low + 1;
        
        if (size <= 16) {
            insertionSort(vec, low, high);
            return;
        }
        
        if (maxDepth == 0) {
            heapSort(vec, low, high);
            return;
        }
        
        int pivotIndex = partition(vec, low, high);
        
        introSort(vec, low, pivotIndex - 1, maxDepth - 1);
        introSort(vec, pivotIndex + 1, high, maxDepth - 1);
    }

    /**
     * @brief 快速排序的分区函数（数组版本）
     * @tparam T 元素的类型
     * @param arr 要分区的数组
     * @param low 分区起始索引
     * @param high 分区结束索引
     * @return 分区后基准元素的最终位置
     * 
     * 分区过程（Lomuto分区方案）：
     * 1. 选择最后一个元素作为基准
     * 2. 维护一个索引i，表示小于基准的元素的边界
     * 3. 遍历数组，将小于基准的元素交换到i的位置
     * 4. 最后将基准元素放到正确的位置
     */
    template<typename T>
    static int partition(T arr[], int low, int high) {
        // 选择最后一个元素作为基准
        T pivot = arr[high];
        
        // i指向小于基准的元素的边界
        int i = low - 1;
        
        // 遍历数组，将小于基准的元素交换到左边
        for (int j = low; j < high; j++) {
            if (arr[j] <= pivot) {
                i++;
                std::swap(arr[i], arr[j]);
            }
        }
        
        // 将基准元素放到正确的位置
        std::swap(arr[i + 1], arr[high]);
        return i + 1;
    }

    /**
     * @brief 快速排序的分区函数（向量版本）
     * @tparam T 元素的类型
     * @param vec 要分区的向量
     * @param low 分区起始索引
     * @param high 分区结束索引
     * @return 分区后基准元素的最终位置
     */
    template<typename T>
    static int partition(std::vector<T>& vec, int low, int high) {
        T pivot = vec[high];
        int i = low - 1;
        
        for (int j = low; j < high; j++) {
            if (vec[j] <= pivot) {
                i++;
                std::swap(vec[i], vec[j]);
            }
        }
        
        std::swap(vec[i + 1], vec[high]);
        return i + 1;
    }

    /**
     * @brief 插入排序（数组版本）- 用于小数组
     * @tparam T 元素的类型
     * @param arr 要排序的数组
     * @param low 子数组起始索引
     * @param high 子数组结束索引
     * 
     * 插入排序算法：
     * 1. 从第二个元素开始（索引low+1）
     * 2. 将当前元素插入到前面已排序部分的正确位置
     * 3. 重复直到所有元素都排序完成
     * 
     * 对于小数组，插入排序通常比快速排序更快，因为它的常数因子较小。
     */
    template<typename T>
    static void insertionSort(T arr[], int low, int high) {
        for (int i = low + 1; i <= high; i++) {
            T key = arr[i];
            int j = i - 1;
            
            // 将大于key的元素向后移动
            while (j >= low && arr[j] > key) {
                arr[j + 1] = arr[j];
                j--;
            }
            
            // 插入key到正确位置
            arr[j + 1] = key;
        }
    }

    /**
     * @brief 插入排序（向量版本）- 用于小数组
     * @tparam T 元素的类型
     * @param vec 要排序的向量
     * @param low 子向量起始索引
     * @param high 子向量结束索引
     */
    template<typename T>
    static void insertionSort(std::vector<T>& vec, int low, int high) {
        for (int i = low + 1; i <= high; i++) {
            T key = vec[i];
            int j = i - 1;
            
            while (j >= low && vec[j] > key) {
                vec[j + 1] = vec[j];
                j--;
            }
            
            vec[j + 1] = key;
        }
    }

    /**
     * @brief 堆排序（数组版本）- 当递归深度过大时使用
     * @tparam T 元素的类型
     * @param arr 要排序的数组
     * @param low 子数组起始索引
     * @param high 子数组结束索引
     * 
     * 堆排序保证在最坏情况下也有O(n log n)的时间复杂度，
     * 用于避免快速排序的最坏情况。
     */
    template<typename T>
    static void heapSort(T arr[], int low, int high) {
        int size = high - low + 1;
        
        // 构建最大堆
        // 最后一个非叶子节点开始，从右至左、从下至上地进行调整
        for (int i = low + size / 2 - 1; i >= low; i--) {
            heapify(arr, low, high, i);
        }
        
        // 逐个提取堆顶元素
        for (int i = high; i > low; i--) {
            std::swap(arr[low], arr[i]);
            heapify(arr, low, i - 1, low);
        }
    }

    /**
     * @brief 堆排序（向量版本）- 当递归深度过大时使用
     * @tparam T 元素的类型
     * @param vec 要排序的向量
     * @param low 子向量起始索引
     * @param high 子向量结束索引
     */
    template<typename T>
    static void heapSort(std::vector<T>& vec, int low, int high) {
        int size = high - low + 1;
        
        for (int i = low + size / 2 - 1; i >= low; i--) {
            heapify(vec, low, high, i);
        }
        
        for (int i = high; i > low; i--) {
            std::swap(vec[low], vec[i]);
            heapify(vec, low, i - 1, low);
        }
    }

    /**
     * @brief 堆化调整函数（数组版本）
     * @tparam T 元素的类型
     * @param arr 要堆化的数组
     * @param low 堆的起始索引
     * @param high 堆的结束索引
     * @param root 当前要堆化的根节点索引
     */
    template<typename T>
    static void heapify(T arr[], int low, int high, int root) {
        int largest = root;
        int left = 2 * (root - low) + 1 + low;   // 左子节点索引
        int right = 2 * (root - low) + 2 + low;  // 右子节点索引
        
        // 检查左子节点是否在范围内且大于当前最大值
        if (left <= high && arr[left] > arr[largest]) {
            largest = left;
        }
        
        // 检查右子节点是否在范围内且大于当前最大值
        if (right <= high && arr[right] > arr[largest]) {
            largest = right;
        }
        
        // 如果最大值不是根节点，则交换并递归堆化
        if (largest != root) {
            std::swap(arr[root], arr[largest]);
            heapify(arr, low, high, largest);
        }
    }

    /**
     * @brief 堆化调整函数（向量版本）
     * @tparam T 元素的类型
     * @param vec 要堆化的向量
     * @param low 堆的起始索引
     * @param high 堆的结束索引
     * @param root 当前要堆化的根节点索引
     */
    template<typename T>
    static void heapify(std::vector<T>& vec, int low, int high, int root) {
        int largest = root;
        int left = 2 * (root - low) + 1 + low;
        int right = 2 * (root - low) + 2 + low;
        
        if (left <= high && vec[left] > vec[largest]) {
            largest = left;
        }
        
        if (right <= high && vec[right] > vec[largest]) {
            largest = right;
        }
        
        if (largest != root) {
            std::swap(vec[root], vec[largest]);
            heapify(vec, low, high, largest);
        }
    }
};
go语言：实现intro sort内省排序算法(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
01-10 142
go语言：实现intro sort内省排序算法(附完整源码)
Python:实现intro sort内省排序算法(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
08-05 389
Python:实现intro sort内省排序算法(附完整源码)
【数据结构与算法-Day 43】深入剖析快速排序（下）：随机化、三路快排与工程应用
吴师兄大模型的博客
10-15 1797
标准的快速排序并非完美，它在特定输入下存在性能瓶颈，甚至会退化到与冒泡排序相当的效率。本文将作为快速排序的进阶篇，深入探讨其性能软肋，并引入两种至关重要的优化策略：**随机化 Pivot** 和 **三路快排**。我们将通过图解、代码和场景分析，彻底搞懂如何让快速排序在各种情况下都能保持“快”的本色，并最终探讨其在工程实践中的地位和选择。
全面掌握排序算法：从基础到高级的实战指南
weixin_42601134的博客
11-24 402
排序的本质是什么？不是代码，不是循环，也不是交换。它的核心在于建立可比较关系，让混沌的数据变得有序、可预测、可检索。举个生活化的例子：当你整理衣柜时，你会按照颜色、季节或使用频率来摆放衣物。这种行为本身就是一种“排序”。只不过在程序世界中，我们的“衣服”变成了整数、字符串甚至复杂对象，而“分类方式”则由比较函数定义。但问题来了：为什么不能所有场景都用或解决呢？毕竟现代语言库已经非常强大。答案是：因为通用性与极致优化之间永远存在权衡。
游戏编程精粹目录
热门推荐
长歌行
02-19 1万+
游戏编程精粹1   第1章　通用编程技术 1.0　神奇的数据驱动设计(Steve Rabin)　3 1.0.1　点子1——基础　3 1.0.2　点子2——最低标准　3 1.0.3　点子3——杜绝硬编码　3 1.0.4　点子4——将控制流写成脚本　4 1.0.5　点子5——什么时候不适合使用脚本？　5 1.0.6　点子6——避免重复数据　5 1.0.7　点子7——开发工具来生成数
游戏编程精粹 目录
冬泳的博客
08-23 4865
游戏编程精粹1   第1章　通用编程技术 1.0　神奇的数据驱动设计(Steve Rabin)　3 1.0.1　点子1——基础　3 1.0.2　点子2——最低标准　3 1.0.3　点子3——杜绝硬编码　3 1.0.4　点子4——将控制流写成脚本　4 1.0.5　点子5——什么时候不适合使用脚本？　5 1.0.6　点子6——避免重复数据　5 1.0.7　点子7——开发工具来生成数据　6 1.0....
C++实现快速排序算法：深入理解算法导论
用C++实现一下加深理解”，可以明确该文件的核心内容是基于《算法导论》（Introduction to Algorithms）一书中对快速排序的理论阐述，使用C++语言进行实际编程实现，旨在通过动手编码来深入掌握快速排序的工作机制、...
c++使用自带的排序算法来排序
weixin_74009895的博客
09-03 467
c++使用自带的排序算法来排序
C++ 快速排序算法：从原理到优化的实战指南
a13458980905的博客
07-24 846
快速排序是 C++ 算法中的基础且重要的知识点，掌握其原理不仅能应对面试和算法竞赛，更能理解 “分治” 思想在复杂问题中的应用。优先使用 std::sort（兼顾性能和稳定性）；需自定义排序逻辑时，可基于快排思想实现，并结合三数取中、插入排序等优化；处理特殊数据（如全重复、几乎有序）时，针对性选择三路快排或其他算法。通过本文的实现与优化分析，希望能帮助你从 “会用” 快排进阶到 “理解并优化” 快排，在面对不同场景时做出最佳选择。参考资料。
C++课后习题训练记录Day38
zmzb0103的博客
11-29 310
在蓝桥云课中选择课程《16届蓝桥杯省赛无忧班（C&C++ 组）4期》，选择第一章中“竞赛常用库函数”课程7并开始练习。输入一个字符，判断其为大写还是小写，若为大写则转换为小写，若为小写则转换为大写，输出转换后的值。（3）练习心得：注意每段代码末尾的分号是否存在，如不存在则需即使补充；对此代码进行检验，检验后无报错，提交此代码，判题结果为正确100分。是否切换为英语模式；
STL和string实现
最新发布
An15294874732的博客
11-30 844
标准模板库。
C++ 实操
淡水瑜的博客
11-28 362
编译 C++ 代码需要依赖gcc/g++这类编译器程序（MinGW-w64、TDM-GCC 都是 Windows 下常用的免费 C++ 编译器）。2、插件2 ： 搜索安装 C/C++ Compile Run，插件右上方，配置settings修改对应路径。1、插件1 ：搜索安装 C/C++（Microsoft Official）3、配置环境变量 PATH，新增C:\mingw64\bin。2、解压后，放到路径 C:\mingw64。Windows 64位系统。Vscode IDE工具。
【C语言】struct结构体内存对齐和位段（超详解）
zore__的博客
11-30 1184
本文详细介绍了C语言中结构体的概念和使用方法。结构体是自定义数据类型，用于描述现实中的复杂对象，如学生信息包含姓名、年龄、成绩等不同类型数据。文章讲解了结构体的声明、定义、初始化方法，以及通过点操作符(.)和箭头操作符(->)访问结构体成员的方式。此外还介绍了结构体数组和结构体指针的使用场景，展示了如何用结构体存储和处理多个同类型数据。这些知识对理解和使用C语言中的复杂数据类型非常有帮助。
C++ -- STL【string的使用】
2301_80059080的博客
11-28 321
摘要：本文详细介绍了C++中的STL(标准模板库)及其字符串处理组件string类。首先对比了C语言字符数组和C++ string类的区别，突出string类的便捷性。然后重点讲解了string类的核心功能： 迭代器操作；多种初始化方式；容量操作；三种遍历方式(下标、迭代器、范围for)；修改操作；其他实用功能(find/substr/c_str等)。通过代码示例展示了string类的各种用法，并比较了不同操作的效率差异，为C++字符串处理提供了全面的参考。
openpnp - 汇川IS620PS2R8I-IAB-C的参数设置和调整
谢绝(无视)留言与私信
11-30 500
手头订制的openpnp设备精度太差了，在解决X轴丝杠齿隙的问题。首先解决了固定问题引起的物理齿隙问题(openpnp - 消除滚珠丝杠物理齿隙的方法此时，用openpnp标定X轴齿隙，还是有齿隙。在openpnp没有标定齿隙之前，控制X轴在顶部相机下运动，顶部相机下有钢尺做参照。发现，X轴丝杠有过冲的情况发生。如果openpnp在X轴丝杠过冲还没结束时，就拍照做比对，那就发生了由测量操作引起的所谓齿隙。这个“测量引起的齿隙”并不是真正的丝杠物理齿隙。
【C++—STL】set和map的使用
lxd050925的博客
11-27 808
本文系统介绍了C++ STL中的关联式容器set和map系列。主要内容包括：1. 对比序列式容器和关联式容器的区别，阐述关联式容器的非线性结构特点；2. 详细讲解set类的构造、迭代器、增删查操作，以及multiset与set的差异；3. 深入分析map类的使用，包括pair类型、构造遍历、增删查改，重点解析operator[]的多功能实现；4. 通过两个数组交集、环形链表检测、随机链表复制等例题展示实际应用。并提供了丰富的代码示例和多种解题思路。
二叉树（C语言，手撕）
weixin_51226647的博客
11-24 594
二叉树（C语言，手撕）
C++14新特性_第一章C++语言特性_Lambda初始化捕获，decltype(auto)
weixin_43916755的博客
11-29 404
总结C++14的初始化捕获，它就是对C++11Lambda功能上的扩充，是一次“升级”，这使得Lambda更好用了。
C++篇（22）LRU Cache
seanmooPercy的博客
11-30 328
LRU Cache
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值