Match, Addieren und Multiplikation für Polynome mit verknüpften Liste

Question

So schreibe ich ein Programm, das aus Multiplikationsfunktion Implementierungen besteht, habe jedoch Probleme beim Schreiben von 3 Funktionen: übereinstimmen, hinzufügen und multiplizieren.

Die Match-Funktion soll anzeigen, ob 2 Polynome gleich sind. wenn das der Fall ist, ist es wahr, sonst falsch.

Add-Funktion jut fügt 2 Polynome hinzu.

Multiplikation produziert nur das Produkt von 2 Polynomen.

Ich bin fest, wie diese Funktionen beginnen. Jeder Rat oder jede Rückmeldung wird hilfreich sein. Ich danke dir sehr.

class Dlist 
{ 
private: 
Node* front; 
public: 
Dlist(Node* f = NULL){front = f;} 

void insertInOrder(int c, int x, int y) 
{ 
    Node* nn = new Node; 
    nn->coef = c; 
    nn->xdeg = x; 
    nn->ydeg = y; 
    int nsum = x + y; 

    Node* p = front; 


    if(front == NULL){ 
     front = nn; 
     return; 
    } 
    while(p != NULL){ 
     if(x == p->xdeg && y == p->ydeg){ 
      p->coef += c; 
      return; 
     } 
     p = p->next; 
    } 
    p = front; 
    if(nsum > p->xdeg + p->ydeg){ 
     nn->next = p; 
     front = nn; 
     return; 
    } 
    else{ 
     while(p->next != NULL && p->next->xdeg + p->next->ydeg > nsum){ 
      p = p->next; 
     } 
    } 
    nn->next = p->next; 
    p->next = nn; 
    return; 
}; 

void print() 
{ 
    Node* p = front; 
    while(p != NULL){ 
     cout << p->coef << "/" << p->xdeg << "/" << p->ydeg << " -> "; 
     p = p->next; 
    } 
    cout << "NULL" << endl; 
    return; 
}; 

int degree() 
{ 
    Node* p = front; 
    int maxd = 0; 

    while(p != NULL){ 
     if(maxd < p->xdeg + p->ydeg){ 
      maxd = p->xdeg + p->ydeg; 
     } 
     p = p->next; 
    } 

    return maxd; 
}; 

void coefficient(int input) 
{ 
    Node* p = front; 
    int index = 0; 
    while(p != NULL){ 
     p = p->next; 
     index++; 
    } 
    if(input < 0){ 
     cout << "Does not exist." << endl; 
     return; 
    } 
    else if(input > index){ 
     cout << "Does not exist." << endl; 
     return; 
    } 
    p = front; 
    for(int i = 0; i != input; i++){ 
     p = p->next; 
    } 
    cout << p->coef << endl; 
    return; 
} 
void sum() 
{ 


} 

};

Answer 1

Wenn wir über die psudocode für jeden Algorithmus vielleicht denken Sie so etwas wie

function match(poly1,poly2): 
    if(length(poly1) != length(poly2)) return false 
    foreach term1 in poly1: 
     boolean termmatched=false 
     foreach term2 in poly2: 
      if matchterms(term1,term2): 
       termmatched = true 
       break 
     endfor 
     if not termmatched: 
      return false 
    endfor 
    return true 
endfunction 

haben diese So prüft zuerst, suchen Sie haben die gleiche Anzahl von Begriff in jedem Polynom. Dann prüfe für jeden Term in dem ersten Polynom, ob es einen Term in dem zweiten Polynom gibt, der übereinstimmt. Wenn kein Term übereinstimmt, stimmen die Polynome nicht überein und wir können sofort zurückkehren.

Dies setzt voraus, dass Sie keinen Ausdruck im zweiten Polynom haben können, der zwei verschiedene Begriffe in der ersten entsprechen kann. Ein ausgefeilterer Ansatz könnte ein Flag für jeden Term auf dem zweiten Polynom setzen, um zu überprüfen, ob es bereits abgeglichen wurde.

Zum Hinzufügen möchten Sie alle Begriffe finden, die übereinstimmen und die Koeffizienten hinzufügen. Wenn es keine Übereinstimmung gibt, füge einfach diesen Begriff hinzu. Hier möchten Sie wahrscheinlich ein Flag verwenden, um zu erkennen, welche Terme im zweiten Polynom übereinstimmen. Alternativ könnten Sie übereinstimmende Terme aus dem zweiten Polynom entfernen.

function add(poly1,poly2): 
    boolean flags[length(poly2)] // array of flags all false 
    polynomial result = empty polynomial 
    foreach term1 in poly1: 
     boolean termmatched=false 
     int i=0 
     foreach term2 in poly2: 
      if matchterms(term1,term2): 
       result.add(new term(term1.coef+term2.coef,term1.xdeg,term1.ydeg)) 
       flags[i]=true // mark flag for second term as matched 
       termmatched = true 
       break 
      ++i 
     endfor 
     if not termmatched: 
      result.add(new term(term1.coef,term1.xdeg,term1.ydeg)) 
    endfor 

    i =0 
    foreach term2 in poly2: 
     if(not flags[i]) 
      result.add(new term(term1.coef,term1.xdeg,term1.ydeg)) 
    endfor 
endfunction 

Multiplikation kann komplizierter sein. Es hängt ein bisschen von Ihrer Polynomklasse ab. Eine gute Polynom-Klasse wird eine Add-Methode hat, das wird eine Schleife durch alle bestehenden Bedingungen für ein Spiel wird einfach

class polynomial 

methods add(coef,xord,yord): 
    foreach term: 
     if match(term,xord,yord): 
      term.coef += coef 
      return 
    endfor 
    // add a new term on the end of the linked list 
    insertInOrder(coef,xord,yord) 

mit dieser Methode Multiplikation

function multiply(poly1,poly2): 
    result = new polynomial 
    foreach term1 in poly1: 
     foreach term2 in poly2: 
      result.add(term1.coef*term2.coef, 
       term1.xord + term2.xord, 
       term1.yord + term2.yord) 
     endfor 
    endfor 
    return result 
endfunction 

Mit dieser intelligenten Add-Methode zu überprüfen, die das Hinzufügen von zwei Polynome werden jetzt trivial