Leetcode0002——Add Two Numbers——Linked List

This is a topic about one-way linked list , What we are looking at is the construction and traversal of one-way linked lists . The title is as follows ：

The traversal of a single linked list takes ordinary addition as the carrier , The meaning of the question is easy to understand .
I wrote two versions of code , One is Opened a new linked list To store the results , One is Add it to the long list in place . It is not difficult to see from the train of thought , The former saves more time （ Because there is no need to judge the length of the linked list , Add and open new nodes directly ）, The latter saves more space .

Here is the code of the second solution ：
1. First, we need to write a function to get the linked list L1 and L2 The length of , The code is as follows ：

// get the length of linked list
int getListLength(ListNode* List)
    {
    
        int Length = 0;
        ListNode* MeasurePtr = List;
        while(MeasurePtr != nullptr)
        {
    
            ++Length;
            MeasurePtr = MeasurePtr->next;
        }
        return Length;
    }

2. This part is AC Core code , Of course, the returned result is a long linked list that stores the final result Longer, The shorter list is used as an addend to add the element values in the longer list one by one . Another two pointers are opened , One day ago （Lead） After one （Follow） To traverse the long linked list . This is because if the previous pointer has pointed to the last linked list node, it will jump out of the loop , And then There's also rounding that hasn't been handled , At this time, we need to follow Follow Pointer to apply for a new linked list node To store the carry of the highest bit , This is the meaning of the following code ：

 // if there is a remained carry bit
 if(Carry)
 	Follow->next = new ListNode(Carry);

Here is the complete code

// in-place calculation
        ListNode* Longer = getListLength(l1) >= getListLength(l2) ? l1 : l2;
        ListNode* Shorter = Longer == l1 ? l2 : l1;
        ListNode* Lead = Longer;
        ListNode* Follow;

        // carry bit
        int Carry = 0;

        while(Lead != nullptr)
        {
    
            // add the shorter list's value
            if(Shorter != nullptr)
                Lead->val += Shorter->val;
            
            // add the carry bit
            Lead->val += Carry;

            // if the Result > 10
            if(Lead->val >= 10)
            {
    
                Lead->val %= 10;
                Carry = 1;
            }
            else
                Carry = 0;
            
            // modify pointers
            Follow = Lead;
            Lead = Lead->next;
            if(Shorter != nullptr)
                Shorter = Shorter->next;
        }

        // if there is a remained carry bit
        if(Carry)
            Follow->next = new ListNode(Carry);

        return Longer;