分治法求解序列最大最小元素【算法设计与分析】_设计一个算法,采用分治法求一个整数序列中的最大和最小元素。

实验问题：

给定一个序列求出此序列的最大最小值<要求利用分治法求解>

问题分析：

为了得到更小的比较次数，采用分治法求解问题；

将序列等分为两组，目的是分别求解两组的最大最小值；

再递归分解直到每组个数不大于2，就可以找到最大（小）值；

再回溯将分解的两组解大者的值取大，解小的取小，合并解。

数学建模：

建立函数MAXMIN（i,j,a）<其中i是一段序列的头指针，j是这段序列的尾指针，a是最开始输入的数组>

当没有分解完全时（i!=j||i!=j-1）

递归分解mid=（i+j）/ 2

分解左边序列：MAXMIN（i,mid,a）、分解右边序列：MAXMIN（mid+1,j,a）

得到左右两边的最大（小）值 lmax（lmin）、rmax（rmin）

再对比lmax（lmin）和rmax（rmin），取合并的解max

递归出口是i=j（序列是一个元素），i=j-1（序列是两个元素）

实验代码：

//分治法求数列最大最小值
#define _CRT_NO_SECURE_WARNINGS
 
#include<stdio.h>
#include<iostream>
 
using namespace std;
 
int str[2] = { 0 };
 
//i是数组首位标记,j是数组的末尾标记
int* MAXMIN(int i, int j, int* a) {
	int max = 0;
	int min = 0;
	int mid = 0;
	int lmax = 0;
	int lmin = 0;
	int rmax = 0;
	int rmin = 0;
	int* ltem;
	int* rtem;
	//i,j指向同一个位置,相当于一个元素
	if (i == j) {
		max = a[i];
		str[0] = max;
		min = a[i];
		str[1] = min;
	}
	//i和j差一个位置,相当于两个元素
	else if (i == j - 1) {
		//a[i]元素小
		if (a[i] < a[j]) {
			max = a[j];
			str[0] = max;
			min = a[i];
			str[1] = min;
		}
		//a[j]元素小
		else {
			max = a[i];
			str[0] = max;
			min = a[j];
			str[1] = min;
		}
	}
	//i和j指向一个数组,分治
	else {
		mid = (i + j) / 2;
		//对于i到mid的数求最大最小值
		ltem = MAXMIN(i, mid, a);
		lmax = *ltem;
		lmin = *(ltem + 1);
		//对于mid+1到j的数求最大最小值
		rtem = MAXMIN(mid + 1, j, a);
		rmax = *rtem;
		rmin = *(rtem + 1);
		//对比左右数列的最大最小值
		if (lmax > rmax) {
			max = lmax;
			str[0] = max;
		}
		else {
			max = rmax;
			str[0] = max;
		}
		if (lmin > rmin) {
			min = rmin;
			str[1] = min;
		}
		else {
			min = lmin;
			str[1] = min;
		}
	}
	return str;
}
 
int main() {
	int a[100] = { 0 };
	int j = 0;
	int k = 0;
	int* p;
	char c ='0';
		
	cout << "请输入要求最大最小值的数列:"<<endl;
	for (j = 0;j < 100;j++) {
		cin >> a[j];
		if (getchar() == '\n') {
			break;
		}
	}
 
	p=MAXMIN(0, j, a);
	cout << "此序列最大值为:" << *p << endl;
	cout << "此序列最小值为:" << *(p + 1) << endl;
	system("pause");
	return 0;
}
 
 

测试数据： 

2 9 1 0 4 5 3 6

实验结果：

时间复杂度分析：

当序列是一个元素时，不需比较  T（n）=0；

当序列是两个元素时，比较一次  T（n）=1；

当序列大于两个元素时，T（n）=2T（n/2）+2；

利用主方法：O（n）>O(2)则

   算法时间复杂度为O（n）