Se requiere al menos la matriz no seleccionados comparando el máximo y el mínimo número de

Introducir el principio de

Buscando el máximo y el mínimo de una matriz desordenada es una situación muy común, en general, los valores máximos y mínimos no son el mismo elemento, podemos encontrar varias maneras lo siguiente:

Algoritmo de ordenación: ordenar la matriz, el primer elemento es el valor mínimo, el último elemento es el máximo, la complejidad promedio en una descarga rápida, por ejemplo, el tiempo de complejidad $ O (NlogN) $, complejidad espacial: $ O (logN ) $, el número de comparaciones: $ NlogN $;
Registro de los máximos y mínimos de dos elementos, la determinación de si cada valor es mayor que el número máximo o mínimo de comparaciones: $ 2 * N $ ';
Dos registros de los valores máximos y mínimos, teniendo dos valores, la comparación de la primera, pequeña en comparación con el valor mínimo, valor máximo se compara con el gran número de comparaciones: $ 1.5 * N $
Comparando el número de adyacente, mayor en posiciones pares, pequeño en posiciones impares, y, finalmente, la comparación de las posiciones pares e impares correspondientes a la posición se obtiene comparando el número máximo y mínimo de comparaciones: $ 1.5 * N $;
método de reparto, un problema versión simplificada TOPK en dos partes, la primera parte de Mín Máx encontrar el último valor del último resultado de la comparación obtenido

Los métodos 3 y 4 es muy cerca del proceso, método 3 se logra más fácilmente, posterior realización particularmente visible

algoritmo

drenaje rápido 1

// 找到数组元素的最大值和最小值 
vector<int> findMinMax(vector<int> arr)
{
    sort(arr.begin(),arr.end());
    return {arr[0],arr.back()};
}

método 2

// 找到数组元素的最大值和最小值 
vector<int> findMinMax(vector<int> arr)
{
    int min_ = INT_MAX,max_ = INT_MIN;
    for(int i=0;i<arr.size();++i)
    {
        if(arr[i] > max_)
            max_ = arr[i];
        if(arr[i] < min_)
            min_ = arr[i];
    }
    return {min_,max_};
}

método 3

Dos registros de los valores máximos y mínimos, teniendo dos valores, la comparación de la primera, pequeña en comparación con el valor mínimo, valor máximo se compara con el gran número de comparaciones: $ 1.5 * N $

// 找到数组元素的最大值和最小值 
vector<int> findMinMax(vector<int> arr) {
    int min_ = INT_MAX,max_ = INT_MIN;
    // 处理前面偶数个元素
    for(int i=0;i<arr.size()/2;++i) {
        // 得到两个元素的最大值和最小值
        int tmp_min,tmp_max;
        if(arr[i] < arr[i+1]) {
            tmp_min = arr[i];
            tmp_max = arr[i+1];
        } else {
            tmp_min = arr[i+1];
            tmp_max = arr[i];
        }
        // 比较,更新最大值和最小值
        if(tmp_max > max_)  max_ = tmp_max;
        if(tmp_min < min_)  min_ = tmp_min;
    }

    // 处理数组个数为奇数的情况 // 处理最后一个元素
    if(arr.size()%2) {
        int tmp = arr.back();
        if(tmp > max_)  max_ = tmp;
        if(tmp < min_)  min_ = tmp;
    }

    return {min_,max_};
}

método 4

número comparativo anterior incluso de elementos, pequeño en posiciones impares, las posiciones, incluso en un gran número de comparaciones: $ 1.5 * N $

// 找到数组元素的最大值和最小值 
vector<int> findMinMax(vector<int> arr) {
    int min_ = INT_MAX,max_ = INT_MIN;
    // 调整位置, 小的位于奇数,大的位置偶数
    for(int i=0;i<arr.size()/2;i++) {
        if(arr[i] > arr[i+1])   swap(arr[i],arr[i+1]);
    }
    // 更新最大值和最小值
    for(int i=0;i<arr.size()/2;i++) {
        if(arr[i] < min_)   min_ = arr[i];
        if(arr[i+1] > max_) max_ = arr[i+1];
    }

    // 处理数组个数为奇数的情况 // 处理最后一个元素
    if(arr.size()%2) {
        int tmp = arr.back();
        if(tmp > max_)  max_ = tmp;
        if(tmp < min_)  min_ = tmp;
    }

    return {min_,max_};
}

método 5

En la búsqueda del número N del valor mínimo Min y Max, se divide en dos porciones, y secuencialmente tomar Min Max,
ligeramente