2021-03-17 算法打卡

3.两数相加

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。请你将两个数相加，并以相同形式返回一个表示和的链表。你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/add-two-numbers
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        int i = 1, j =1;
        ListNode* End1 = l1;
        ListNode* End2 = l2;
        while(End1->next != nullptr)
        {
            ++i;
            End1 = End1->next;
        }
        while(End2->next != nullptr)
        {
            ++j;
            End2 = End2->next;
        }
        int k = (i>=j)?i:j;
        ListNode* l3 = new ListNode();
        ListNode* Begin = l3;
        for(int m = 0; m < k-1; ++m)
        {
            ListNode* New = new ListNode();
            New->next = Begin->next;
            Begin->next = New;
            Begin = New;
        }
        Begin = l3;
        End1 = l1;
        End2 = l2;
        for(int m = 0; m < k; ++m)
        {
            if(i >= j)//l1更长
            {
                if(End2 != nullptr)
                {
                    Begin->val += (End1->val + End2->val);
                    if(Begin->val >= 10)
                    {
                      Begin->val %= 10;
                      if(Begin->next != nullptr)
                      {
                        Begin->next->val = 1;
                      }
                      else
                      {
                        Begin->next = new ListNode(1);
                      }
                    }
                }
                else
                {
                    if(Begin != nullptr && End1 != nullptr)
                    Begin->val += End1->val;
                    if(Begin->val >= 10)
                    {
                      Begin->val %= 10;
                      if(Begin->next != nullptr)
                      {
                        Begin->next->val = 1;
                      }
                      else
                      {
                        Begin->next = new ListNode(1);
                      }

                    }
                }
                

                Begin = Begin->next;
                if(End1 != nullptr)
                End1 = End1->next;
                if(End2 != nullptr)
                End2 = End2->next;
            }
            else//l2更长
            {
                if(End1 != nullptr)
                {
                    Begin->val += (End1->val + End2->val);
                    if(Begin->val >= 10)
                    {
                       Begin->val %= 10;
                       if(Begin->next != nullptr)
                       {
                          Begin->next->val = 1;
                       }
                        else
                        {
                          Begin->next = new ListNode(1);
                        }

                    }
                }
                else
                {
                    if(Begin != nullptr && End2 != nullptr)
                    Begin->val += End2->val;
                    if(Begin->val >= 10)
                    {
                       Begin->val %= 10;
                    
                       if(Begin->next != nullptr)
                       {
                          Begin->next->val = 1;
                       }
                       else
                       {
                          Begin->next = new ListNode(1);
                       }
                    }
                }
                

                Begin = Begin->next;
                if(End1 != nullptr)
                End1 = End1->next;
                if(End2 != nullptr)
                End2 = End2->next;
            }
            
        }
        
        
        return l3;
        
    }
};

小结：自己写的凑出来的，又臭又长！！！

参考别人的方法，使用中间变量保存每位相加的结果。最后处理进位。

下面贴改进：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        int i = 1, j =1;
        ListNode* End1 = l1;
        ListNode* End2 = l2;
        while(End1->next != nullptr)
        {
            ++i;
            End1 = End1->next;
        }
        while(End2->next != nullptr)
        {
            ++j;
            End2 = End2->next;
        }
        int k = (i>=j)?i:j;
        ListNode* l3 = new ListNode();
        ListNode* Begin = l3;
/*        for(int m = 0; m < k-1; ++m)
        {
            ListNode* New = new ListNode();
            New->next = Begin->next;
            Begin->next = New;
            Begin = New;
        }
 */       
        Begin = l3;
        End1 = l1;
        End2 = l2;
        

        for(int m = 0; m < k; ++m)
        {
            int sum = 0;
            if(End1 != nullptr)
            {
                sum += End1->val;
                End1 = End1->next;
            }
            if(End2 != nullptr)
            {
                sum += End2->val;
                End2 = End2->next;
            }
            if(Begin != nullptr)
            {
                sum += Begin->val;
                Begin->val = sum % 10;
                if(sum >= 10)
                {
                    Begin->next = new ListNode(1);
                }
                else
                {
                    if(m < k-1)       //最后一次运算，如果没有进位，不用再加结点了
                    Begin->next = new ListNode(0);
                }
                Begin = Begin->next;
            }

        }
        //if(Begin->val == 0)
        //delete Begin;     
        
        return l3;
        
    }
};

4.反转链表

反转一个单链表。

示例:

输入: 1->2->3->4->5->NULL
       输出: 5->4->3->2->1->NULL
进阶:
       你可以迭代或递归地反转链表。你能否用两种方法解决这道题？

 

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-linked-list
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head != nullptr)
        {
            ListNode* p = head;
            int i = 0;
            while(p != nullptr)
            {
              ++i;
              p = p->next;
            }
            int* num;
            num = new int[i];
            p = head;

            for(int j = 0; p != nullptr; ++j)
            {
              num[j] = p->val;
              p = p->next;
            }

            ListNode* New = new ListNode();
            ListNode* L = New;
            
            for( ; i >= 1; --i)
            {

              L->val = num[i-1];
              if(i != 1)
              {
                L->next = new ListNode();
                L = L->next;
              }

            }

            return New;
            delete []num;
        }
        else
        return head;

    }
};

小结：

写的不大好！