operación de clasificación en el proceso de desarrollo a menudo se enfrenta a muchos problemas complejos a menudo son capaces de ordenar a través de la secuencia y más fácil. Un buen algoritmo de clasificación a menudo puede ahorrar una gran cantidad de recursos de tiempo y espacio.
Dependiendo del número de registros a clasificar, un proceso de tipo diferente cuando se utiliza la memoria, se pueden clasificar en dos categorías: clasificación interna, se refiere a todos los registros de ordenar que se almacena en la memoria de acceso aleatorio en un ordenador de proceso de clasificación; externa ordena, se refiere al número de registros que se ordenan muy grande, no se puede poner toda la memoria, la necesidad de registros de acceso a memoria externa en la visita proceso de clasificación.
clasificación interna
-
Categorías
se clasifican de acuerdo con el principio de clasificación interna se puede dividir en: ordenación por inserción, cambio de clasificación, ordenación por selección, ordenamiento por mezcla clasificación y recuento de cinco categorías.
De acuerdo con la carga de trabajo necesaria para el proceso de clasificación de clase se puede dividir en: sencilla pedido (tiempo de complejidad es O (n ^ 2)), avanzado método de clasificación (tiempo de complejidad (nlogn) grados O) grados y Radix sort (Tiempo Complejidad es O (d * n)). -
ordenación por inserción
ordenación por inserción es un método de clasificación simple, su funcionamiento básico consiste en insertar un registro en una lista ordenada, y luego obtener una nueva y ordenada, además de un número de la lista de registros nuevos.
//直接插入排序
void insertSort (int[] a) { //非递减排序
int n = a.length;
if (n < 2) return; //待排序的记录少于两个
for (int i = 1; i < n; i ++) { //a[0]为初始有序序列，进行n - 1次插入排序
int t = a[i]; //待插入元素
int j = 0;
for (j = i - 1; j >= 0 && a[j] > a[t]; j --) { //对于大于待插入元素的的记录右移
a[j + 1] = a[j];
}
a[j + 1] = t;
}
}
La ordenación por inserción se basa en una secuencia ordenada, mirada para insertar una posición de inserción de registro, y luego insertar en esta posición y lograr, si vamos a encontrar la posición de inserción utilizando binario proceso de búsqueda puede evolucionar parecer ordenación por inserción - - inserción binaria.
//折半插入排序
void bInsertSort( int[] a) {
int n = a.length;
if (n < 2) return;
for (int i = 1; i < n; i ++) {
int left = 0, right = i - 1;
while (left <= right) {
int mid = (left + right) / 2;
if (a[mid] < a[i]) left = mid + 1;
else right = mid - 1;
}
int t = a[i];
for (int j = i - 1; j >= right + 1; j --) {
a[j + 1] = a[j];
}
a[right + 1] = t;
}
}
inserción binario y reduce el número de registros registrados en la comparación lista ordenada que se inserta, pero el número del elemento móvil no se ha reducido, todavía es complejidad de tiempo es O (n ^ 2). Con el fin de reducir el número de movimiento registrado también propuesto un algoritmo de ordenación de 2 vías.
//2路插入排序
int[] insertSort2(int[] a) {
int n = a.length;
if (n < 2) return a;
int[] b = new int[n];
b[0] = a[0];
int first = 0;
int last = 0;
for (int i = 1; i < n; i ++) {
if (a[i] >= b[0]) {
int j = 0;
for (j = last; a[i] < b[j]; j --) b[j + 1] = b[j];
b[j + 1] = a[i];
last ++;
} else {
if (first == 0) {
b[n - 1] = a[i];
first = n - 1;
} else {
int j = 0;
for (j = first; b[j] < a[i]; j ++) b[j - 1] = b[j];
b[j - 1] = a[i];
first --;
}
}
}
return b;
}
Colina sorting especie conocida como la reducción gradual, que también pertenece a la clase del método de ordenación por inserción, pero ha mejorado mucho la eficiencia del tiempo. Su complejidad y la secuencia temporal de los logros incrementales relacionados con el cálculo es más complejo, ya que se relaciona con problemas de matemáticas sin resolver, no existe un método de cálculo.
La idea básica es para ordenar toda la colina de la columna a clasificar en una pluralidad de sub-secuencias, y luego la secuenciación directa para cada sub-secuencia, después repetidamente ordenada de acuerdo a la secuencia incrementales, toda la secuencia se convertirá en el orden básico, de modo que a continuación, utilizar el tipo de inserción directa será más fácil. Por lo general, seleccione d [k] = 2 ^ ( t - k + 1) como la secuencia de incremento (Se observó que esta secuencia ordenada de acuerdo con la complejidad de tiempo es O (n ^ (3/2)) ), t es el número de veces tipo.
//希尔排序
void sellSort(int a[],int[] d) {
int n = a.length;
int m = d.length;
if(n < 2 || m < 1) return;
for (int i = 0; i < m; i ++) { //对a进行m趟希尔排序
insertSort(a,d[i]);
}
}
/*
* 一趟希尔排序
* */
void insertSort (int[] a,int d) {
int n = a.length;
for (int i = d; i < n;i ++) {
if (a[i] < a[i - d]) {
int t = a[i];
int j = i - d;
while (j >= 0 && t < a[j]) {
a[j + d] = a[j];
j -= d;
}
a[j + d] = t;
}
}
}
- tipo de cambio
ordenamiento de burbuja
fregadero grande hacia abajo.
//冒泡排序
void guLuGuLuSort(int[] a) {
int n = a.length;
if (n < 2) return;
for (int i = 0; i < n - 1; i ++) {
for (int j = 0; j < n - 1 - i; j ++) {
if (a[j] > a[j + 1]) {
int t = a[j];
a[j] = a[j + 1];
a[j + 1] = t;
}
}
}
}
Quicksort (O (n * LGN))
//递归实现
void quickSort(int[] a,int l,int r) {
if (l >= r) return;
int i = l,j = r;
int mid = a[l];
while (l < r) {
while (l < r && a[r] >= mid) r --;
a[l] = a[r];
while (l < r && a[l] <= mid) l ++;
a[r] = a[l];
}
a[l] = mid;
quickSort(a,i,l - 1);
quickSort(a,l + 1,r);
}
-
selección Ordenar
Seleccione la fila
se selecciona en el valor mínimo de n elementos en una primera posición, la selección de n - un mínimo de elementos en la segunda posición seleccionada ... n - elementos i en el valor mínimo de i + 1 posición.
//简单选择排序
void selectSort(int[] a) {
int n = a.length;
if (n < 2) return;
for(int i = 0; i < n; i ++) {
int min = a[i];
int p = i;
for (int j = i;j < n; j++) {
if (a[j] < a[i]) {
min = a[j];
p = j;
}
}
a[p] = a[i];
a[i] = min;
}
}
- Combinar una especie
de mezcla de clasificación se basa en la fusión de los dos lista ordenada llevado a cabo sobre la base de una lista. Vamos a empezar a ordenar cada elemento considerado como una lista ordenada, tal acción se fusionarán en una pluralidad de veintidós ha lista de dos elementos ordenados. Esta lista ordenada es entonces entonces dos elementos pairwise combinados para formar una lista ordenada de la pluralidad tiene cuatro elementos ... y así sucesivamente hasta que una lista ordenada de síntesis de n elementos.
complejidad Tiempo de O (n * LGN), la complejidad espacial de O (n)
public void mergeSort (int[] a, int l,int t) {
if (l == t) return;
int m = (l + t) / 2;
mergeSort(a,l,m);
mergeSort(a,m + 1,t);
merge(a,l,m,t);
}
public void merge (int[] a, int l, int m, int t) {
int n = a.length;
int[] b = new int[n];
int i = l, j = m + 1;
int k = l;
while (i <= m && j <= t) {
if (a[i] <= a[j]) {
b[k ++] = a[i ++];
} else {
b[k ++] = a[j ++];
}
}
while (i <= m) {
b[k ++] = a[i ++];
}
while (j <= t) {
b[k++] = a[j++];
}
i = l;
while (i <= t) {
a[i] = b[i ++];
}
}
- Radix sort
/*
* 假设待排对象的元素为正整数
* */
public void sort(int[] a) {
if (a.length < 2) return;
Note head = new Note();
Note p = head;
int max = Integer.MIN_VALUE;
for (int i = 0; i < a.length; i ++) { //将数组转换链表，顺便找一下最大值
if (a[i] > max) {
max = a[i];
}
Note note = new Note();
note.data = a[i];
note.next = null;
p.next = note;
p = p.next;
}
int i = 1;
while (max != 0) { //进行多次分发和收集
head = FAC(head, i);
max /= 10;
i ++;
}
p = head.next;
i = 0;
while (p != null) { //放回到数组
a[i ++] = p.data;
p = p.next;
}
}
/*
* 参数l表示关键字的位置，如l = 1则表示个位为此次分发和收集的关键字
* */
public Note FAC(Note head,int l) {
Note[] h = new Note[10]; //十个分发链的头
Note p = head.next;
while (p != null) { //分发
int k = (p.data / (int)Math.pow(10,l -1)) % 10;
if (h[k] == null) {
h[k] = new Note();
}
Note q = h[k];
while (q.next != null) {
q = q.next;
}
q.next = p;
p = p.next;
q.next.next = null;
}
Note newHead = new Note();
for (int i = 0; i< 10; i++) { //合并
if (h[i] != null) {
Note q = newHead;
while (q.next != null) {
q = q.next;
}
q.next = h[i].next;
}
}
return newHead;
}
class Note {
int data;
Note next;
}
