每日刷题 Day07

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

示例 1：
输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.

示例 2：
输入：l1 = [0], l2 = [0]
输出：[0]

示例 3：
输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]

提示：
每个链表中的节点数在范围 [1, 100] 内
0 <= Node.val <= 9
题目数据保证列表表示的数字不含前导零
通过次数1,133,407提交次数2,750,057

来源：力扣（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) {
        //因为链表长度太长，所以不考虑将链表转换为整数，再相加
        ListNode *head=nullptr;	//始终指向单链表表头
        ListNode *tail=nullptr;  //始终指向单链表表尾
        int temp=0;
        int index=0;    //表示两结点数值相加是否存在进位，若有进位index=1
        while(l1!=NULL||l2!=NULL){
            int temp1=l1?l1->val:0;  //若结点l1不为空,temp1=l1->val;若为空,则temp1=0;
            int temp2=l2?l2->val:0;  //与temp1同理
            temp=temp1+temp2+index;
            if(!head){
                head=tail=new ListNode(temp%10);
            }
            else{
                tail->next=new ListNode(temp%10);
                tail=tail->next;
            }
            index=temp/10;
            if(l1){
                l1=l1->next;
            }
            if(l2){
                l2=l2->next;
            }
        }
        if(index!=0){           //判断最后是否有进位
            tail->next=new ListNode(index);
        }
        return head;
    }
};

题二：二叉树的中序遍历
给定一个二叉树的根节点 root ，返回它的 中序 遍历。

示例 1：
输入：root = [1,null,2,3]
输出：[1,3,2]

示例 2：
输入：root = []
输出：[]

示例 3：
输入：root = [1]
输出：[1]

示例 4：
输入：root = [1,2]
输出：[2,1]

示例 5：
输入：root = [1,null,2]
输出：[1,2]

提示：
树中节点数目在范围 [0, 100] 内
-100 <= Node.val <= 100

进阶: 递归算法很简单，你可以通过迭代算法完成吗？

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/binary-tree-inorder-traversal

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
		//中序遍历采用递归的思路
    void Traversal(TreeNode* root,vector<int> &nums){
        if(root==nullptr)
            return;
        Traversal(root->left,nums);
        nums.push_back(root->val);   //将中序遍历的值添加进数组nums中
        Traversal(root->right,nums);
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> nums;
        Traversal(root,nums);
        return nums;
    }
};

题三：加一
给定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加一。
最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。
你可以假设除了整数 0 之外，这个整数不会以零开头。

示例 1：
输入：digits = [1,2,3]
输出：[1,2,4]
解释：输入数组表示数字 123。

示例 2：
输入：digits = [4,3,2,1]
输出：[4,3,2,2]
解释：输入数组表示数字 4321。

示例 3：
输入：digits = [0]
输出：[1]

提示：
1 <= digits.length <= 100
0 <= digits[i] <= 9

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/plus-one

class Solution {
public:
    vector<int> plusOne(vector<int>& digits) {
        int len = digits.size();  //数组长度
        int sum = digits[len-1]+1;
        digits[len-1]=sum%10;
        int index=sum/10;  //表示加一之后是否有进位
        int j=len-2;
        if(index!=0){
            while(j>=0){
                sum=digits[j]+index;
                digits[j]=sum%10;
                index=sum/10;
                j--;
            }
        }
        if(index!=0){
            digits.insert(digits.begin(),index);  
            //在digits头部添加元素；
            //digits.push_front(index);
        }
        return digits;
    }
};