C程序使用指针对数组进行排序

在C程序中，对数组进行排序是一个常见的操作。使用指针可以更高效地访问数组元素，并具有较小的开销。

1. 冒泡排序

冒泡排序是最简单的排序算法，它通过不断比较相邻的两个元素并交换它们的位置来排序。

void bubbleSort(int arr[], int len) {
    int i, j, temp;
    for (i = 0; i < len - 1; i++) {
        for (j = 0; j < len - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

使用指针可以更方便地访问数组元素：

void bubbleSort(int *arr, int len) {
    int *p, *q, temp;
    for (p = arr; p < arr + len - 1; p++) {
        for (q = arr; q < arr + len - 1 - (p - arr); q++) {
            if (*q > *(q + 1)) {
                temp = *q;
                *q = *(q + 1);
                *(q + 1) = temp;
            }
        }
    }
}

2. 快速排序

快速排序是一种优秀的排序算法，它通过分治的思想将大问题分解成小问题，并通过递归的方式解决。

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

使用指针可以更高效地访问数组元素：

void quickSort(int *arr, int left, int right) {
    if (left < right) {
        int *p = arr + left, *q = arr + right, pivot = *(arr + left);
        while (p < q) {
            while (p < q && *q >= pivot) q--;
            if (p < q) *p++ = *(q);
            while (p < q && *p < pivot) p++;
            if (p < q) *q-- = *(p);
        }
        *p = pivot;
        quickSort(arr, left, p - arr - 1);
        quickSort(arr, p - arr + 1, right);
    }
}

3. 堆排序

堆排序是一种利用完全二叉树的性质来实现的高效排序算法。

void heapSort(int arr[], int len) {
    int i, temp;
    for (i = len / 2 - 1; i >= 0; i--)
        heapify(arr, len, i);
    for (i = len - 1; i > 0; i--) {
        temp = arr[0];
        arr[0] = arr[i];
        arr[i] = temp;
        heapify(arr, i, 0);
    }
}

void heapify(int arr[], int len, int i) {
    int largest = i, left = 2 * i + 1, right = 2 * i + 2, temp;
    if (left < len && arr[left] > arr[largest])
        largest = left;
    if (right < len && arr[right] > arr[largest])
        largest = right;
    if (largest != i) {
        temp = arr[i];
        arr[i] = arr[largest];
        arr[largest] = temp;
        heapify(arr, len, largest);
    }
}

使用指针可以更方便地访问数组元素：

void heapSort(int *arr, int len) {
    int i, temp;
    for (i = len / 2 - 1; i >= 0; i--)
        heapify(arr, len, i);
    for (i = len - 1; i > 0; i--) {
        temp = *arr;
        *arr = *(arr + i);
        *(arr + i) = temp;
        heapify(arr, i, 0);
    }
}

void heapify(int *arr, int len, int i) {
    int largest = i, left = 2 * i + 1, right = 2 * i + 2, temp;
    if (left < len && *(arr + left) > *(arr + largest))
        largest = left;
    if (right < len && *(arr + right) > *(arr + largest))
        largest = right;
    if (largest != i) {
        temp = *(arr + i);
        *(arr + i) = *(arr + largest);
        *(arr + largest) = temp;
        heapify(arr, len, largest);
    }
}

4. 归并排序

归并排序是一种利用分治的思想，将数组分为两个子数组，逐步将子数组排序并合并的算法。

void mergeSort(int arr[], int left, int right) {
    if (left < right) {
        int mid = (left + right) / 2;
        mergeSort(arr, left, mid);
        mergeSort(arr, mid + 1, right);
        merge(arr, left, mid, right);
    }
}

void merge(int arr[], int left, int mid, int right) {
    int i, j, k, len1 = mid - left + 1, len2 = right - mid;
    int L[len1], R[len2];
    for (i = 0; i < len1; i++)
        L[i] = arr[left + i];
    for (j = 0; j < len2; j++)
        R[j] = arr[mid + 1 + j];
    i = j = 0;
    k = left;
    while (i < len1 && j < len2) {
        if (L[i] <= R[j])
            arr[k++] = L[i++];
        else
            arr[k++] = R[j++];
    }
    while (i < len1) arr[k++] = L[i++];
    while (j < len2) arr[k++] = R[j++];
}

使用指针可以更高效地访问数组元素：

void mergeSort(int *arr, int left, int right) {
    if (left < right) {
        int mid = (left + right) / 2;
        mergeSort(arr, left, mid);
        mergeSort(arr, mid + 1, right);
        merge(arr, left, mid, right);
    }
}

void merge(int *arr, int left, int mid, int right) {
    int i, j, k, len1 = mid - left + 1, len2 = right - mid;
    int L[len1], R[len2];
    for (i = 0; i < len1; i++)
        *(L + i) = *(arr + left + i);
    for (j = 0; j < len2; j++)
        *(R + j) = *(arr + mid + 1 + j);
    i = j = 0;
    k = left;
    while (i < len1 && j < len2) {
        if (*(L + i) <= *(R + j))
            *(arr + k++) = *(L + i++);
        else
            *(arr + k++) = *(R + j++);
    }
    while (i < len1) *(arr + k++) = *(L + i++);
    while (j < len2) *(arr + k++) = *(R + j++);
}

通过以上代码示例，我们了解了使用指针对数组进行排序的方法，这不仅可以提高程序的性能，而且可以更加精简代码，让代码更具可读性。