(Estudo 6) divisão especial e estratégia de conquistar algoritmo --BFPTR

Leads problema: dada uma colecção de N, em que o k-ésimo menor número obtido, o primeiro K de um pequeno elemento refere-se a um elemento de K L após a recolha de elementos em ordem crescente boa.

1: a inércia do pensamento é o número de cada conjunto são classificados, e, em seguida, a partir do índice do elemento k, o melhor caso é para ser O (nlogn)

2: BFPTR algoritmo, mesmo no pior dos casos, é possível conseguir O algoritmo (n) pelo algoritmo de aprendizagem, é sensação intuitiva, o algoritmo primeiro conjunto de números divididos em grupos de 5, e então encontrar a mediana de cada grupo, a mediana em um conjunto, e então encontrar a mediana do conjunto de m, em seguida, a matriz são divididos de acordo com a mediana, a descarga é menor do que m da esquerda do que ao lugar certo m grande, e a posição de observação m k da relação recursiva correspondente e, no algoritmo de ordenação rápida previamente aprendido, de fato, o algoritmo muda o cubo (pivô) método de selecção, e pode melhorar significativamente a eficiência do algoritmo

ponto pessoal da compreensão:

Os elementos são divididos . 5 em grupos, ( fazê-lo tornar mais racional a divisão posterior, um estudo realizado por cinco dos matemáticos ) de cada espécie, em seguida, encontrar a mediana mediano m dividido depois quando a maior parte da coleção foi em um estado ordenado, em seguida, tomar uma classificação rápida de pensar, a coleção é dividida, ou seja, para modificar a regra de seleção unidade principal rápida tipo, a mediana mediana do conjunto como um componente principal, o pior caso a complexidade de tempo é também o (n)

Pseudo-código (compreensão puramente pessoal, espero conseguir críticas):

. 1 : o Find () { // encontrar um conjunto de N k-ésimo número menor 
      FindMid (); // um conjunto de N é dividida em grupos de cinco, um total de n / 5 grupos, cada grupo para inserção de sequenciação, para identificar cada mediano, e incluído no conjunto M.
    // encontrar a média de idade M em 
      FindIndex (); // conjunto N encontrado no índice de idade
       // a idade delimitada para a pequena idade de idade N inferior à esquerda, para a maior do que Intermédia mid a direita, e depois de gravar subscritos mediana divididos
 // Se mid subscrito <k, em seguida, olhando para o conjunto certo meados
 // Se mid subscrito> k, em seguida, definir o que olha à esquerda meados
 // se o mid = índice k, encontrar os números pequenos de K 
}

Código (referência a alguns blogueiros)

// 
//   main.cpp
 //   作业6
 // 
//   Criado por yizhihenpidehou em 2020/03/31.
//   de Copyright © 2020 yizhihenpidehou. Todos os direitos reservados.
//
 #include <iostream> 
#include <stdio.h>
 usando  namespace std;
const  int Maxen = 100 ;
vazio InsertSort ( int N [], int baixo, int alta) { // 插入排序
    int i, j;
    para (i = low + 1 ; i <= elevado; i ++ ) { 
        j = i- 1;
        int tmp = n [i];
        enquanto (j> = tmp baixo && < n [j]) { 
            n [j + 1 ] = N [j]; 
            j - ; 
        } 
        N [j + 1 ] = tmp; 
    } 
} 
Int FindMid ( int N [], int baixo, int {alta) // 找出中位数
    se (baixo alta ==) retorno n [baixa];
    int i, k;
    para (i = baixo; i + 4 <= elevado; i + = 5 ) {
        InsertSort (n, i, i + 4 ); 
        k = i- baixo; 
        permuta (n [partir + k / 5 ], N [I + 2 ]); 
    } 
    Int cnt = alta-i + 1 ;
    se (CNT> 0 ) { 
        InsertSort (n, i, elevado); 
        k = i- baixo; 
        permuta (n [partir + k / 5 ], N [i + cnt / 2 ]); 
    } 
    K = k / 5 ;
    se (k == 0 ) return n [baixa];
    RetornaFindMid (n-, Baixo, Baixo + K); 
} 
int FindMidIndex ( int n- [], int Baixo, int alta, int MIDD) { // encontrar o índice médio 
    para ( int I = baixa; I <= alta ; i ++ ) {
         SE (N- [I] == MIDD) {
             return I; 
        } 
    } 
    retorno - 1. ; 
} 
int a partição ( int N- [], int baixa, int alta, int índice) { // acordo com o determinado a mediana da posição mediana para ser dividido, para obter a divisão 
    se(baixo <= alta) {
         int i = baixo, J = elevado; 
        permuta (n [índice], N [baixa]); 
        int tmp = n [baixa];
        enquanto (! i = j) {
             enquanto (i <j && n [j]> = tmp) { 
                j - ;} 
            n [i] = n [j];
            enquanto (i <j && n [i] <= tmp) { 
                i ++ ;} 
            n [j] = n [i]; 
        } 
        N [i] = tmp;
        voltar i; 
    } 
        Return - 1 ;
} 
Int BFPTR ( int N [], int baixo, int alta, int k) {
     int midd = FindMid (n, baixo, alto);
    int indexx = FindMidIndex (n, baixo, alto, midd);
    int NewIndex = partição (n, baixo, alto, indexx);
    int rank = NewIndex-baixo + 1 ;
    se (classificação == k) retornar NewIndex;
    outra  se (classificação> k) retornar BFPTR (n, baixo, newIndex- 1 , k);
    retorno BFPTR (n, NewIndex + 1 , alta, k- classificação); 
}
 Int principal ( int argc, const  de char * argv []) {
     int Num [Maxen] = {- 1 , 12 , 1 , 8 , 10 , 6 , 2 , 5 , 9 , 11 , 3 , 4 , 7 };
    int k; 
    scanf ( " % d " , & k);
    int baixa = 1 ;
    int high = 12 ;
    int índice = BFPTR (Nm, baixo, alto, k); 
    printf ( " % d \ n " , Num [índice]);
    para ( int i = baixo; i <high; i ++ ) { 
        printf ( " % d " , Num [i]); 
    } 
    Printf ( " \ n " );
    retornar  0 ; 
}

View Code