Code complet de tri à bulles (C++)

algorithme d'apprentissage

Je suis un chien de recherche en mécanique et je m'intéresse aux algorithmes. Ceci est un enregistrement de mon algorithme autodidacte.
Jour 1 : Tri à bulles

1. Le principe du tri à bulles ?

1. Comparez séquentiellement les éléments adjacents de l'arrière vers l'avant. Si vous souhaitez trier par ordre croissant, alors ces derniers éléments sont plus petits que les précédents, et les deux éléments sont échangés ; l'ordre décroissant est l'inverse.

2. Faites de même pour chaque paire d'éléments adjacents, de la première paire à la dernière paire. Après un tour de comparaison et d'échange, le dernier élément sera le nombre le plus petit (ou le plus grand), et ce nombre n'a pas besoin de participer aux opérations de comparaison ultérieures.

3. Répétez les étapes ci-dessus pour tous les éléments.

4. Continuez à répéter les étapes ci-dessus pour de moins en moins d'éléments à chaque fois, jusqu'à ce qu'il n'y ait plus de paire de nombres à comparer.
L'exemple est le suivant

2. Code de base

Le code a été testé et est stable et efficace

//函数写在Algorithm这个类里面了，并且是用模板方式编写
//这是为了函数能适应各种类型的数据
template<class T1>
vector<T1> Algorithm::bubblesort(vector<T1> array)
{
    
    
    int len = array.size();
    for(int i=0;i<len-1;i++)//n-1次冒泡
    {
    
    
        for(int j = 0;j<len-1-i;j++)//每一次冒泡需要两两比较len—1-i次
        {
    
    
            //交换两数操作
            int tem =  array[j+1];
            if(array[j] < array[j+1])//从小到大就大于号，从大到小就小于号
            {
    
    
                array[j+1] = array[j];
                array[j] = tem;
            }

        }
    }
    return  array;

}

3. Analyse de la complexité des algorithmes

Le tri à bulles a une complexité de O(n2) à cause de deux boucles imbriquées. Cette complexité est insupportable pour le temps qu'il faut pour trier une grande quantité de données, donc elle est peu utilisée.La prochaine section apprendra l'algorithme de tri le plus couramment utilisé : le tri rapide, dont la complexité moyenne de l'algorithme est O(nlogn)