大数加法 && 重排链表 && 二叉树根节点到叶子节点的所有路径和 -js

01 - 大数加法

描述
以字符串的形式读入两个数字，编写一个函数计算它们的和，以字符串形式返回。

示例1
输入："1","99"
返回值："100"
说明：1+99=100 

思路：将两个字符串反转，补位。得到相同长度的字符串后，进行加和即可
1.找出最长的字符串，用最长的字符串的长度减去最短的字符串的长度得到最短的字符串需要补位的个数。
2.遍历两个字符串进行加和操作即可

代码实现：

function solve( s ,  t ) {
    // write code here
    // 将字符串切割成数组后反转
    let sNum = s.split('').reverse()
    let tNum = t.split('').reverse()
    // 最大值减最小值得到补位数量
    let count = Math.max(s.length,t.length) - Math.min(s.length,t.length)
    // 判断两个字符串中哪个是长度最短的进行补位
    if(s.length > t.length){
        while(count){
            tNum.push('0')
            count --
        }
    }else{
        while(count){
            sNum.push('0')
            count --
        }
    }
    // 需要返回的结果
    let result = ''
    // 表示进位
    let carry = 0
    for(let i = 0; i < sNum.length; i ++){
        let temp = parseInt(sNum[i]) + parseInt(tNum[i]) + carry
        if(temp >= 10){
        	// 结果向前拼串 不然到后面还得将结果字符串切割反转
            result = (temp - 10) + result
            carry = 1
        }else{
            result = temp + result
            carry = 0
        }
    }
    // 这里的判断是 因为999 + 1 会得到000的情况 所以在前面加1
    if(carry === 1) {
        result = 1 + result
    }
    // 最后将结果return就行
    return result
}

02 - 重排链表

题目在这里

输入：
{1,2,3,4}
返回值：{1,4,2,3}
说明：给定head链表1->2->3->4, 重新排列为 1->4->2->3,会取head链表里面的值打印输出 1  

思路：
1.设置快慢指针，将链表从中间位置切分成两个链表fast和slow；（切分链表的时候尽量向后多切割一位，如果完全等分的话后面会出现slow链表的最后一个元素需要插在fast链表的最后一位。这个位置的元素本来在没有切割之前就在那个位置，切割反转之后再把它放回原来的位置，多此一举。）
2.反转slow链表
3.将反转后的slow链表插进fast链表中

代码实现：

function reorderList( head ) {
    // write code here
    if(head == null || head.next == null) return head
    let slow = head
    let fast = head
    // 这个指针是最后将慢指针最后指向位置后面的切掉
    let slowLast = head
    while(slow && fast && fast.next){
        slow = slow.next
        fast = fast.next.next
    }
    // 这里向后多切割一位
    slowLast = slow
    slow = slow.next
    slowLast.next = null
    fast = head
    // 反转链表
    slow = reverseList(slow)
    // 这里需要第三个指针 用来保存slow的头部
    let slowPrev = slow
    // 将反转后的slow链表插入到fast链表中
    while(slow){
        slowPrev = slow.next
        slow.next = fast.next
        fast.next = slow
        slow = slowPrev
        fast = fast.next.next
    }
    // 反转函数
    function reverseList(list){
        let node = list
        let prev = list
        while(node){
            prev = node
            node = node.next
            if(prev == list){
                prev.next = null
            }else{
                prev.next = list
            }
            list = prev
        }
        return list
    }
}

03 - 二叉树根节点到叶子节点的所有路径和

描述
给定一个二叉树的根节点root，该树的节点值都在数字\ 0-9 0−9 之间，每一条从根节点到叶子节点的路径都可以用一个数字表示。
1.该题路径定义为从树的根结点开始往下一直到叶子结点所经过的结点
2.叶子节点是指没有子节点的节点
3.路径只能从父节点到子节点，不能从子节点到父节点
4.总节点数目为n

示例1
输入：{1,2,3}
返回值：25

思路：
1.递归得到每条路径的节点字符串，保存到一个数组中；
2.遍历数组将全部元素转成Number类型加和即可

代码实现：

function sumNumbers( root ) {
    // write code here
    let pathArr = []
    let path = ''
    function pathRecursive(root ,path){
        if(root == null){
            return 0
        }
        path += root.val
        // 这里到达叶子节点时 直接返回本次递归 如果这里不做限制的话会出现路径字符串重复的情况
        if(root.left == null && root.right == null){
            pathArr.push(path)
            return 
        }
        pathRecursive(root.left,path)
        pathRecursive(root.right,path)
    }
    pathRecursive(root,path)
    let result = 0
    for(let i = 0; i < pathArr.length; i ++){
        result += parseInt(pathArr[i])
    }
    return result
    
}