Je suis actuellement coincé sur certaines fonctions opérant sur des listes associées à une structure en C ++.
Je suis censé savoir quelles sont ces fonctions sans compiler, mais je ne peux pas sembler avoir compris la théorie derrière elle complètement, car mes suppositions sont toutes trop génériques. P>
y a-t-il un moyen de Devinez la raison derrière l'existence de ces fonctions simplement en les regardant? Et que font-ils? P>
aussi, que se passera-t-il si j'appelle Q (LA, LB) si LA = (2, 3, 4, 5, 1, 6) et LB = (3, 4 , 5)? P>
bool u(List l, int x) { if (l=nullptr) return false; if (l->info == x) return true; return u(l->next, x); } void v(List& l, int x) { List tmp = new (cell); tmp->info = x; tmp -> next = l; l = tmp; } List q(List l1, List l2) { List aux = nullptr; while (l1!=nullptr) { if (!u(l2,l1->info)) v(aux,l1->info); l1=l1->next; } return aux; }
3 Réponses :
La fonction vérifie si la liste ajoute la valeur vérifie chaque valeur dans la liste Il y a des erreurs dans le code. La ligne p> ne se compare pas mais assigne. l code> contient la valeur
x code> dans le champ
info code>. La fonction p>
x code> à la liste
l code>. La fonction p>
l1 code> s'il s'agit également d'un élément de la liste
l2 code>. Si la valeur est élément de la liste
l2 code>, la valeur est ajoutée à la liste
AUX code>. La liste
AUX code> est renvoyée. P>
AUX code> est un pointeur sur le dernier élément de la liste et non à la tête. P> P>
Cela ne répond pas à la question qui n'était pas "quelles sont ces fonctions?", Mais "Comment reconnaître ce qu'ils font?"
Plus que cela, c'est une mauvaise question et de mauvaises questions ne doivent pas être récompensées par des réponses.
Commençons par la première fonction la touche consiste à comprendre le type probable de la liste ainsi, Ainsi, Vous pouvez utiliser cette même logique maintenant pour trouver la signification des autres fonctions. p> p> code>. De l'expérience avec des listes liées et du code, il semble que nous ayons quelque chose comme p>
u () code> prend une liste
l code> et une valeur
x code>. Si la liste dirigée par
l code> est vide (
l == nullptr code>), il renvoie
false code>. Sinon, le nœud info est égal à
x code> il renvoie
vrai code>. Sinon, il s'appelle de manière récursive avec
L code> remplacé par
l-> suivant code>. P>
u (l, x) code > retourne vrai si et seulement si au moins l'un des nœuds de la liste liée contient la valeur
x code> comme
info code>. Un nom plus approprié pour cette fonction aurait été
contient () code> avec l'implémentation plus simple p>
Vous pouvez prendre une conjecture raisonnable quant à ce que ces fonctions pouvaient faire à partir des déclarations.
List (List, List)
Bien sûr, il y a une manière non seulement "de deviner la raison de la présente activité de la fonction juste en les regardant", mais de le déterminer de manière concluante. Cela se fait en lisant chaque code de la fonction, en l'analysant et en déterminant quelle est la fonction. Par exemple, si la seule chose que la fonction contient est
a = b; code> Vous pouvez conclure fièrement que l'objectif de la fonction est d'attribuer
B code> à
A code >. De même, en examinant le code de chaque fonction, on peut facilement déterminer ce qu'il fait. Toutes ces fonctions sont des opérations de liste liées de base et ne sont pas très compliquées.
u code> va toujours planter comme il définit
l code> sur
nullptr code> et invitionnellement latérérences il.
Vous pouvez essayer de dessiner les listes sur le papier à gratter ou un tableau blanc, puis tracez le code. Notez que
u code> utilise la récursion pour traverser la liste.
q code> Utilise une itération à la place, et il utilise les deux
u code> et
v code>. Une fois que vous comprenez ce que ces fonctions font, compréhension
q code> devrait être assez simple.
@Botje: Très bien. Je pense que cela est clairement destiné à être
== code> au lieu de
= code>.