1 左右值概念
2 结构体定义
3 const作用
给一个这样的例子 const成员函数：保证不会修改对象的状态，可以在 const对象上调用。
4排序算法
选择排序
#include <iostream>
#include <vector>
void selectionSort(std::vector<int>& arr) {
int n = arr.size();
for (int i = 0; i < n - 1; ++i) { // 外层循环控制已排序部分的末尾
int minIndex = i; // 假设当前未排序部分的第一个元素是最小的
for (int j = i + 1; j < n; ++j) { // 内层循环找到未排序部分的最小元素
if (arr[j] < arr[minIndex]) {
minIndex = j;
}
}
std::swap(arr[i], arr[minIndex]); // 将最小元素放到已排序部分的末尾
}
}
int main() {
std::vector<int> arr = {64, 25, 12, 22, 11};
selectionSort(arr);
for (int num : arr) {
std::cout << num << " ";
}
// 输出: 11 12 22 25 64
return 0;
}
#include <iostream>
#include <vector>
void insertionSort(std::vector<int>& arr) {
int n = arr.size();
for (int i = 1; i < n; ++i) { // 从第二个元素开始
int key = arr[i]; // 当前待插入元素
int j = i - 1;
// 将比 key 大的元素后移
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = key; // 插入到正确位置
}
}
int main() {
std::vector<int> arr = {12, 11, 13, 5, 6};
insertionSort(arr);
for (int num : arr) {
std::cout << num << " ";
}
// 输出: 5 6 11 12 13
return 0;
}
#include <iostream>
#include <vector>
void bubbleSort(std::vector<int>& arr) {
int n = arr.size();
for (int i = 0; i < n - 1; ++i) { // 外层循环控制轮次
bool swapped = false; // 优化：如果某一轮没有交换，说明已有序
for (int j = 0; j < n - i - 1; ++j) { // 内层循环比较相邻元素
if (arr[j] > arr[j + 1]) {
std::swap(arr[j], arr[j + 1]);
swapped = true;
}
}
if (!swapped) break; // 提前终止
}
}
int main() {
std::vector<int> arr = {5, 2, 9, 1, 5, 6};
bubbleSort(arr);
for (int num : arr) {
std::cout << num << " ";
}
// 输出: 1 2 5 5 6 9
return 0;
}
#include <iostream>
#include <vector>
// 分区函数（Lomuto 方案）
int partition(std::vector<int>& arr, int low, int high) {
int pivot = arr[high]; // 选择最后一个元素作为基准
int i = low - 1; // i 是小于基准的区域的右边界
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; // 返回基准的最终位置
}
// 快速排序主函数
void quickSort(std::vector<int>& arr, int low, int high) {
if (low < high) {
int pivotIndex = partition(arr, low, high);
quickSort(arr, low, pivotIndex - 1); // 排序左半部分
quickSort(arr, pivotIndex + 1, high); // 排序右半部分
}
}
int main() {
std::vector<int> arr = {10, 7, 8, 9, 1, 5};
quickSort(arr, 0, arr.size() - 1);
std::cout << "排序结果: ";
for (int num : arr) {
std::cout << num << " ";
}
// 输出: 1 5 7 8 9 10
return 0;
}
优化策略
优化后的快速排序（Quick Sort）完整代码
以下是结合 随机化基准、三数取中法、小数组切换插入排序 和 尾递归优化 的完整实现：
#include <iostream>
#include <vector>
#include <cstdlib> // for rand()
#include <algorithm> // for std::sort (对比测试)
// 插入排序（用于小规模数据）
void insertionSort(std::vector<int>& arr, int low, int high) {
for (int i = low + 1; i <= high; ++i) {
int key = arr[i];
int j = i - 1;
while (j >= low && arr[j] > key) {
arr[j + 1] = arr[j];
--j;
}
arr[j + 1] = key;
}
}
// 三数取中法选择基准
int medianOfThree(std::vector<int>& arr, int low, int high) {
int mid = low + (high - low) / 2;
// 确保 arr[low] <= arr[mid] <= arr[high]
if (arr[low] > arr[mid]) std::swap(arr[low], arr[mid]);
if (arr[low] > arr[high]) std::swap(arr[low], arr[high]);
if (arr[mid] > arr[high]) std::swap(arr[mid], arr[high]);
// 将中位数放到 high 位置（Lomuto 分区方案）
std::swap(arr[mid], arr[high]);
return arr[high];
}
// 分区函数（Lomuto 方案 + 随机化基准）
int partition(std::vector<int>& arr, int low, int high) {
// 随机选择基准并交换到末尾
int randomIndex = low + rand() % (high - low + 1);
std::swap(arr[randomIndex], arr[high]);
// 三数取中法优化（可选，此处注释掉以单独测试随机化）
// int pivot = medianOfThree(arr, low, high);
int pivot = arr[high];
int i = low - 1; // i 是小于基准的区域的右边界
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;
}
// 快速排序主函数（尾递归优化）
void quickSort(std::vector<int>& arr, int low, int high) {
const int INSERTION_THRESHOLD = 16; // 小数组阈值
while (low < high) {
if (high - low + 1 <= INSERTION_THRESHOLD) {
insertionSort(arr, low, high);
break;
}
int pivotIndex = partition(arr, low, high);
// 尾递归优化：先处理较短的子数组
if (pivotIndex - low < high - pivotIndex) {
quickSort(arr, low, pivotIndex - 1);
low = pivotIndex + 1;
} else {
quickSort(arr, pivotIndex + 1, high);
high = pivotIndex - 1;
}
}
}
// 测试代码
int main() {
std::vector<int> arr = {10, 7, 8, 9, 1, 5, 3, 6, 2, 4};
std::vector<int> arrCopy = arr; // 用于对比 std::sort
// 手动实现的快速排序
quickSort(arr, 0, arr.size() - 1);
std::cout << "快速排序结果: ";
for (int num : arr) {
std::cout << num << " ";
}
std::cout << "\n";
// C++ 标准库排序（对比验证）
std::sort(arrCopy.begin(), arrCopy.end());
std::cout << "std::sort 结果: ";
for (int num : arrCopy) {
std::cout << num << " ";
}
std::cout << "\n";
return 0;
}
浙公网安备 33010602011771号