[Estructura de datos] Conceptos básicos: seis algoritmos de clasificación (clasificación de inserción simple, clasificación de colinas, clasificación de burbujas, clasificación rápida, clasificación de selección simple, clasificación de pila)

Others 2020-10-15 15:58:18 views: null

Directorio de artículos

I. Introducción

La estructura de datos tiene solo cinco puntos de prueba: lista vinculada (incluida la pila y la cola), árbol binario, gráfico, búsqueda y
clasificación. Tres puntos de prueba de clasificación: comparación de todos los algoritmos de clasificación + principios de cada algoritmo de clasificación + características de cada algoritmo de clasificación

Dos, clasificación de inserción simple

2.1 demostración + resultado en ejecución

#include <iostream>

using namespace std;
void InsertSort(int r[],int n)   //0号单元为暂存单元和监视哨    
{
    
    
    int j=0;
    for(int i=2; i<=n; i++)
    {
    
    
        r[0]=r[i];                     //用于暂存待排序元素  
        for ( j=i-1; r[0]<r[j]; j--)    //寻找合适的插入位置
            r[j+1]=r[j];                  //移动
        r[j+1]=r[0];
    }

}
int main()
{
    
    
    int a[5];
    for (int i=0; i<5; i++)
        cin>>a[i];
    cout<<endl;
    InsertSort(a,5);
    for (int i=1; i<5; i++)
    {
    
    
        cout<<a[i];
        cout<<" ";
    }
    cout<<endl;
    return 0;
}

resultado de la operación:

​​​​Inserte la descripción de la imagen aquí

2.2 Características: clasificación de inserción simple

Orden de inserción simple:
1. La complejidad del tiempo es O (n ^ 2), debido a dos bucles;
2. La complejidad del espacio es O (1), un centinela temporal;
3. Solo movimientos adyacentes, sin jitter, es uno Una clasificación estable:
4. Es adecuada para la situación en la que la secuencia está básicamente ordenada.

Tres, tipo colina

Resumen: La clasificación Hill, un método de clasificación avanzado, se puede considerar como una versión mejorada de la clasificación de inserción simple

3.1 Demo + resultado en ejecución

#include <iostream>
 
using namespace std;
void shellSort(int r[],int n)
{
    
    
    for (int d=n/2; d>=1; d=d/2)
    {
    
    
 
        for (int i=d+1; i<=n; i++) //d为增量
        {
    
    
 
            r[0]=r[i];    //0号元素用于暂存  没有意义
            int j=0;
            for ( j=i-d; j>0&&r[0]<r[j]; j=j-d)
                r[j+d]=r[j];           //记录每次移动d个位置，跳跃移动
            r[j+d]=r[0];
        }
    }
}
int main()
{
    
    
    int a[6];
    for (int i=0; i<6; i++)
        cin>>a[i];
    cout<<endl;
    shellSort(a,6);
    for (int i=1; i<6; i++)
    {
    
    
        cout<<a[i];
        cout<<" ";
    }
 
    cout<<endl;
    return 0;
}

resultado de la operación:

Inserte la descripción de la imagen aquí

3.2 Características: clasificación de colinas


Clasificación de colinas: 1. La complejidad del tiempo es O (nlgn) ~ O (n ^ 2), que es el resultado de una gran cantidad de experimentos repetidos;
2. La complejidad del espacio es O (1), un centinela temporal;
3. Hay un jitter El movimiento es de tipo inestable.

Cuarto, clasificación de burbujas

Resumen: clasificación de burbujas, una clasificación de bajo nivel, fácil de entender

4.1 Demo + resultado en ejecución

#include <iostream>
 
using namespace std;
void bubbleSort(int r[],int n)
{
    
    
    int exchange=n;
    while(exchange!=0)
    {
    
    
 
        int  bound=exchange;
        exchange=0;
        for (int j=1; j<bound; j++)
        {
    
    
            if(r[j]>r[j+1])
            {
    
    
                r[0]=r[j];         //0号元素用于交换暂存
                r[j]=r[j+1];
                r[j+1]=r[0];
                exchange=j;
            }
        }
    }
}
int main()
{
    
    
    int a[6];
    for (int i=0; i<6; i++)
        cin>>a[i];
    cout<<endl;
    bubbleSort(a,6);
    for (int i=1; i<6; i++)
    {
    
    
        cout<<a[i];
        cout<<" ";
    }
 
    cout<<endl;
    return 0;
}

resultado de la operación:

Inserte la descripción de la imagen aquí

4.2 Características: clasificación de burbujas

Clasificación de burbujas:
1. La complejidad del tiempo es O (n ^ 2), debido a dos bucles;
2. La complejidad del espacio es O (1), un centinela temporal;
3. Solo hay movimientos adyacentes, sin jitter, que es uno Una especie estable.

Cinco, clasificación rápida (enfoque de entrevista)

Resumen: la clasificación rápida, una clasificación avanzada, puede verse como una versión mejorada de la clasificación de burbujas

5.1 Demo + resultado en ejecución

#include <iostream>
 
using namespace std;
int Partition(int r[],int first,int _end)
{
    
    
 
    int i=first;int j=_end;
    while(i<j)
    {
    
    
 
        while(i<j && r[i]<=r[j])  j--;
        if(i<j)
        {
    
    
 
            int temp=r[i];
            r[i]=r[j];
            r[j]=temp;
            i++;
        }
        while(i<j && r[i]<=r[j]) i++;
        if(i<j)
        {
    
    
 
            int temp=r[i];
            r[i]=r[j];
            r[j]=temp;
            j--;
        }
    }
    return i;
}
void QuickSort(int r[],int first,int _end)
{
    
    
    if(first<_end)
    {
    
    
        int pivot=Partition(r,first,_end);
        QuickSort(r,first,pivot-1);
        QuickSort(r,pivot+1,_end);
    }
}
int main()
{
    
    
    int a[6];
    for (int i=0; i<6; i++)
        cin>>a[i];
    cout<<endl;
    QuickSort(a,0,5);
    for (int i=0; i<6; i++)
    {
    
    
        cout<<a[i];
        cout<<" ";
    }
 
    cout<<endl;
    return 0;
}

resultado de la operación:

Inserte la descripción de la imagen aquí

5.2 Funciones: Clasificación rápida


Clasificación rápida: 1. La complejidad del tiempo es O (nlgn);
2. La complejidad del espacio es O (1), una variable de intercambio (puede omitir esta variable cuando hace un uso razonable de la suma y la resta durante el intercambio);
3. Hay jitter, que no es Clasificación estable;

Seis, clasificación de selección simple

Resumen: clasificación de selección simple, un método de clasificación de bajo nivel, fácil de entender

6.1 Demo + resultado en ejecución

#include <iostream>
 
using namespace std;
void selectSort(int r[],int n)
{
    
    
    for (int i=1; i<n; i++)
    {
    
    
 
        int index=i;
        int j=0;
        for (j=i+1; j<=n; j++)
        {
    
    
            if(r[j]<r[index])
            {
    
    
                r[0]=r[j];           //0号元素用于暂存玩车个交换
                //  其实可以不用这样，使用加减法可以不需要暂存元素，这里方便读者理解，用简单的方式
                r[j]=r[index];
                r[index]=r[0];
            }
        }
        if(index!=i)
        {
    
    
 
            r[0]=r[i];
            r[i]=r[index];
            r[index]=r[0];
        }
    }
}
int main()
{
    
    
    int a[6];
    for (int i=0; i<6; i++)
        cin>>a[i];
    cout<<endl;
    selectSort(a,6);
    for (int i=1; i<6; i++)
    {
    
    
        cout<<a[i];
        cout<<" ";
    }
 
    cout<<endl;
    return 0;
}

resultado de la operación:

Inserte la descripción de la imagen aquí

6.2 Funciones: selección y clasificación simples

Clasificación de selección simple:
1. La complejidad del tiempo es O (n ^ 2) debido a dos bucles;
2. La complejidad del espacio es O (1), y se utiliza un elemento de almacenamiento temporal para realizar el intercambio (no es necesario, puede agregar dos números) La resta realiza el intercambio de dos números);
3. Hay rebote de elementos, que es un tipo inestable;
4. No hay preferencia por la aplicación, porque la mejor y la peor complejidad de tiempo promedio es O (n ^ 2)

Siete, tipo montón

Resumen: la clasificación de montón, un método de clasificación avanzado, puede verse como una versión mejorada de la clasificación de selección simple

7.1 Demo + resultado en ejecución

#include <iostream>
 
using namespace std;
void shift(int r[],int k,int m)
{
    
    
 
    int  i=k,j=2*i;   // i 为某个结点  2*i为该结点的左孩子
    while(j<=m)         //  其左孩子没到结束  说明该结点还是非叶子结点，因为叶子结点是没有左孩子的
    {
    
    
 
        if(j<m && r[j]<r[j+1]  )  j++;  //j和j+1  比较左右孩子，j指向较大者
        if(r[i]>r[j])  break;    //当根结点大于左右孩子中较大者，跳出本次循环
        else                //否则，交换根节点和左右孩子较大者
        {
    
    
            r[0]=r[j];   //0号元素用于交换暂存
            r[j]=r[i];
            r[i]=r[0];
            i=j;
            j=2*i;
        }
    }
}
 
void heapSort(int r[],int n)
{
    
    
    for (int i=n/2; i>=1; i--)
        shift(r,i,n);
    for (int i=1; i<n; i++)
    {
    
    
        r[0]=r[1];    //0号元素用于交换暂存
        r[1]=r[n-i+1];
        r[n-i+1]=r[0];
        shift(r,1,n-i);
    }
}
int main()
{
    
    
    int a[6];
    for (int i=0; i<6; i++)
        cin>>a[i];
    cout<<endl;
    heapSort(a,6);
    for (int i=1; i<6; i++)
    {
    
    
        cout<<a[i];
        cout<<" ";
    }
 
    cout<<endl;
    return 0;
}

resultado de la operación:

Inserte la descripción de la imagen aquí

7.2 Funciones: Clasificación de montón


Clasificación de montón: 1. La complejidad del tiempo es O (nlgn) debido a dos ciclos;
2. La complejidad del espacio es O (1) y un centinela temporal;
3. Hay un jitter, que es un tipo inestable;
4. Adecuado para seleccionar los primeros elementos más pequeños y los primeros elementos más grandes

8. Hoja de referencia de la entrevista (principio del algoritmo de clasificación + características del algoritmo de clasificación)

La estructura de datos tiene solo cinco puntos de prueba: lista vinculada (incluida la pila y la cola), árbol binario, gráfico, búsqueda y
clasificación. Tres puntos de prueba de clasificación: comparación de todos los algoritmos de clasificación + principios de cada algoritmo de clasificación + características de cada algoritmo de clasificación

Las características de cada algoritmo de clasificación se enumeran primero, y el principio del algoritmo de clasificación se discutirá más adelante.

Orden de inserción simple:
1. La complejidad del tiempo es O (n ^ 2), debido a dos bucles;
2. La complejidad del espacio es O (1), un centinela temporal;
3. Solo movimientos adyacentes, sin jitter, es uno Una clasificación estable:
4. Es adecuado para la situación en que la secuencia está básicamente ordenada. Clasificación de
colinas:
1. La complejidad del tiempo es O (nlgn) ~ O (n ^ 2), que es el resultado de una gran cantidad de experimentos repetidos;
2. La complejidad del espacio es O (1), un centinela temporal;
3. Hay un jitter El movimiento es de tipo inestable.

Clasificación de burbujas:
1. La complejidad del tiempo es O (n ^ 2), debido a dos bucles;
2. La complejidad del espacio es O (1), un centinela temporal;
3. Solo hay movimientos adyacentes, sin jitter, que es uno Una especie estable. Clasificación
rápida:
1. La complejidad del tiempo es O (nlgn);
2. La complejidad del espacio es O (1), una variable de intercambio (puede omitir esta variable cuando hace un uso razonable de la suma y la resta durante el intercambio);
3. Hay jitter, que no es Clasificación estable;

Clasificación de selección simple:
1. La complejidad del tiempo es O (n ^ 2) debido a dos bucles;
2. La complejidad del espacio es O (1), y se utiliza un elemento de almacenamiento temporal para realizar el intercambio (no es necesario, puede agregar dos números) La resta se da cuenta del intercambio de dos números);
3. Hay rebote de elementos, que es un tipo inestable;
4. No hay preferencia por la aplicación, porque la mejor y la peor complejidad de tiempo promedio es O (n ^ 2)
clasificación de pila:
1 , La complejidad del tiempo es O (nlgn), debido a dos ciclos;
2. La complejidad del espacio es O (1), y un centinela temporal;
3. Hay un jitter, que es un tipo inestable;
4. Adecuado para la selección Los primeros elementos más pequeños y los primeros elementos más grandes

Nueve, resumen

Se completan seis algoritmos de clasificación (clasificación de inserción simple, clasificación de colinas, clasificación de burbujas, clasificación rápida, clasificación de selección simple, clasificación de pila).

¡Codifique todos los días, progrese todos los días! ! !

Supongo que te gusta

Origin blog.csdn.net/qq_36963950/article/details/108953996
Recomendado
Clasificación
Diario
Más
2024-05-14(10)
2024-05-13(7)
2024-05-12(22)
2024-05-11(31)
2024-05-10(32)
2024-05-09(31)
2024-05-08(18)
2024-05-07(35)
2024-05-06(4)
2024-05-05(0)

Code World

© 2018 codetd.com