Fortuna abandonó Francia 3 bases tema class2-- montón heapInsert, heapify, heapsort implementación en C ++
1. Conceptos básicos
1. Hay dos árbol binario completo:
5
/ \
12
/ \ /
3426
completo binario
5
/ \
1 2
/
1
de izquierda a derecha ordenado binario
2. El árbol binario puede ser completamente equivalente al montón que las matrices se pueden utilizar para lograr
en el que el i-ésimo izquierdo niño nodo: 2 . i + 1, el i-ésimo nodo del hijo derecho: 2 i + 2, el nodo padre del i-ésimo nodo: (i- 1.) / 2
3. gran pila root: se refiere a cualquier sub- el valor máximo del nodo del árbol es la cabeza de
raíz montón pequeño: Min se refiere a cualquier sub-árbol del nodo es la cabeza de la
2.heapInsert: nuevo nodo para unirse en el proceso de ajuste es de gran montón de raíz
La matriz en un montón grande raíz, estructura de pila estableció
análisis
Si el elemento actual es mayor que el elemento de inserción de su nodo padre, entonces la posición de conmutación del nodo padre del nodo actual. A continuación, el tamaño del nodo padre después de que el nodo insertado elemento de la inspección con la nueva ubicación de reemplazo, aunque mayor que o continuar con el intercambio.
por ejemplo. Ejemplo [2,1,3,6] se convierte en un gran montón de raíz
posiciones 0,1,2,3
(1) 2 se inserta, el nodo padre (0-1) / 2 = 0 posición, y que no se mueven a sí mismos;
(2) 1 se inserta, el nodo padre (1-1) / 2 = posición 0, 1 <2, no se mueve;
(3) 3 se inserta, el nodo padre (2-1) / 2 = posición 0, 3> 2, la posición de cambio; este 3 posición se convierte en 0, el nodo padre (0-1) / 2 = 0 posición, y que no se mueven a sí mismos;
este caso:
3
/
12
(4) 6 se inserta, el nodo padre (3-1) / 2 = la posición 1, 6> 1, la posición de cambio, una posición de las 6 en este momento se convierte en un nodo padre (1-1) / 2 = 0 posición; 6> 3, continúan intercambiando;
6
/
32
/
1
código del núcleo
(Índice-1) / 2 es la ubicación del nodo padre del índice
void heapinsert(int arr[],int index)
{
while(arr[index] > arr[(index-1)/2])
{
swap(arr[index],arr[(index-1)/2]);
index = (index-1)/2;
}
}
Utilizar un bucle a través de la matriz, heapinsert llamada
for(int i = 0;i < length;i++ )
{
heapinsert(arr,i);//用for循环传入要处理的index
}
El código completo
#include<iostream>
#define length 5
using namespace std;
void swap(int &a,int &b)
{
int temp = a;
a = b;
b = temp;
}
void heapinsert(int arr[],int index)
{
while(arr[index] > arr[(index-1)/2])
{
swap(arr[index],arr[(index-1)/2]);
index = (index-1)/2;
}
}
int main()
{
//int arr[length] = {2,1,3,6,0,4};
int arr[length] = {3,4,5,1,2};
int heapsize = length;
for(int i = 0;i < length;i++ )
{
heapinsert(arr,i);//用for循环传入要处理的index
}
system("pause");
return 0;
}
complejidad del tiempo
Además de un número requerido de altura comparativo de las vistas de árbol, O (logN), cuando 0 a i-1 se añadió una pocas necesidad de comparar log (I-1) veces; el número N necesidad log1 + log 2 + ... + log (N-1) = log (N)
3.heapify: Supongamos que la matriz durante un valor menor, reajustada para apilar raíz grande
análisis
1. Encontrar el valor máximo de la cantidad de niños a izquierda y derecha, el valor máximo se compara con el cambio, si el cambio es mayor que el valor máximo de los hijos izquierdo y derecho, la conmutación de dos números, y luego para encontrar el izquierdo y el intercambio de los niños correctas, la comparación continúa.
2. Continuar con la condición de comparación: los niños no se queden fuera de los límites.
código del núcleo
Y comparando el número actual de niños de todo, encontrar el valor máximo asignado a la más grande, y si el número actual es el mayor salto, si no, los dos números intercambiados, índice de actualización, y los niños posición izquierda, siguen comparar.
void heapify(int arr[],int index,int heapsize)
{
int left = index * 2 + 1;
while(left < heapsize)
{
int largest = left + 1 < heapsize && arr[left]<arr[left + 1] ?
left + 1:left;
largest = arr[largest] > arr[index] ? largest : index;
if(largest == index)
break;
swap(arr[largest],arr[index]);
index = largest;
left = index * 2 + 1;
}
}
El código completo
#include<iostream>
#define length 6
using namespace std;
void swap(int &a,int &b)
{
int temp = a;
a = b;
b = temp;
}
void heapify(int arr[],int index,int heapsize)
{
int left = index * 2 + 1;
while(left < heapsize)
{
int largest = left + 1 < heapsize && arr[left]<arr[left + 1] ?
left + 1:left;
largest = arr[largest] > arr[index] ? largest : index;
if(largest == index)
break;
swap(arr[largest],arr[index]);
index = largest;
left = index * 2 + 1;
}
}
int main()
{
//int arr[length] = {2,1,3,6,0,4};
int arr[length] = {6,5,4,3,5,2};
int heapsize = length;
arr[0] = 1;
heapify(arr,0,heapsize);
system("pause");
return 0;
}
4. heapsort
análisis
heapinsert combinarse heapify.
(1) se convierte en matriz de modo gran pila raíz (heapinsert);
(2) mantenimiento de la última parte superior de la pila y el tamaño intercambio montón menos uno (Guardar máximo)
(3) re-pila se hace grande de raíz, elementos que corresponden a la parte superior de la pila entonces pequeños reordenamientos (heapify)
(. 4) se detiene hasta que un tamaño de la pila.
código del núcleo
1.heapinsert
void heapinsert(int arr[],int index)
{
while(arr[index] > arr[(index-1)/2])
{
swap(arr[index],arr[(index-1)/2]);
index = (index-1)/2;
}
}
2.heapify
void heapify(int arr[],int index,int heapsize)
{
int left = 2*index+1;
while (left < heapsize)
{
int largest = left+1<heapsize && arr[left+1]>arr[left]?
left+1:left;
largest = arr[index] < arr[largest]?largest:index;
if(index == largest)
break;
swap(arr[index],arr[largest]);
index = largest;
left = 2*index+1;
}
}
3.heapsort
void heapsort(int arr[],int heapsize)
{
while(heapsize > 1)
{
swap(arr[0],arr[heapsize-1]);
heapsize--;
heapify(arr,0,heapsize);
}
}
El código completo
#include<iostream>
#include<time.h>
#define length 10
using namespace std;
void swap(int &a,int &b)
{
int temp = a;
a = b;
b = temp;
}
void heapify(int arr[],int index,int heapsize)
{
int left = 2*index+1;
while (left < heapsize)
{
int largest = left+1<heapsize && arr[left+1]>arr[left]?
left+1:left;
largest = arr[index] < arr[largest]?largest:index;
if(index == largest)
break;
swap(arr[index],arr[largest]);
index = largest;
left = 2*index+1;
}
}
void heapsort(int arr[],int heapsize)
{
while(heapsize > 1)
{
swap(arr[0],arr[heapsize-1]);
heapsize--;
heapify(arr,0,heapsize);
}
}
void heapinsert(int arr[],int index)
{
while(arr[index] > arr[(index-1)/2])
{
swap(arr[index],arr[(index-1)/2]);
index = (index-1)/2;
}
}
int main()
{
srand((unsigned)time(NULL));
int arr[length] ;
int heapsize = length ;
cout<<"arr = ";
for(int i = 0;i<heapsize;i++)
{
arr[i] = rand()%10;
cout<<arr[i]<<" ";
heapinsert(arr,i);
}
cout<<endl<<"arr1 = ";
heapsort(arr,heapsize);
for(int i = 0;i<length;i++)
{
cout<<arr[i]<<" ";
}
cout<<endl;
//system("pause");
return 0;
}
complejidad del tiempo
O (N * logN), no tiene en cuenta el establecimiento de la pila de proceso, cada logN clasificación, la fila N.
