C++ 排序和跟踪索引

C ++ 排序与跟踪索引是程序员日常工作中经常使用的工具。排序算法在给定一组数据的情况下，按特定的顺序对它们进行排序。跟踪索引是一种记录程序执行过程的方式。在本文中，我们将讨论 C ++ 中的排序和跟踪索引。

排序

C ++ 中有多种排序算法可供选择。以下是一些常见的排序算法：

冒泡排序

冒泡排序是一种简单的排序算法，它通过多次比较并交换相邻的元素来将一个序列排序。在每一次遍历中，将当前元素与下一个元素进行比较，如果当前元素大于下一个元素，则将它们交换位置。

冒泡排序的时间复杂度为 O(n^2)。

void bubbleSort(int arr[], int n) {
    for (int i = 0; i < n - 1; ++i) {
        for (int j = 0; j < n - 1 - i; ++j) {
            if (arr[j] > arr[j + 1]) {
                std::swap(arr[j], arr[j + 1]);
            }
        }
    }
}

选择排序

选择排序是一种简单的排序算法，它通过重复选择当前未排序的最小元素来将一个序列排序。在每一次遍历中，将当前元素与未排序的元素中最小的元素进行比较，如果当前元素大于最小元素，则将它们交换位置。

选择排序的时间复杂度为 O(n^2)。

void selectionSort(int arr[], int n) {
    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]);
    }
}

插入排序

插入排序是一种简单的排序算法，它通过每次将一个未排序的元素插入到已排序的部分的适当位置来将一个序列排序。在每一次遍历中，将当前元素与已排序的元素逐一进行比较，并将其插入到适当的位置。

插入排序的时间复杂度为 O(n^2)，但对于已几乎排好序的序列，插入排序的效率较高。

void insertionSort(int arr[], int n) {
    for (int i = 1; i < n; ++i) {
        int key = arr[i];
        int j = i - 1;
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j -= 1;
        }
        arr[j + 1] = key;
    }
}

快速排序

快速排序是一种高效的排序算法，它通过使用分治策略将一个序列分为更小的子序列，然后递归地排序这些子序列。在每次遍历中，选择一个基准元素，将序列中比它小的元素移到它前面，将序列中比它大的元素移到它后面。

快速排序的时间复杂度为 O(nlogn)，但在最坏情况下的时间复杂度为 O(n^2)。

void quickSort(int arr[], int left, int right) {
    if (left >= right) {
        return;
    }
    int pivot = arr[left];
    int i = left + 1, j = right;
    while (i <= j) {
        while (i <= j && arr[i] < pivot) {
            i++;
        }
        while (i <= j && arr[j] > pivot) {
            j--;
        }
        if (i <= j) {
            std::swap(arr[i], arr[j]);
            i++;
            j--;
        }
    }
    std::swap(arr[left], arr[j]);
    quickSort(arr, left, j - 1);
    quickSort(arr, j + 1, right);
}

跟踪索引

跟踪索引是一种记录程序执行过程的方式。通过添加跟踪索引，我们可以了解程序执行过程中变量的值以及程序执行的顺序。

traceIndex 宏

下面是一个 traceIndex 宏的实现，它将在变量名和值之间输出一个箭头符号。

#define TRACE_INDEX(X) std::cerr << #X << " -> " << X << std::endl;

使用 traceIndex 宏的示例：

int main() {
    int a = 1, b = 2;
    TRACE_INDEX(a);
    TRACE_INDEX(b);
    std::swap(a, b);
    TRACE_INDEX(a);
    TRACE_INDEX(b);
    return 0;
}

输出结果：

a -> 1
b -> 2
a -> 2
b -> 1

tracer 类

除了使用宏之外，还可以通过创建一个 tracer 类的实例来添加跟踪索引。tracer 类是一个模板类，它接受一个任意类型的变量，可以通过 << 运算符向标准错误输出流中输出变量。

template<typename T>
class tracer {
public:
    tracer(const char* name, const T& value) : name_(name), value_(value) {};
    friend std::ostream& operator<<(std::ostream& os, const tracer<T>& t) {
        return os << t.name_ << " -> " << t.value_;
    }
private:
    const char* name_;
    const T& value_;
};

使用 tracer 类的示例：

int main() {
    int a = 1, b = 2;
    std::cerr << tracer("a", a) << std::endl;
    std::cerr << tracer("b", b) << std::endl;
    std::swap(a, b);
    std::cerr << tracer("a", a) << std::endl;
    std::cerr << tracer("b", b) << std::endl;
    return 0;
}

输出结果：

a -> 1
b -> 2
a -> 2
b -> 1

结论

C ++ 排序和跟踪索引是程序员日常工作中经常使用的工具。在编写 C ++ 应用程序时，了解这些工具的实现可以帮助我们更高效地编写代码。