算法设计思想

分而治之

概念

分而治之是算法设计中的一种思想

它将一个问题分成多个和原问题相似的小问题，递归解决小问题，再将结果合并以解决原来的问题

猜数游戏

var guessNumber = function(n) {
    const rec=(low,high)=>{
        if(low>high){return}
        let mid=Math.floor((low+high)/2);
        let res=guess(mid);
        if(res===0){return mid}
        else if(res===1){return rec(mid+1,high)}
        else{return rec(low,mid-1)}
    }
    return rec(1,n)
};

翻转二叉树

var invertTree = function(root) {
    if(!root){return null}
    return{
        val:root.val,
        left:invertTree(root.right),
        right:invertTree(root.left)
    }

};

判断相同的树

var isSameTree = function(p, q) {
    if(!p&&!q){return true}
    if(!p||!q){return false}
    if(p.val!==q.val){return false}
    return isSameTree(p.left,q.left)&&isSameTree(p.right,q.right)

};

判断是否为镜像二叉树

var isSymmetric = function(root) {
    if(!root) return true;
    const compareTree=(l,r)=>{
      if(!l&&!r){return true}
      if(!l||!r){return false}
      if(l.val!=r.val){return false}
      return compareTree(l.left,r.right)&&compareTree(l.right,r.left)
}
  return compareTree(root.left,root.right)
};

动态规划

概念

动态规划是算法设计中的一种方法

它将一个问题分解为相互重叠的子问题，通过反复求解子问题来解决原来的问题

爬楼梯

var climbStairs = function(n) {
    if(n===1) {return 1}
    let arr=[1,1];
    for(let i=2;i<=n;i++){
        arr[i]=arr[i-1]+arr[i-2]
    }
    return arr[n]
};

打家劫舍

var rob = function(nums) {
    if(nums.length===0){return 0}
    let dp=[0,nums[0]];
    for(let i=2;i<=nums.length;i++){
        dp[i]=Math.max(dp[i-2]+nums[i-1],dp[i-1])
    }
    return dp[nums.length]
};

贪心算法

概念

贪心算法是算法设计中的一种方法

期盼通过每个阶段的局部最优选择，从而达到全局的最优

分饼干

var findContentChildren = function(g, s) {
const  sort= function(a,b){
    return a-b
};
g.sort(sort);
s.sort(sort);
let i=0;
s.forEach(n=>{
 if(n>=g[i]){i++;}
 });
return i
};

股票最大利润

var maxProfit = function(prices) {
    let profit=0;
    for(let i=1;iprices[i-1]){
            profit+=prices[i]-prices[i-1]
        }
    }
    return profit
};

回溯算法

概念

回溯算法是算法设计中的一种方法

回溯算法是一种渐进式寻找并构建问题解决方式的策略

回溯算法会先从一个可能的动作开始解决问题，如果不行，就回溯并选择另一个动作，直到将问题解决

全排列

var permute = function(nums) {
const res=[];
const backtrack=(path)=>{
  if(path.length===nums.length){
      res.push(path);
      return
  }
  nums.forEach(n=>{
    if(path.includes(n)){return}
    backtrack(path.concat(n));
  });
    }
backtrack([]);
return res
};

求子集

var subsets = function(nums) {
    const res=[];
    const backtrack=(path,l,start)=>{
      if(path.length===l){
          res.push(path);
          return
      }
      for(let i=start;i

学习总结

数据结构：栈，队列，链表，集合，字典，树，图，堆

算法：链表，树，图的遍历，数组的排序和搜索

算法设计思想：分而治之，动态规划，贪心和回溯