directorio
La secuenciación sencilla
Ordenar burbuja
Dos elementos adyacentes cada comparación, la mayor (menor) se cambian a la parte de atrás, para hacer que cada pase en una determinada posición de su secuencia aleatoria máximo elemento (más pequeño). N veces para llevar a cabo toda ordenado la matriz, preferiblemente un tiempo de complejidad O (N), la media, la peor son O (N ^ 2), la complejidad espacial es O (1), es estable.
void BubbleSort(Item a[],int n)
{
for(int i=0;i<n-1;i++) //执行n趟
for(int j=0;j<n-1-i;j++) //第i趟的a[n-i]~a[n]已经排好序，不用重复比较
{
if(a[j]>a[j+1]) //以升序排列为例
{
swap(a[j],a[j+1]);
}
}
}Ordenar la inserción
Cada vez que el primer elemento de la secuencia no ordenada de uno en uno en comparación con la secuencia ordenada de elementos, se inserta en la posición correcta, formando secuencia nueva ordenada de n veces, hasta que se ordena la secuencia completa. Este método asegura que los delanteros subsecuencias están ordenadas. Preferiblemente tiempo complejidad O (N), la media, lo peor de O (N ^ 2), la complejidad espacial es O (1), es estable.
void InsertSort(Item a[],int n)
{
for(int i=1;i<n;i++) //执行n趟，每趟i都指向无序序列的第一个元素
{
int j=i-1; //初始化j，指向有序序列的最后一个元素
while(j>1&&a[j]>a[i]) //当待插入元素小于当前j指向的元素，则将a[j]往后移一位，为待插入元素腾位置
{
a[j]=a[j-1]; //再继续检查前面的所有元素，直到a[j]<a[i]，此时j指向的就是需要插入的位置
j--;
}
a[j]=a[i];
}
}selección Ordenar
Identificar cada secuencia aleatoria desde el máximo valor y una posición de secuencia no ordenada primer elemento de conmutación, este método puede garantizar la secuencia antes de que el promotor están ordenadas. complejidad Tiempo Preferiblemente, el peor de los casos, el peor son O (N ^ 2), ya sea como una sonda de un mínimo debe ser ordenado. complejidad espacial es O (1), es inestable, por ejemplo: [58529], 5 y 2 después de la primera de cambio, el segundo en la parte posterior 5, y sus posiciones relativas cambiadas.
void SelectSort(Item a[],int n)
{
for(int i=0;i<n;i++)
{
for(int j=i,min_pos=i;j<n;j++) //a[i]~a[n]是无序区间，初始化最小元素下标为i
{
if(a[j]<a[min_pos]) //更新最小元素下标
{
min_pos=j;
}
}
swap(a[i],a[min_pos]) //交换无序区间第一个元素与无序区间最小元素的位置
}
}Ordenación rápida
Para un elemento de la matriz como un pivote (un estándar división), llamadas recursivas por viaje es menor que el valor del pivote pivote izquierda a la derecha es mayor que el valor del pivote, por lo que cada llamada recursiva puede determinar un elemento la posición final. Recursive condición final L> = R, es decir, la secuencia que debe clasificarse cuando sólo un elemento, está claro que el orden, entonces la parte posterior actual a la anterior recursión recursión.
void QuickSort(Item a[],int l,int r)
{
if(l>=r) return; //序列中只有一个元素时结束递归
int i=partition(a,l,r); //获得枢轴的下标
QuickSort(a,l,i-1); //对枢轴左半部分调用快排
QuickSort(a,i+1,r); //对枢轴右半部分调用快排
}
int partition(Item a[],int l,int r)
{
//规定一个元素为枢轴，并获得它的最终位置，使在它左边的数都小于它，在它右边的数都大于它
//让元素a[l]的值作为枢轴值
int x=a[l];
int i=l,j=r;
while(i!=j)
{
while(j>i&&a[j]>=x) j--;
if(j>i) //此时退出while是因为j指向比枢轴值小的数
{
a[i]=a[j]; //直接覆盖i指向的元素，放在枢轴左边
i++;
}
while(j<i&&a[i]<x) i++;
if(j>i) //此时i指向比枢轴值大的数
{
a[j]=a[i]; //放在枢轴右边
j--;
}
//由于第一次覆盖的元素就是枢轴，是我们已知的，所以直接覆盖不会丢失数据。
//而在这之后被覆盖的元素都是无关紧要的，因为它的值在上一步已经去了它该去的位置了。
//执行到最后，只有枢轴值x不知道它该去的位置在哪里，显然，就是i=j的位置。
}
a[i]=x;
}
Combinar especie
columna Ordenar para ser dividido en extremos aproximadamente iguales izquierdo y derecho de tamaño, respectivamente, seguido de dos secuencias terminales secuenciales ordenamiento por mezcla de forma recursiva hasta que hay sólo un elemento en la secuencia, el final de la recursión. Al final de cada ronda recursión, un área ambos lados están ordenados por separado. En este momento, tiene buena descarga y entonces ordenó dos secuencias en una secuencia, en un área de trabajo, de vuelta a la recursión anterior continúa hasta que se mezclen en una secuencia de longitud original. Por último, la secuencia de buena fila secuencia completa con un área de trabajo para actualizar la secuencia original de los elementos a clasificar.
void MergeSort(Item a[],int l,int r)
{
int mid=(l+r)/2;
if(r<=l) return;
MergeSort(a,l,mid);
MergeSort(a,mid+1,r);
MergeAB(a,b,l,m,r);
}
void MergeAB(Item a[],Item b[],int l,int m,int r)
{
int i=l,j=mid+1,k=0; //指针指向两个子序列的第一个元素
while(i<=mid&&j<=r) //若未超出所指示的子序列，则将较小值存入工作区b
{
if(a[i]<a[j]) b[k++]=a[i];
else b[k++]=a[j];
}
if(i>m) //若i先超出所子序列，则只需把j还未遍历的数组全部赋给工作区b
{
while(j<=r) b[k++]=a[j++];
}
else //若i先超出所子序列，则只需把j还未遍历的数组全部赋给工作区b
while(i<=mid) b[k++]=a[i++];
for(int i=l;i<=r;i++)
{
a[i]=b[i]; //再把工作区b里的序列复制到数组a去
}
}
heapsort
La secuencia que se va ordenadas según las características estructurales del árbol binario completo en una matriz, el almacenamiento de claves debe comenzar en 1, el elemento de la matriz Salí de niño es 2i, el hijo derecho es 2i + 1. Después construido después de la pila, para ordenar una secuencia de n elementos se ordenan, correspondiente a n veces la pila se ajusta, la corriente de salida mínima (grandes) elementos, con el último elemento de la matriz (es decir, el árbol binario completo Por último, un nodo hoja) superior sustituido de los elementos de la pila, haciendo que la pila de reajuste.
void Sift(Item R[],int low,int high)
{
//这是一个自上而下的堆调整
int i=low,j=2*i; //j是i的左孩子
int temp=R[i];
while(j<=high)
{
if(j<high&&R[j]<R[j+1]) //右孩子更大
{
j++; //j指向右孩子
}
/*以上操作使j指向左右孩子中较大的一个*/
if(temp<R[j])
{
R[i]=R[j];
i=j; //i下降，不用管另一个孩子，因为R[i]与R[j]的交换没有影响到另一个孩子及其子树
j=i*2; //j仍指向i的左孩子
}
else break;
}
R[i]=temp; //被调整结点的值放入最终位置
//最终要找到一个R[j]不大于当前根节点R[low]的地方将temp放进去，如果j走到最后都没有这样的位置，说明R[low]就是最大的，就把一开始放在temp里的值再还给R[low]
}
/*堆排序函数*/
void HeapSort(Item R[],int n)
{
for(int i=n/2;i>=1;i--) //从最后一个叶子结点的父节点开始，自下而上，自右向左调整，每次以结点i为堆的根结点
Sift(R,i,n);
/*上面是堆的初始化，下面是每一轮最值的输出和后续的调整*/
for(int i=n;i>=2;i--) //从最后一个叶子结点开始，自下而上，自右向左，每次用最后一个叶子结点替换堆顶结点，从而引起新一轮的调整
{
temp=R[1];
R[1]=R[i];
R[i]=temp;
Sift(R,1,i-1); //开始新的一轮调整是从下到下，从左到右的，由于第i个元素已经有序，所以只需要调整到第i-1个元素
}
}En otras palabras, el proceso de clasificación de pila de clasificación desde el nodo padre es la última hoja inicio nodo, de derecha a izquierda, de abajo hacia arriba, a la orden del nodo es la raíz del árbol luego de arriba abajo, de izquierda a ajustes necesarios hasta que todo el árbol binario completo árbol por cada niño se cumplan de una grande (pequeña) de la raíz montón. Después de la parte superior de la pila de salida, con la última hoja de unión nodo superior Alternativamente pila, a continuación, la pila no puede satisfacer grandes (pequeñas) propiedades de raíz montón, necesidad de ser ajustados, esta vez sólo desde la parte superior de la pila de arriba a abajo, de izquierda a derecha para ajustar,
Ordenar conteo
Encontrar el valor máximo max y el valor mínimo min de la secuencia, la diferencia en su longitud como para abrir un espacio array dist C, traversal secuencia a, a cada visita a un [i], la aplicación de c [min + i] ++, por último, con el fin de c [min + i] º a [i] en una matriz de longitud longitud (a) para ir.
cubo especie
2 bits de los elementos de barril tales como tipo, de acuerdo con aplicar primero la base de la bañera 10, entonces el valor del dígito de las decenas de los elementos respectivos en la bañera, y a continuación, ordena el interior de cada cubo, el ordenadas cosiendo juntos para obtener una secuencia ordenada.
Radix sort
De hecho, el pensamiento sobre el mismo con el cubo especie, pero sólo por entero la clasificación, el primer bit que debe clasificarse como punto de referencia, ordenar resultados colocan juntos en una falsa secuencia ordenada, entonces esta secuencia clasifica como punto de referencia a diez, ordenar resultados uniendo obtener una verdadera secuencia ordenada.
Tomado de la imagen: https://www.jianshu.com/p/134a0eed5e3a
