【算法设计与分析】分治算法（五）锦标赛算法（求第二大数）

实验目的

1）了解分治策略算法思想及基本原理；
2）掌握使用分治算法求解问题的一般特征；
3）掌握分解、治理的方法；
4）能够针对实际问题，能够正确的分解、治理，设计分治算法；
5）能够正确分析算法的时间复杂度和空间复杂度。

实验内容（要求）

给出包含n个数的数列，求第二大的数。

算法设计(问题分析、建模、算法描述)

问题分析：
     采用锦标赛算法，将数组中的数两两分组进行比较，较大的进入下一轮的比较，并且在比较中记录下所有对应获胜元素所淘汰的元素，当最后一个元素也就是最大值max产生时，max所对应的所有被max淘汰的元素也被记录了下来，并且第二大的数second也在其中，然后我们只需要在这些元素中找最大的数即为第二大的数second。利用二叉树，构建一棵比赛的满二叉树。叶子节点就是所有的数，根节点就是冠军元素。
算法描述：

1. 先进行pk构建满二叉树
2. 用一个数组b来存放这些数在数组a中的下标，空的为-1，然后通过左右子树不断的比较，将大数放到父亲节点，一直到根节点。
3. 采用一个递归实现来进行第二次比较，递归地寻找到与最大数max比较的所有元素，然后从下往上覆盖最大数max，直到根节点就得到了第二大数second。

算法源码

#include <bits/stdc++.h>
#pragma GCC optimize(2)
#define int long long

using namespace std;
const int N = 1e5 + 10;
int n, a[N];

void pk(int* a, int* b, int bLen, int index, int max)
{
    int left = index * 2;
    int right = index * 2 + 1;

    //当找到存放最大数序号的叶子节点时将其改写为-1
    if (left > bLen || right > bLen)
    {
        b[index - 1] = -1;
        return;
    }

    //如果左儿子是最大数则继续递归左儿子，反之递归右儿子
    if (b[left - 1] == max)
        pk(a, b, bLen, left, max);
    else
        pk(a, b, bLen, right, max);

    if (a[b[left - 1] - 1] > a[b[right - 1] - 1])
        b[index - 1] = b[left - 1];
    else
        b[index - 1] = b[right - 1];

}

int fd(int a[], int n)
{
    int x = 1;
    while (x < n)
    {
        x = x << 1;
    }
    int* b = new int[2 * x - 1];

    //将b数组中后x个元素装入1到n的标号
    for (int i = 0; i < x; i++)
    {
        if (i < n)
        {
            b[x - 1 + i] = i+1;
        }
        else
        {
            b[x - 1 + i] = -1;
        }
    }

    for (int i = 2 * x - 2; i > 0; i -= 2)
    {
        if (b[i] < 0)
        {
            if (b[i - 1] >= 0)
                b[(i - 1) / 2] = b[i - 1];
            else
                b[(i - 1) / 2] = -1;

        }
        else
        {
            if (a[b[i] - 1] > a[b[i - 1] - 1])
                b[(i - 1) / 2] = b[i];
            else
                b[(i - 1) / 2] = b[i - 1];
        }
    }

    pk(a, b, 2 * x - 1, 1, b[0]);

    int second = a[b[0] - 1];
    delete[]b;
    return second;
}

int32_t main()
{
    cin >> n;
    for (int i = 1; i <= n; ++i) {
        cin >> a[i];
    }

    cout << fd(a, n) << endl;

    return 0;
}

测试数据及运算结果(要求：截图说明算法运行的结果)

测试数据：
7
23 76 91 56 98 12 78

输出结果：

算法分析(分析算法的时间复杂度和空间复杂度)

时间复杂度：O(log n)
T(n) = n-1+⌈logn⌉-1 = n+⌈logn⌉-2，T(n) = O(log n)

空间复杂度：O(n)
创建一个满二叉树，其节点数为2n-1，需要用一个大小为2n的数组来存储完全二叉树的所有节点。在排序过程中，需要额外使用一个大小为n的数组，用于存储每个子树的胜者