Complexité du temps BFS

BFS signifie une recherche d'absure d'abord. La recherche de respiration est un algorithme pour rechercher un nœud particulier dans un arbre. Un nœud ou un sommet signifie la même chose pour un arbre. Le but de cet article est d'expliquer l'algorithme BFS, de donner une brève note sur la complexité du temps et d'apprendre comment la complexité du temps est applicable à l'algorithme BFS. C ++ est utilisé pour le codage.

Contenu de l'article

• • Introduction - Voir ci-dessus
  • Recherche d'abord
  • Brève note sur la complexité du temps
  • Recherche d'un sommet par la recherche d'abord-première
  • Conclusion

Recherche d'abord

L'arbre
Un diagramme d'arbre pour illustrer la recherche d'abord en forme est le suivant:

Pour rechercher un nœud, l'algorithme commence par le nœud racine 1 puis au nœud 2, nœud 3, etc. Niveau par niveau, de haut en bas, de gauche à droite, jusqu'à ce qu'il rencontre le nœud qu'il recherche.

Stockage de l'arbre
Un arbre est comme un graphique simple. Dans cet article, l'arbre est stocké à l'aide d'une liste d'adjacence. Une liste d'adjacence indique un nœud (sommet) et tous ses nœuds adjacents (sommets), comme suit, dans le diagramme précédent:

1 adjacent à 2, 3, 4
2 adjacent au 1, 5, 6
3 adjacent à 1
4 adjacent au 1, 7, 8
5 adjacent au 2, 9, 10
6 adjacent à 2
7 adjacent au 4, 11, 12
8 adjacent à 4
9 adjacent à 5
10 adjacent à 5
11 adjacent à 7
12 Adjacent à 7

Un bord
Un bord est la ligne rejoignant un sommet et un sommet adjacent. Il peut également être considéré comme une paire, composée d'un sommet (nœud) et d'un sommet adjacent (nœud adjacent). Ainsi, l'arbre précédent a les bords suivants pour les sommets correspondants:

3 bords: 1 adjacent à 2, 3, 4
3 bords: 2 adjacents au 1, 5, 6
1 bord: 3 adjacent à 1
3 bords: 4 adjacents au 1, 7, 8
3 bords: 5 adjacents à 2, 9, 10
1 bord: 6 adjacent à 2
3 bords: 7 adjacents au 4, 11, 12
1 bord: 8 adjacent à 4
1 bord: 9 adjacent à 5
1 bord: 10 adjacent à 5
1 bord: 11 adjacent à 7

Structure C ++
Les informations précédentes peuvent être stockées dans un vecteur C ++ de vecteurs. Chaque ligne commence par un nœud, suivi de ses nœuds adjacents. Le vecteur de vecteur C ++, pour l'arbre précédent, est le suivant:

vecteur vtr = 1, 2, 3, 4,
2, 1, 5, 6,
3, 1,
4, 1, 7, 8,
5, 2, 9, 10,
6, 2,
7, 4, 11, 12,
8, 4,
9, 5,
10, 5,
11, 7,
12, 7;

Brève note sur la complexité du temps

Considérez le code suivant:

int n = 10;
pour (int i = 0; icouter << i << ", ";

La sortie est:

0, 1, 2, 3, 4, 5, 6, 7, 8, 9,

En supposant que l'instruction COUT est une opération simple, la complexité temporelle (vitesse) pour cette boucle est censée être O (n), où n dans ce cas est 10. Le Big O suivi des supports avec n est la notation de la complexité du temps (vitesse). Considérez le code suivant:

int n = 10;
pour (int i = 0; i<7; i++)
couter << i << ", ";

La sortie est:

0, 1, 2, 3, 4, 5, 6,

Bien que n soit 10, jusqu'à 10 éléments sont imprimés (7 éléments ont été imprimés). La complexité du temps est toujours censée être O (n). C'est le nombre maximal possible d'opérations qui est pris en considération.

Considérez le code suivant:

int n = 10;
int m = 10;
pour (int i = 0; icouter << i << ", ";

couter << endl;
pour (int i = 0; icouter << i << ", ";

couter << endl;

La sortie est:

0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
0, 1, 2, 3, 4, 5, 6, 7, 8, 9,

Il y a deux boucles pour 10 variables chacune, pour n et m. La complexité du temps (vitesse) ici est: O (n + m). Même si la sortie est:

0, 1, 2, 3, 4, 5, 6
0, 1, 2, 3, 4, 5, 6

La complexité du temps est toujours donnée comme o (n + m). C'est le nombre maximal possible d'opérations qui est pris en considération. Aussi, si la sortie est:

0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
0, 1, 2, 3, 4, 5, 6, 7, 8, 9,

Par convention, la complexité temporelle est toujours donnée comme o (n + m).

Recherche d'un sommet par la recherche d'abord-première

Wikipédia.org donne l'algorithme comme suit:

• Utilisez une file d'attente (premier dans First Out).
• Vérifiez si un sommet a été exploré avant d'obtenir le sommet.

Il continue en disant que la complexité du temps est:

O (| v | + | e |)

Où | V | est le nombre de sommets (nœuds) et | e | est le nombre d'arêtes.

Si la structure de l'arbre est donnée comme vecteur de vecteurs, comme dans le cas précédent, il ne sera pas nécessaire d'utiliser une file d'attente. Il suffit de scanner le vecteur de vecteurs, de haut en bas, jusqu'à ce que le sommet recherché soit vu. Cette procédure donne toujours la même complexité de temps d'O (| V | + | E |).

Supposons que pour l'arbre précédent, le sommet 9 doit être recherché. À partir de la table des bords / nœuds rediffurée dans ce qui suit, pour un accès facile, le nombre de bords est de 19 et le nombre de nœuds est de 9:

3 bords: 1 adjacent à 2, 3, 4
3 bords: 2 adjacents au 1, 5, 6
1 bord: 3 adjacent à 1
3 bords: 4 adjacents au 1, 7, 8
3 bords: 5 adjacents à 2, 9, 10
1 bord: 6 adjacent à 2
3 bords: 7 adjacents au 4, 11, 12
1 bord: 8 adjacent à 4
1 bord: 9 adjacent à 5
1 bord: 10 adjacent à 5
1 bord: 11 adjacent à 7

Les opérations sont 9 + 19 = 28. Dans ce tableau, les bords sont cités à gauche et les sommets sont cités à droite. Encore une fois, c'est la somme maximale possible qui est considérée, c'est-à-dire: 11 + 21 = 32. Cela signifie qu'il y a onze sommets plus 21 bords, qui est o (11 + 21), écrit en termes généraux comme o (| v | + | e |).

Le code C ++ pour rechercher le sommet 9 est:

int counter = 0;
pour (non signé i = 0; ipour (non signé j = 0; jcompteur = compteur + 1;

if (vtr [i] [0] == 9)
casser;

couter << counter << endl;

La sortie est de 28, avec un maximum de 32.

Conclusion

La complexité du temps BFS est:

O (| v | + | e |)

Où | V | est le nombre de sommets (nœuds) et | e | est le nombre d'arêtes.