前言
hello,大家好啊,这里是文宇不是文字,是文宇哦
快速排序(Quick Sort)
快速排序是一种排序算法,通过将一个数组分成两个子数组,再对这两个子数组进行排序,最终将整个数组排序完成。
快速排序的基本思想是:选择一个基准元素(pivot),通过一趟排序将数组分成两部分,使得左边的元素都小于等于基准元素,右边的元素都大于等于基准元素。然后对这两部分分别继续使用同样的方法进行排序,直到整个数组有序。
具体实现过程可以如下:
- 选择一个基准元素(pivot)。可以选择数组的第一个元素、最后一个元素或者数组中任意一个元素作为基准元素。
- 设定两个指针(i 和 j),分别指向数组的第一个元素和最后一个元素。
- 从右向左找到第一个小于等于基准元素的元素,记为 a[j]。
- 从左向右找到第一个大于等于基准元素的元素,记为 a[i]。
- 如果 i < j,则交换 a[i] 和 a[j]。
- 重复步骤3、4、5,直到 i >= j。
- 将基准元素与 a[j] 交换位置,此时基准元素的位置就是 j。
- 对基准元素左边的子数组和右边的子数组分别进行递归排序。
下面是一个使用 C++ 实现快速排序的示例代码:
#include <iostream>
using namespace std;
// 交换两个元素的值
void swap(int& a, int& b) {
int temp = a;
a = b;
b = temp;
}
// 快速排序
void quickSort(int arr[], int low, int high) {
if (low >= high) {
return;
}
int pivot = arr[low]; // 选择第一个元素作为基准元素
int i = low; // 左指针
int j = high; // 右指针
while (i < j) {
// 从右向左找到第一个小于等于基准元素的元素
while (i < j && arr[j] >= pivot) {
j--;
}
// 从左向右找到第一个大于等于基准元素的元素
while (i < j && arr[i] <= pivot) {
i++;
}
// 交换 arr[i] 和 arr[j]
if (i < j) {
swap(arr[i], arr[j]);
}
}
// 将基准元素与 arr[j] 交换位置
swap(arr[low], arr[j]);
// 对基准元素左边的子数组进行递归排序
quickSort(arr, low, j - 1);
// 对基准元素右边的子数组进行递归排序
quickSort(arr, j + 1, high);
}
int main() {
int arr[] = {5, 4, 3, 2, 1};
int n = sizeof(arr) / sizeof(arr[0]);
quickSort(arr, 0, n - 1);
for (int i = 0; i < n; i++) {
cout << arr[i] << " ";
}
cout << endl;
return 0;
}
以上代码实现了快速排序算法,将输入数组按从小到大的顺序排序输出。
归并排序(Merge Sort)
归并排序(Merge Sort)是一种排序算法,它基于分治法(Divide and Conquer)的思想,将一个待排序的数组分成两个子数组,对这两个子数组分别进行归并排序,最后将排序好的两个子数组合并起来,完成整个数组的排序。
归并排序的基本思想是:将待排序的数组不断地二分,直到每个子数组只剩下一个元素。然后将这些单个元素的子数组两两合并,合并后的数组保持有序。重复这个过程,直到最终将整个数组合并成一个有序的数组。
具体实现过程可以如下:
- 将待排序的数组不断地二分,直到每个子数组只剩下一个元素。
- 对每一对相邻的子数组进行合并操作,合并后的数组保持有序。合并的过程可以使用一个额外的数组来存储合并的结果,也可以在原数组上进行原地排序。
- 重复步骤2,直到最终将整个数组合并成一个有序的数组。
下面是一个使用 C++ 实现归并排序的示例代码:
#include <iostream>
using namespace std;
// 合并两个子数组
void merge(int arr[], int left, int mid, int right) {
int i = left; // 左子数组的起始索引
int j = mid + 1; // 右子数组的起始索引
int k = 0; // 临时数组的起始索引
int* temp = new int[right - left + 1]; // 临时数组
// 比较两个子数组的元素,将较小的元素放入临时数组
while (i <= mid && j <= right) {
if (arr[i] <= arr[j]) {
temp[k++] = arr[i++];
} else {
temp[k++] = arr[j++];
}
}
// 将剩余的元素放入临时数组
while (i <= mid) {
temp[k++] = arr[i++];
}
while (j <= right) {
temp[k++] = arr[j++];
}
// 将临时数组的元素复制回原数组
for (int m = 0, n = left; m < k; m++, n++) {
arr[n] = temp[m];
}
delete[] temp;
}
// 归并排序
void mergeSort(int arr[], int left, int right) {
if (left >= right) {
return;
}
int mid = (left + right) / 2; // 数组中间元素的索引
// 对左半部分进行归并排序
mergeSort(arr, left, mid);
// 对右半部分进行归并排序
mergeSort(arr, mid + 1, right);
// 合并左右两个子数组
merge(arr, left, mid, right);
}
int main() {
int arr[] = {5, 4, 3, 2, 1};
int n = sizeof(arr) / sizeof(arr[0]);
mergeSort(arr, 0, n - 1);
for (int i = 0; i < n; i++) {
cout << arr[i] << " ";
}
cout << endl;
return 0;
}
以上代码实现了归并排序算法,将输入数组按从小到大的顺序排序输出。在合并两个子数组时,使用了一个临时数组来辅助合并操作。
堆排序(Heap Sort)
堆排序(Heap Sort)是一种排序算法,它是基于二叉堆的数据结构实现的。堆是一个完全二叉树,其中每个父节点的值都大于(或小于)其子节点的值。
堆排序的基本思想是:将待排序的数组构建成一个最大堆(或最小堆),然后将堆顶元素与堆的最后一个元素交换,再将剩余的元素重新调整为最大堆(或最小堆)。重复这个过程,直到整个数组有序。
具体实现过程可以如下:
- 将待排序的数组构建成一个最大堆(或最小堆)。
- 将堆顶元素与堆的最后一个元素交换。
- 将剩余的元素重新调整为最大堆(或最小堆)。
- 重复步骤2和3,直到整个数组有序。
下面是一个使用 C++ 实现堆排序的示例代码:
#include <iostream>
using namespace std;
// 调整堆,保持堆的性质
void heapify(int arr[], int n, int i) {
int largest = i; // 默认最大值索引为 i
int left = 2 * i + 1; // 左子节点索引
int right = 2 * i + 2; // 右子节点索引
// 如果左子节点大于根节点,更新最大值索引
if (left < n && arr[left] > arr[largest]) {
largest = left;
}
// 如果右子节点大于根节点,更新最大值索引
if (right < n && arr[right] > arr[largest]) {
largest = right;
}
// 如果最大值索引不等于 i,交换根节点与最大值节点,并递归调整堆
if (largest != i) {
swap(arr[i], arr[largest]);
heapify(arr, n, largest);
}
}
// 堆排序
void heapSort(int arr[], int n) {
// 构建最大堆,从最后一个非叶子节点开始调整堆
for (int i = n / 2 - 1; i >= 0; i--) {
heapify(arr, n, i);
}
// 交换堆顶元素与堆的最后一个元素,并重新调整堆
for (int i = n - 1; i >= 0; i--) {
swap(arr[0], arr[i]);
heapify(arr, i, 0);
}
}
int main() {
int arr[] = {5, 4, 3, 2, 1};
int n = sizeof(arr) / sizeof(arr[0]);
heapSort(arr, n);
for (int i = 0; i < n; i++) {
cout << arr[i] << " ";
}
cout << endl;
return 0;
}
以上代码实现了堆排序算法,将输入数组按从小到大的顺序排序输出。在调整堆的过程中,使用了一个辅助函数 heapify 来保持堆的性质。通过构建最大堆,然后不断地交换堆顶元素与堆的最后一个元素,并重新调整堆,最终实现了堆排序算法。
结语
今天的文章到此结束啦,玛德,快给我干爆了,真不想写