实验任务
完成以下代码：
二分搜索算法、合并排序算法、快速排序算法、棋盘覆盖算法、最接近点对算法
二分搜索算法
//源代码如下：
#include<stdio.h>
#include<stdlib.h>
//二分搜索算法
int BinarySearch(int a[],int n,int x) {
int left = 0, right = n - 1;
while (right >= left) {
int middle = (right + left) / 2;
if (a[middle] == x)
return middle;
if (a[middle] < x)
left = middle + 1;
else
right = middle - 1;
}
return -1;
}
// 快速排序的分区函数
int Partition(int a[], int begin, int end) {
int pivot = a[end];
int i = (begin - 1);
for (int j = begin; j < end; j++) {
if (a[j] <= pivot) {
i++;
// Swap a[i] and a[j]
int temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
// Swap a[i+1] and a[end] (or pivot)
int temp = a[i + 1];
a[i + 1] = a[end];
a[end] = temp;
return i + 1;
}
// 快速排序算法
void QuickSort(int a[], int begin, int end) {
if (begin < end) {
int partitionIndex = Partition(a, begin, end);
QuickSort(a, begin, partitionIndex - 1);
QuickSort(a, partitionIndex + 1, end);
}
}
int main()
{
int a[100]; // 假设数组最大长度为100，可以根据需要调整
int n, x, i;
// 输入数组的长度
printf("输入数组的长度：");
scanf("%d", &n);
// 检查数组长度是否超过预定义的最大长度
if (n > 100) {
printf("数组长度超出预定义的最大值。\n");
return 1;
}
// 输入数组的每个元素
printf("输入数组的%d个元素：\n", n);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
// 对数组进行快速排序
QuickSort(a, 0, n - 1);
// 验证二分搜索函数的正确性
// int a[6] = {1,3,6,8,9,12};
// int n = 6;
// int x;
// 输入要查找的数
printf("输入你要查找的数：");
scanf("%d", &x);
// 执行二分搜索
int result = BinarySearch(a, n, x);
if (result != -1)
printf("查找成功，要查找的数的下标为%d\n", result+1);
else
printf("查找失败\n");
// system("pause");
return 0;
}
利用了快速排序算法：
上述源代码实现了以下几点
1，可以自己定义输入
2，可以不按顺序输入
3，时间复杂度依旧是O(nlogn)
运行截图
合并排序算法
//源代码如下
#include <iostream>
#include <cstdlib>
using namespace std;
// 归并排序的递归函数，用于将数组arr从索引left到right的部分进行排序
void MergeSortRecursively(int* arr, int left, int right);
// 归并函数，用于合并两个已排序的子数组
void Merge(int* arr, int leftStart, int mid, int rightEnd);
int main() {
int n;
cout << "请输入数组长度：";
cin >> n; // 读取用户输入的数组长度
// 动态分配内存以存储数组
int* a = (int*)malloc(sizeof(int) * n);
cout << "\n输入整数数组：";
for (int i = 0; i < n; i++) {
cin >> a[i]; // 读取数组的每个元素
}
// 调用归并排序递归函数，对整个数组进行排序
MergeSortRecursively(a, 0, n - 1);
// 输出排序后的数组
cout << "\n排序后数组为：";
for (int i = 0; i < n; i++) {
cout << a[i] << " ";
}
cout << endl;
free(a); // 释放动态分配的内存
return 0;
}
// 归并排序的递归函数实现
void MergeSortRecursively(int* arr, int left, int right) {
if (left < right) {
// 计算中间索引，避免整数溢出
int mid = left + (right - left) / 2;
// 递归地对左右两部分进行排序
MergeSortRecursively(arr, left, mid);
MergeSortRecursively(arr, mid + 1, right);
// 合并已排序的两部分
Merge(arr, left, mid, right);
}
}
// 归并两个已排序的子数组的函数实现
void Merge(int* arr, int leftStart, int mid, int rightEnd) {
int n1 = mid - leftStart + 1; // 左侧子数组的元素数量
int n2 = rightEnd - mid; // 右侧子数组的元素数量
// 动态分配内存以存储两个子数组的元素
int* left = (int*)malloc(sizeof(int) * n1);
int* right = (int*)malloc(sizeof(int) * n2);
// 将原数组的元素复制到left和right数组中
for (int i = 0; i < n1; i++) {
left[i] = arr[leftStart + i];
}
for (int j = 0; j < n2; j++) {
right[j] = arr[mid + 1 + j];
}
int i = 0, j = 0, k = leftStart; // 初始化指针
// 合并过程：逐个比较左右子数组的元素，将较小的元素放入原数组
while (i < n1 && j < n2) {
if (left[i] <= right[j]) {
arr[k++] = left[i++];
} else {
arr[k++] = right[j++];
}
}
// 将剩余的左侧子数组元素复制到原数组
while (i < n1) {
arr[k++] = left[i++];
}
// 将剩余的右侧子数组元素复制到原数组
while (j < n2) {
arr[k++] = right[j++];
}
// 释放left和right数组的动态分配内存
free(left);
free(right);
}
运行截图：
快速排序算法：
//源代码如下：
#include<stdio.h>
#include<stdlib.h>
// 快速排序的分区函数
int Partition(int a[], int begin, int end) {
int pivot = a[end];
int i = (begin - 1);
for (int j = begin; j < end; j++) {
if (a[j] <= pivot) {
i++;
// Swap a[i] and a[j]
int temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
// Swap a[i+1] and a[end] (or pivot)
int temp = a[i + 1];
a[i + 1] = a[end];
a[end] = temp;
return i + 1;
}
// 快速排序算法
void QuickSort(int a[], int begin, int end) {
if (begin < end) {
int partitionIndex = Partition(a, begin, end);
QuickSort(a, begin, partitionIndex - 1);
QuickSort(a, partitionIndex + 1, end);
}
}
// 打印数组的函数
void printArray(int a[], int size) {
for (int i = 0; i < size; i++) {
printf("%d ", a[i]);
}
printf("\n");
}
int main()
{
int a[100]; // 假设数组最大长度为100，可以根据需要调整
int n, x, i;
// 输入数组的长度
printf("输入数组的长度：");
scanf("%d", &n);
// 检查数组长度是否超过预定义的最大长度
if (n > 100) {
printf("数组长度超出预定义的最大值。\n");
return 1;
}
// 输入数组的每个元素
printf("输入数组的%d个元素：\n", n);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
// 对数组进行快速排序
QuickSort(a, 0, n - 1);
// 打印排序后的数组
printf("排序后的数组为:\n");
printArray(a, n);
// system("pause");
return 0;
}
运行截图：
棋盘覆盖算法
//源代码如下：
#include <stdio.h>
#include <stdlib.h>
int num = 0;
int Matrix[100][100];
void chessBoard(int tr, int tc, int dr, int dc, int size);
int main()
{
int size,r,c,row,col;
printf("请输入棋盘的行列号");
scanf("%d",&size);
printf("请输入特殊方格的行列号");
scanf("%d %d",&row,&col);
chessBoard(0,0,row,col,size);
for (r = 0; r < size; r++)
{
for (c = 0; c < size; c++)
{
printf("%2d ",Matrix[r][c]);
}
printf("\n");
}
return 0;
}
void chessBoard(int tr, int tc, int dr, int dc, int size)
{
if (size==1)
return;
int s = size/2; //分割棋盘
int t = ++num; //L型骨牌号
//覆盖左上角子棋盘
if (dr < tr + s && dc < tc +s)
{
//特殊方格在此棋盘中
chessBoard(tr,tc,dr,dc,s);
}
else //此棋盘中无特殊方格
{
//用t号L型骨牌覆盖右下角
Matrix[tr+s-1][tc+s-1] = t;
//覆盖其余方格
chessBoard(tr,tc,tr+s-1,tc+s-1,s);
}
//覆盖右上角子棋盘
if (dr < tr + s && dc >= tc + s )
{
//特殊方格在此棋盘中
chessBoard(tr,tc+s,dr,dc,s);
}
else //此棋盘中无特殊方格
{
//用t号L型骨牌覆盖左下角
Matrix[tr+s-1][tc+s] = t;
//覆盖其余方格
chessBoard(tr,tc+s,tr+s-1,tc+s,s);
}
//覆盖左下角子棋盘
if (dr >= tr + s && dc < tc + s)
{
//特殊方格在此棋盘中
chessBoard(tr+s,tc,dr,dc,s);
}
else
{
//用t号L型骨牌覆盖右上角
Matrix[tr+s][tc+s-1] = t;
//覆盖其余方格
chessBoard(tr+s,tc,tr+s,tc+s-1,s);
}
//覆盖右下角子棋盘
if (dr >= tr + s && dc >= tc + s)
{
//特殊方格在此棋盘中
chessBoard(tr+s,tc+s,dr,dc,s);
}
else
{
//用t号L型骨牌覆盖左上角
Matrix[tr+s][tc+s] = t;
//覆盖其余方格
chessBoard(tr+s,tc+s,tr+s,tc+s,s);
}
}
运行截图：
最接近点对算法
//源代码如下：
#include<iostream>
#include<vector>
#include<algorithm>
#include<ctime>
#include<random>
using namespace std;
class point
{
public:
double x;
double y;
point(double x, double y) :x(x), y(y) {}
point() { return; }
};
bool compare_x(const point& A, const point& B)//比较x坐标，A的x小返回true，A和B相等或B的x小返回false
{
return A.x < B.x;
}
bool compare_y(const point& A, const point& B)//比较y坐标，A的y小返回true，A和B的y相等或B的y小返回false
{
return A.y < B.y;
}
double distance(const point& A, const point& B)//返回A和B之间的距离
{
return sqrt(pow(A.x - B.x, 2) + pow(A.y - B.y, 2));
}
double merge(vector<point>& points_y, double min_d, int mid, pair<point, point>& min_point)//合并函数，将左右区域距离的最小值与中间区域的6个点比较
{ //points为点的集合；dis为左右的最近点距离；mid为x坐标排序后，点集合中中间点的索引值；min_point为求得的最近点对
vector<point> left, right;
for (int i = 0; i < points_y.size(); i++)//搜集左右两边符合条件的点
{
if (points_y[i].x <= points_y[mid].x && points_y[i].x > points_y[mid].x - min_d)
left.push_back(points_y[i]);
else if (points_y[i].x > points_y[mid].x && points_y[i].x < points_y[mid].x + min_d)
right.push_back(points_y[i]);
}
int j = 0;//右侧点的下界
for (int i = 0; i < left.size(); i++)//遍历左边的点集合，与右边符合条件的计算距离
{
for (; j < right.size(); j++)
{
if (right[j].y >= left[i].y - min_d)
{
break;
}
}
for (int l = 0; l < 6 && l + j < right.size(); l++)//遍历右边的6个点
{
if (distance(left[i], right[j + l]) < min_d)
{
min_d = distance(left[i], right[j + l]);
min_point.first = left[i];
min_point.second = right[j + l];
}
}
}
return min_d;
}
double closest_point(vector<point>& points, vector<point>& points_y, pair<point, point>& min_point)//递归求解points中的最近点对，返回最近点对距离，min_point存储这个点对
{
if (points.size() == 2)//两个点
{
min_point.first = points[0];
min_point.second = points[1];
return distance(points[0], points[1]);
}
if (points.size() == 3)//三个点
{
double min_distance = min(distance(points[0], points[1]), min(distance(points[0], points[2]), distance(points[1], points[2])));
if (distance(points[0], points[1]) == min_distance)
{
min_point.first = points[0];
min_point.second = points[1];
}
else if (distance(points[0], points[2]) == min_distance)
{
min_point.first = points[0];
min_point.second = points[2];
}
else
{
min_point.first = points[1];
min_point.second = points[2];
}
return min_distance;
}
pair<point, point> temp_min_point1, temp_min_point2;
int mid = (points.size() >> 1) - 1;//size为偶数，mid为中点左边；size为奇数，mid为中点-1
double d_left, d_right, min_d;
vector<point> left(mid + 1), right(points.size() - mid - 1), left_y, right_y;//定义两个vector：left，right
copy(points.begin(), points.begin() + mid + 1, left.begin());//复制左边区域点集合到left
copy(points.begin() + mid + 1, points.end(), right.begin());//复制右边区域点集合到right
for (int i = 0; i < points_y.size(); i++)//将按y排好序的数组以point[mid]分为两部分，分完后还是按y排好序的
{
if (points_y[i].x <= points[mid].x)
left_y.push_back(points_y[i]);
else
right_y.push_back(points_y[i]);
}
d_left = closest_point(left, left_y, temp_min_point1);
d_right = closest_point(right, right_y, temp_min_point2);
min_d = min(d_left, d_right);
if (d_left == min_d)
{
min_point = temp_min_point1;
}
else
{
min_point = temp_min_point2;
}
return merge(points_y, min_d, mid, min_point);
}
double closest_point2(vector<point> p, pair<point, point>& min_point)//暴力穷举法
{
double minDistance = 99999;
for (int i = 0; i < p.size(); i++)
{
for (int j = 0; j < p.size(); j++)
{
double d = distance(p[i], p[j]);
if (d - 0 < 1e-4)
{
continue;
}
if (d < minDistance)
{
minDistance = d;
min_point = make_pair(p[i], p[j]);
}
}
}
return minDistance;
}
int main()
{
int count;
double x, y, min_distance;
vector<point> points;
vector<point> points_y;
pair<point, point> min_point;
default_random_engine e(time(NULL));
uniform_real_distribution<double> u(-10, 10);
cout << "请输入点的个数:";
cin >> count;
for (int i = 0; i < count; i++)
{
printf("第%d个点:", i + 1);
point p(u(e), u(e));
printf("(%lf,%lf)\n", p.x, p.y);
points.push_back(p);
points_y.push_back(p);
}
sort(points.begin(), points.end(), compare_x);//把所有的点按x从小到大排序
sort(points_y.begin(), points_y.end(), compare_y);//把左边的点按y从小到大排序
min_distance = closest_point(points, points_y, min_point);
cout << "分治法：" << endl;
printf("最近点对为:(%lf,%lf),(%lf,%lf)\n最近点对距离为:%lf\n", min_point.first.x, min_point.first.y, min_point.second.x, min_point.second.y, min_distance);
cout << "暴力穷举法：" << endl;
min_distance = closest_point2(points, min_point);
printf("最近点对为:(%lf,%lf),(%lf,%lf)\n最近点对距离为:%lf\n", min_point.first.x, min_point.first.y, min_point.second.x, min_point.second.y, min_distance);
system("pause");
return 0;
}
运行截图：
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
