Projeto e Análise de Algoritmos - estratégia de dividir e conquistar selecionado k-th maior elemento

1. Problema

l  por fractura e estratégia conquista, escolhendo os pequenos elementos k.

2. Parse

Quicksort e pensamento pela partição, cada elemento principal selecionada aleatoriamente é determinado menos do que o número de elementos do elemento principal, se o número for maior do que k recursivamente Olhando metade esquerda, se o número for menor do que k recursivamente encontrar a seção direita

3. projeto

. 1  int find_kth ( int L, int P & lt, int K) {
 2  
3.      IF (P & lt == L) retorno Um [L]; // limite recursiva 
. 4  
. 5      int temp = A [aleatória (L, P & lt)]; // seleccionados aleatoriamente elemento principal 
6.  
7.      int CNT = 0 ; // contar o número maior do que o elemento principal 
8.  
9.      int I = L, J = I & lt;
 10  
. 11      o tempo (I <= J) {
 12 é  
13 é          o tempo (a [i] > TEMP && I <= J) I ++, ++ CNT ;
 14  
15         o tempo (A [J] <&& TEMP = I <= J) J, ;
 16  
. 17          IF (I < J) {
 18 é  
19.              a troca (a [i], A [J]);
 20 é  
21 é              CNT ++ ;
 22 é  
23 é          }
 24  
25          I ++, J, ;
 26 é  
27      }
 28  
29      IF (CNT> = k) { // Se k <= cnt, na metade esquerda do k-th maior recursivamente para encontrar 
30  
31 é          o retorno find_kth (L, L + CNT - 1. , K);
 32  
33 é      }
 34 é  
35      o mais { //Caso contrário, na parte da direita na recursão de encontrar um grande número de k-CNT 
36  
37 [          retorno find_kth (CNT + L, P & lt, K - CNT);
 38 é  
39      }
 40  
41 é } 

Análise 4.

complexidade de tempo: O (nlogn)

complexidade de espaço: O (n)

5. Fonte

https://github.com/BambooCertain/Algorithm.git

. 1 #include <stdio.h>
 2 #include <algoritmo>
 . 3 #include <o iostream>
 4.  A utilização  de espaço de nomes DST;
 . 5  int Um [ 100010 ];
 . 6  vazio a troca ( int & X, int & Y) {
 . 7      int temp = X ;
 . 8      X = Y;
 . 9      Y = TEMP;
 10  }
 . 11  int aleatório ( int L, int P & lt) { // retorna em um [l, r] inteiro aleatório no intervalo 
12 é      retornoRAND ()% (P & lt - L + 1. ) + L;
 13 é  }
 14  int find_kth ( int L, int P & lt, int K) {
 15      SE (P & lt == L) retorno Um [L]; // recursiva limite 
16      int a = TEMP [aleatória (L, P & lt)]; // seleccionado aleatoriamente PCA 
17.      int CNT = 0 ; // contar o número é maior do que o eixo 
18 é      int I = L, J = I & lt;
 . 19      a, enquanto (I <= J) {
 20 é          o tempo (a [i]> TEMP && I <= J) I ++, ++ CNT ;
 21 está         o tempo (A [J] <= TEMP && I <= J) J, ;
 22 é          SE (I < J) {
 23 é              a troca (a [i], A [J]);
 24              CNT ++ ;
 25          }
 26 é          I ++, J - ;
 27      }
 28      IF (CNT> = k) { // Se k <= cnt, na metade esquerda do k-th maior recursivamente para encontrar 
29 de          retorno find_kth (L, L + CNT - 1. , k);
 30      }
 31 é      a outra { // outra forma na metade direita de forma recursiva para encontrar um grande número de k-ntc 
32          de retorno find_kth (CNT + L, P & lt, K - CNT);
 33 é      }
34  }
 35  int main () {
 36      int n; cin >> n;
37      para ( int i = 1 ; i <= n; i ++) cin >> a [i];
38      int k; cin >> k;
39      cout << find_kth ( 1 , n, k) << endl;
40 }

O código completo