// Ici c est une constante   
   pour (int je = 1; je <= c; je++) {  
        // quelques expressions O(1)
   }

2) O(n) : la complexité temporelle d'une boucle est considérée comme O(n) si les variables de la boucle sont incrémentées/décrémentées 
d'une quantité constante. Par exemple, les fonctions suivantes ont une complexité temporelle O(n).

 // Ici c est une constante entière positive   
   pour (int je = 1; je <= n; je += c) {  
        // quelques expressions O(1)
   }

   pour (int je = n; je > 0; je -= c) {
        // quelques expressions O(1)
   }

3) O(n c ) : la complexité temporelle des boucles imbriquées est égale 
au nombre de fois que l'instruction la plus interne est exécutée. 
Par exemple, les exemples de boucles suivants ont une complexité temporelle  O(n 2 )

 pour (int je = 1; je <=n; je += c) {
       pour (int j = 1; j <=n; j += c) {
          // quelques expressions O(1)
       }
   }

   pour (int je = n; je > 0; je -= c) {
       pour (int j = i+1; j <=n; j += c) {
          // quelques expressions O(1)
   }

Par exemple, le tri par sélection et le tri par insertion ont une complexité temporelle  O(n 2 ).
4) O(Logn) Temps La complexité d'une boucle est considérée comme O(Logn) si les variables de la 
boucle sont divisées/multipliées par une quantité constante. Et aussi pour un appel récursif dans une fonction 
récursive, la complexité temporelle est considérée comme O (Logn).

pour (int je = 1; je <=n; je *= c) {

       // quelques expressions O(1)
   }
   pour (int je = n; je > 0; je /= c) {
       // quelques expressions O(1)
   }

//Fonction récursive
annuler la récursivité(n)
{
    si(n==0)
        revenir;
    autre{
        // quelques expressions O(1)
    }
    recurse(n-1);
}


Par exemple, la recherche d'un élément binaire iterative

// Ici c est une constante supérieure à 1   
   pour (int je = 2; je <=n; je = pow(je, c)) {
       // quelques expressions O(1)
   }
   // Ici, le plaisir est sqrt ou cuberoot ou toute autre racine constante
   pour (int je = n; je > 1; je = fun(i)) {
       // quelques expressions O(1)
   }

Comment combiner les complexités temporelles de boucles consécutives ?  
Lorsqu'il y a des boucles consécutives, nous calculons la complexité temporelle comme une somme des complexités temporelles des boucles individuelles. 

pour (int je = 1; je <=m; je += c) {  
        // quelques expressions O(1)
   }
   pour (int je = 1; je <=n; je += c) {
        // quelques expressions O(1)
   }
   La complexité temporelle du code ci-dessus est O(m) + O(n) qui est O(m+n)
   Si m == n, la complexité temporelle devient O(2n) qui est O(n).   

a une complexité temporelle O (Logn). Voyons mathématiquement comment il est O(Log n). La série que nous obtenons dans la première boucle est 1, c, c 2 , c 3 , … c k . Si on pose k égal à Log c n, on obtient c Log c n qui vaut n. 
5) O(LogLogn) La complexité temporelle d'une boucle est considérée comme O(LogLogn) si les variables de boucle sont réduites/augmentées de manière exponentielle d'une quantité constante.