(Estudio 6) se dividen Especial y estrategia de conquista algoritmo --BFPTR

Leads problema: dado un conjunto de N, en el que el k-ésimo menor número obtenido, la primera K de un pequeño elemento se refiere a un elemento de K L después de la recogida de los elementos en orden ascendente bueno.

1: la inercia del pensamiento es el número de cada conjunto están ordenadas, y luego encontrar el índice del elemento k, el mejor de los casos es a ser O (nlogn)

2: BFPTR algoritmo, incluso en el peor caso, es posible lograr O (n) algoritmo mediante el algoritmo de aprendizaje, es sensación intuitiva, el algoritmo primer conjunto de números divididos en grupos de 5, y luego encontrar la mediana de cada grupo, la mediana en un conjunto, y luego encontrar la mediana del conjunto de m, entonces la matriz se dividen según la mediana, la descarga es más pequeño que m a la izquierda que en el lugar adecuado m grande, y la posición de observación m k de la relación recursiva correspondiente y, en el algoritmo de ordenación rápida aprendidas previamente, de hecho, el algoritmo cambia el cubo (pivote) método de selección, y puede mejorar significativamente la eficiencia del algoritmo

personal punto de entendimiento:

Los elementos están divididos . 5 en grupos, ( haciendo así que la división más racional posterior, un estudio realizado por cinco de los matemáticos ) para cada especie, y luego encontrar la mediana mediana m dividida después cuando la mayor parte de la colección ha estado en un estado ordenado, a continuación, tomar una clase rápida de pensar, se divide la colección, es decir, para modificar la regla principal de selección de unidades rápida especie, la mediana mediana del conjunto como un componente principal, el peor de los casos la complejidad del tiempo es también O (n)

Pseudo-código (comprensión puramente personal, la esperanza de obtener la crítica):

. 1 : el Find () { // encontrar un conjunto de N k-ésimo número menor 
      FindMid (); // un conjunto de N se divide en grupos de cinco, un total de n 5 grupos /, cada grupo para la secuenciación de inserto, para identificar cada la mediana, y se incluye en conjunto M.
    // encontrar la mediana de mediana M en 
      FindIndex (); // set N encontrado en el índice de mediana
       // a mediana delimitada en la pequeña mediana edad N que la izquierda, en el más grande que mediana mediados de la derecha, y después de la grabación subíndices medio divididas
 // Si mediados subíndice <k, entonces mirando el conjunto adecuado mediados
 // Si mediados subíndice> k, a continuación, la mitad izquierda mirando
 // si la mitad index = k, encontrar los números pequeños de K 
}

Código (referencia a algunos bloggers)

// 
//   main.cpp
 //   作业6
 // 
//   Creado por yizhihenpidehou el 31/03/2020.
//   Copyright © 2020 yizhihenpidehou. Todos los derechos reservados.
//
 #include <iostream> 
#include <stdio.h>
 utilizando  espacio de nombres std;
const  int Maxen = 100 ;
void InsertSort ( int n [], int baja, int alto) { // 插入排序
    int i, j;
    para (i = baja + 1 ; i <= alta; i ++ ) {
        j = i- 1 ;
        int tmp = n [i];
        mientras que (j> = bajo && tmp < n [j]) {
            n [j + 1 ] = n [j];
            j - ;
        }
        n [j + 1 ] = tmp;
    }
}
int FindMid ( int n [], int baja, int alto) { // 找出中位数
    si (alta baja ==) de retorno n [baja];
    int i, k;
    para (i = baja; i + 4 <= alta; i + = 5 ) {
        InsertSort (n, i, i + 4 );
        k = i- baja;
        swap (n [bajo + k / 5 ], n [i + 2 ]);
    }
    int cnt = Alta-i + 1 ;
    si (cnt> 0 ) {
        InsertSort (n, i, alto);
        k = i- baja;
        swap (n [bajo + k / 5 ], n [i + cnt / 2 ]);
    }
    k = k / 5 ;
    si (k == 0 ) retorno n [baja];
    retorno FindMid (n, bajo, bajo + k);
}
int FindMidIndex ( int n [], int baja, int alta, int midd) { // 找出中位数的下标
    para ( int i = baja; i <= alta; i ++ ) {
         si (n [i] = = midd) {
             volver i;
        }
    }
    volver - 1 ;
}
int la partición ( int n- [], int bajo, int alta, int index) { // dividen de acuerdo a la mediana determinado, la posición mediana calculada dividido 
    IF (Low <= alta) {
         int I = Low, J = alta;
        swap (n [índice], n [baja]);
        int tmp = n [baja];
        mientras que (! i = j) {
             mientras que (i <j && n [j]> = tmp) {
                j - ;}
            n [i] = n [j];
            mientras que (i <j && n [i] <= tmp) {
                i ++ ;}
            n [j] = n [i];
        }
        n [i] = tmp;
        volver i;
    }
        volver - 1 ;
}
int BFPTR ( int n [], int baja, int alta, int k) {
     int midd = FindMid (n, bajo, alto);
    int indexx = FindMidIndex (n, bajo, alto, midd);
    int NewIndex = partición (n, bajo, alto, indexx);
    int rango = NewIndex de baja + 1 ;
    si (rango == k) de regreso NewIndex;
    más  si (rango> k) volver BFPTR (n, bajo, newIndex- 1 , k);
    retorno BFPTR (n, NewIndex + 1 , alto, k- rango);
}
int principal ( int argc, const  char * argv []) {
     int num [Maxen] = {- 1 , 12 , 1 , 8 , 10 , 6 , 2 , 5 , 9 , 11 , 3 , 4 , 7 };
    int k;
    scanf ( " % d " , y k);
    int baja = 1 ;
    int alta = 12 ;
    int index = BFPTR (num, bajo, alto, k);
    printf ( " % d \ n " , num [índice]);
    para ( int i = baja; i <alta; i ++ ) {
        printf ( " % d " , num [i]);
    }
    printf ( " \ n " );
    volver  0 ;
}

Ver código