算法

算法

1. 给定两个字符串形式的非负整数 num1 和 num2 ，计算它们的和并同样以字符串形式返回。
   你不能使用任何內建的用于处理大整数的库（比如 BigInteger）， 也不能直接将输入的字符串转换为整数形式。

function bigNumberAdd(num1, num2) {
    let i = num1.length - 1
    let j = num2.length - 1
    let carry = 0
    let result = ''
    
    while(i >= 0 && j>=0) {
        let addNumber = parseInt(num1[i]) + parseInt(num2[j])
        let count = addNumber%10 + carry
        addNumber >= 10 ? carry = 1 : carry = 0
        result= count + result
        i --
        j --
    }
    
    if(i >= 0) {
        result = (parseInt(num1[i]) + carry).toString() +  result
        if(i - 1 >= 0) {
            result = num1.substring(0, i) + result
        }
    }
    if(j >= 0) {
        result = (parseInt(num2[j]) + carry).toString() +  result
        if(j - 1 >= 0) {
            result = num2.substring(0, j) + result
        }
    }
    
    return result
}

2.无重复字符的最长子串的长度

function maxSubstringLength(str) {
    let maxLength = 0
    let start = 0
    let map = new Map()
    
    for(let i = 0; i < str.length; i++ ) {
       let char = str[i]
       if(map.has(char) && map.get(char) >= start) {
           start = map.get(char) + 1
       }
       maxLength = Math.max(maxLength, i - start + 1)
       map.set(char, i)
    }
    
    return maxLength
}

3.给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。
请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。
注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。

function mergeArray(nums1, nums2){
    for(let i = 0; i < nums1.length; i++ ) {
       if(nums1[i] >= nums2[0]) {
           const value = nums2.shift()
           nums1.splice(i, 0, value)
           i--
       }
    }
    if(nums2.length > 0) {
        nums1 = nums1.concat(nums2)
    }
    return nums1
}

4.冒泡排序

function Bubble(num){
   for(var i = 0; i < num.length; i++ ) {
       for(var j = 0; j <  num.length - 1 - i ; j++) {
           if(num[j] > num[j+1]) {
               let temp = num[j+1]
               num[j+1] = num[j]
               num[j] = temp
           }
       }
   }
   return num
}

5.快速排序

function Quick(num){
   if(num.length <= 1)  return num
   
   let val = num[num.length - 1]
   let leftArr = []
   let rightArr = []
   
   for(let i = 0; i < num.length - 1; i++) {
       if(num[i] <= val) leftArr.push(num[i])
       if(num[i] > val) rightArr.push(num[i])
   }
   
   return [...Quick(leftArr), val, ...Quick(rightArr)]
}

6.手写一个 new 操作符

7.将虚拟dom转化为真实dom

const VNode = {
  tag: 'DIV',
  attrs:{
      id:'app'
  },
  children: [
    {
      tag: 'SPAN',
      children: [
        { tag: 'A', children: [] }
      ]
    },
    {
      tag: 'SPAN',
      children: [
        { tag: 'A', children: [] },
        { tag: 'A', children: [] }
      ]
    }
  ]
}

function createRealDom(Vnode){
  let dom
  if(typeof Vnode === 'string') {
        dom = document.createTextNode(Vnode)
        retun dom
  }
  
  if(Object.prototype.toString.call(Vnode) === '[object Object]') {
       dom = document.createElement(Vnode.tag)
       if(Object.keys(Vnode.attrs).length > 0) {
           Object.keys(Vnode.attrs).forEach((key) => {
               dom.setAttrbutes(key,Vnode.attrs[key] )
           })
       }
  }
  
  if(VNode.children && VNode.children.length > 0) {
      VNode.children.forEach(node => {
      dom.appChild(createRealDom(node))
      })
  }
  
  return dom
}