用递归和分治分别实现求线性表中的最大数

//1.递归实现

/*算法设计思想：

将线性表平均分为两部分，分别求出这两部分的最大值，最后得出的最大值是左右两部分最大值的最大值，

  递归思想体现在每一个部分都可以分为两部分，求出最大值。*/

#include"tou.h"

using namespace std;

int Max(int a, int b, vector<int>&num1) {

int i = a, j = b;

int maxx, max1, max2,mid;

if (i == j) return num1[i];

else {

mid = (i + j) / 2;//将原来的线性表分为两部分，分别递归求最大值

max1 = Max(i, mid,num1 );

max2 = Max(mid + 1, j,num1);

maxx = max(max1, max2);

}

return maxx;

}

int main() {

int n=0;

cout << "数组的长度n=";

cin >> n;

vector<int>num(n);

for (int i = 0; i < n; i++) {

cin >> num[i];

}

int res= Max(0, n - 1, num);

cout << "最大的数是:" << res << endl;

}

 

调试结果：

 

//2.分治实现

/*算法设计思想

随机选取一个数作为基准，把比他小的数放在左边，比它大的数放在右边，由于我们随机的输入数组的元素，所以

  就直接让第一个数作为基准数，因为第一个数也是随机的，不会影响结果的复杂度。然后将基准数右面的数进行快速排序，重复

  此步骤，每次都是对基准数右面的数进行快速排序，直到右面的数只剩一个数，输出此数即为结果*/

#include "tou.h"

using namespace std;

int n = 0, k = 0;

int sort1(int a, int b,std::vector<int> & num1) {//快速排序，具体过程不再注释

int i, j, t, temp;

if (a > b) return 0;

temp = num1[a];

i = a; j = b;

while (i < j) {

while (num1[j] > temp&&i < j)

j--;

while (num1[i] < temp&&i < j)

i++;

if (i < j) {

swap(num1[i], num1[j]);

}

}

num1[a]=num1[i];num1[i]=temp;//将基准数归位

return i;//返回的是作为基准的那个数的下标

}

int fenzhi( int left,int right, std::vector<int> &num2) {

int pos = sort1(left, right,num2);//先进行一遍快速排序，并将返回的基准的下标赋值给pos

while (pos + 1 != n) {

fenzhi(pos + 1, right, num2);

}

return num2[pos];//pos+1=k时即为最后一个元素

}

调试结果与递归实现调试的结果相同。

 

总结：如果用排序算法的话，时间复杂度最快的也是快速排序O(logn)，用递归和分治时间复杂度降为O（n）。