Secuencia Bitónica
Una sucesión se llama bitónica si primero es creciente y luego decreciente. En otras palabras, una array arr[0..ni] es bitónica si existe un índice i donde 0<=i<=n-1 tal que
x0 <= x1 …..<= xi and xi >= xi+1….. >= xn-1
- Una secuencia ordenada en orden creciente se considera bitónica con la parte decreciente vacía. De manera similar, la secuencia de orden decreciente se considera bitónica con la parte creciente como vacía.
- Una rotación de secuencia bitónica también es bitónica.
Clasificación bitónica
Se trata principalmente de dos pasos.
- Formando una secuencia bitónica (discutida anteriormente en detalle). Después de este paso llegamos a la cuarta etapa en el siguiente diagrama, es decir, la array se convierte en {3, 4, 7, 8, 6, 5, 2, 1}
- Creación de una secuencia ordenada a partir de una secuencia bitónica: después del primer paso, la primera mitad se ordena en orden creciente y la segunda mitad en orden decreciente.
Comparamos el primer elemento de la primera mitad con el primer elemento de la segunda mitad, luego el segundo elemento de la primera mitad con el segundo elemento de la segunda, y así sucesivamente. Intercambiamos elementos si un elemento de la primera mitad es más pequeño.
Después de los pasos anteriores de comparación e intercambio, obtenemos dos secuencias bitónicas en una array. Vea la quinta etapa en el siguiente diagrama. En la quinta etapa tenemos {3, 4, 2, 1, 6, 5, 7, 8}. Si observamos más de cerca los elementos, podemos notar que hay dos secuencias bitónicas de longitud n/2, de modo que todos los elementos de la primera secuencia bitónica {3, 4, 2, 1} son más pequeños que todos los elementos de la segunda secuencia bitónica. {6, 5, 7, 8}.
Repetimos el mismo proceso dentro de dos secuencias bitónicas y obtenemos cuatro secuencias bitónicas de longitud n/4 de manera que todos los elementos de la secuencia bitónica más a la izquierda son más pequeños y todos los elementos de la más a la derecha. Vea la sexta etapa en el siguiente diagrama, las arrays son {2, 1, 3, 4, 6, 5, 7, 8}.
Si repetimos este proceso una vez más, obtenemos 8 secuencias bitónicas de tamaño n/8, que es 1. Dado que todas estas secuencias bitónicas están ordenadas y cada secuencia bitónica tiene un elemento, obtenemos la array ordenada.
Java
/* Java program for Bitonic Sort. Note that this program
works only when size of input is a power of 2. */
public class BitonicSort {
/* The parameter dir indicates the sorting direction,
ASCENDING or DESCENDING; if (a[i] > a[j]) agrees
with the direction, then a[i] and a[j] are
interchanged. */
void compAndSwap(int a[], int i, int j, int dir)
{
if ((a[i] > a[j] && dir == 1) || (a[i] < a[j] && dir == 0)) {
// Swapping elements
int temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
/* It recursively sorts a bitonic sequence in ascending
order, if dir = 1, and in descending order otherwise
(means dir=0). The sequence to be sorted starts at
index position low, the parameter cnt is the number
of elements to be sorted.*/
void bitonicMerge(int a[], int low, int cnt, int dir)
{
if (cnt > 1) {
int k = cnt / 2;
for (int i = low; i < low + k; i++)
compAndSwap(a, i, i + k, dir);
bitonicMerge(a, low, k, dir);
bitonicMerge(a, low + k, k, dir);
}
}
/* This function first produces a bitonic sequence by
recursively sorting its two halves in opposite sorting
orders, and then calls bitonicMerge to make them in
the same order */
void bitonicSort(int a[], int low, int cnt, int dir)
{
if (cnt > 1) {
int k = cnt / 2;
// sort in ascending order since dir here is 1
bitonicSort(a, low, k, 1);
// sort in descending order since dir here is 0
bitonicSort(a, low + k, k, 0);
// Will merge whole sequence in ascending order
// since dir=1.
bitonicMerge(a, low, cnt, dir);
}
}
/*Caller of bitonicSort for sorting the entire array
of length N in ASCENDING order */
void sort(int a[], int N, int up)
{
bitonicSort(a, 0, N, up);
}
/* A utility function to print array of size n */
static void printArray(int arr[])
{
int n = arr.length;
for (int i = 0; i < n; ++i)
System.out.print(arr[i] + " ");
System.out.println();
}
// Driver method
public static void main(String args[])
{
int a[] = { 3, 7, 4, 8, 6, 2, 1, 5 };
int up = 1;
BitonicSort ob = new BitonicSort();
ob.sort(a, a.length, up);
System.out.println("\nSorted array");
printArray(a);
}
}
Producción:
Sorted array 1 2 3 4 5 6 7 8
Complejidad de tiempo : O(n*log 2 (n))
Espacio auxiliar : O(1)
¡ Consulte el artículo completo sobre Bitonic Sort para obtener más detalles!
Publicación traducida automáticamente
Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA