ein c-Programm zum hinzufügen von zwei einfach verketteten Listen, der ungleiche Längen, mit Einzel-digited zahlen in all Ihren Knoten

1. Lesen Sie jede Stelle als Ihre ASCII-äquivalente in ein char-array, indiziert von 0, für beide Listen.
2. Verwenden Sie die atoi() - Funktion auf beiden char-arrays ( Sie können mit atol() oder atoll() wenn Sie sind besorgt über die Länge)
3. Fügen Sie beide zahlen
4. Verwenden Sie die itoa() Funktion zum umwandeln in ein char-array & dann wieder in die neue Liste.

Obwohl, ich gebe zu, die itoa() Funktion ist nicht standard.

Die Lösung könnte sein, viel einfacher, wenn die Liste gespeichert werden die zahlen in umgekehrter Reihenfolge.

Dennoch mit der gegebenen Einschränkung, hier ist ein Ansatz.

1. finden Sie die nthToLast Ziffer der beiden Listen, beginnend mit n = 0,
2. erstellen Sie eine node mit der Summe der Ziffern,
3. aktualisieren (ausführen) carry,
4. insert den neu erstellten Knoten an die head of die result Liste

Folgenden ist der (ungeprüfte) C-code.

typedef struct DigitNode_ {
    int digit;
    struct DigitNode_ * next;
} DigitNode;

/*  Returns the n-th element from the end of the SLL;
    if no such element exists, then return NULL.
    See: https://stackoverflow.com/questions/2598348/
*/
extern DigitNode * nthNodeFromTail( DigitNode * listHead, size_t n );

/*  Push pNode in the front, i.e. as the new head of the list */
extern void pushFront( DigitNode ** pListHead, DigitNode * pNode );

/*  Create new list as sum of a and b, and return the head of the new list.
        a -> 4 -> 7 -> 9 -> 6 -> NULL
        b ->           5 -> 7 -> NULL
    results in
        c -> 4 -> 8 -> 5 -> 3 -> NULL
*/
DigitNode * sumDigitLists( DigitNode * a, DigitNode * b ) {

    DigitNode * c = 0;
    int carry = 0;

    /* i is the position of a node from the tail of the list, backwards */
    for( size_t i = 0; /* see 'break' inside */; i++ ) {

        const DigitNode * const ithNodeA = nthNodeFromTail( a, i );
        const DigitNode * const ithNodeB = nthNodeFromTail( b, i );

        /* Stop when processing of both lists are finished */
        if( !ithNodeA && !ithNodeB ) {
            break;
        }

        const int ithDigitA = ithNodeA ? ithNodeA->digit : 0;
        const int ithDigitB = ithNodeB ? ithNodeB->digit : 0;

        assert( (0 <= ithDigitA) && (ithDigitA <= 9) );
        assert( (0 <= ithDigitB) && (ithDigitB <= 9) );

        const int conceptualIthDigitC = carry + ithDigitA + ithDigitB;
        const int ithDigitC = conceptualIthDigitC % 10;
        carry = conceptualIthDigitC / 10;

        DigitNode ithNodeC = { ithDigitC, NULL };
        pushFront( &c, &ithNodeC ); 
    }

    return c;
}

Ist dies einleuchtend. Vorausgesetzt, die Knoten ganz Links ist der bedeutendste bit. Richten Sie die beiden Listen, hinzufügen und propagieren tragen. Nach der Rückkehr erstellen Sie einen neuen Knoten, wenn nötig.

#include <stdio.h>


struct list {
 int val;
 struct list * next;
};


    int listadd (struct list  *l1, struct list *l2) {

        if ((l1 == NULL) || (l2 == NULL))
                return;
        int carry = 0;

        if ((l1->next == NULL) && (l2->next != NULL)) {
                carry += listadd (l1, l2->next) + l2->val;
                return carry;
        }

        else if ((l1->next != NULL) && (l2->next == NULL)) {
                carry +=listadd (l1->next, l2);
                l1->val = l1->val + carry;
        }
        else if ((l1->next != NULL) && (l2->next != NULL)) {
                carry += listadd (l1->next, l2->next);
        }
        else if ((l1->next == NULL) && (l2->next == NULL)) {
                l1->val = l1->val + l2->val;
                carry = l1->val/10;
                l1->val = l1->val%10;
                return carry;
        }

        carry = l1->val/10;
        l1->val = l1->val%10;
        return carry;
}

struct list * createnode (int val) {
  struct list * temp = (struct list *) malloc (sizeof(struct list));
  temp->val = val;
  temp->next = NULL;
  return temp;
}

int main() {
   int carry = 0;
   struct list *l1 = createnode(1);
l1->next = createnode(2);

   struct list *l2 = createnode(7);
   l2->next = createnode(8);

  carry = listadd(l1,l2);

  if (carry != 0) {
        struct list * temp = createnode(carry);
        temp->next = l1;
        l1 = temp;
  }


   while (l1!= NULL) {
        printf ("%d", l1->val);
        l1=l1->next;
   }
}