题目

假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。
对每个孩子 i，都有一个胃口值 g[i]，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j，都有一个尺寸 s[j] 。如果 s[j] >= g[i]，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。

坑

这道题还是挺简单的，而且我的思路是对的也做出来了。
但为什么不通过呢？
因为sort的排序不是默认从小到大啊啊啊啊！

  1. g.sort((a,b)=> a-b); //要这么写

code

这道题有两个思路，

  • 大饼干喂给胃口大的，充分利用饼干尺寸喂饱一个，全局最优就是喂饱尽可能多的小孩。【从后向前遍历小孩数组】

  • 小饼干先喂饱小胃口【从前向后】

    1.小饼干喂小胃口

    注意：这里必须遍历饼干尺寸，去找合适的胃口
    不能遍历胃口 去吃饼干。

    1. var findContentChildren = function(g, s) {
    3.   g.sort((a,b)=> a-b);
    4.   s.sort((a,b)=> a-b); //排序[有坑]
    5.   console.log(g);
    6.   console.log(s);
    7.   let index =0; 
    8. //注意，这里的逻辑必须是先遍历尺寸。
    9.   for(let i=0;i<s.length;++i){ 
    10.       if(g[index]<=s[i] && index<g.length){
    11.           index++;
    12.       }
    14.   }
    15.   return index;
    16. }

    2. 大饼干喂大胃口

    1. var findContentChildren = function(g, s) {
    2.   g = g.sort((a, b) => a - b)
    3.   s = s.sort((a, b) => a - b)
    4.   let result = 0
    5.   let index = s.length - 1
    6.   for(let i = g.length - 1; i >= 0; i--) {
    7.       if(index >= 0 && s[index] >= g[i]) {
    8.           result++
    9.           index--
    10.       }
    11.   } 
    12.   return result
    13. };

    3. 我的垃圾双循环

    虽然但是我想的是双指针法
    ps：我也不垃圾啊，如果先遍历胃口，确实要双指针了。 ```javascript var findContentChildren = function(g, s) {

    g.sort((a,b)=> a-b); s.sort((a,b)=> a-b); //排序 let count =0; let index =0; // for(let i=0;i<g.length;i++){

    1.   let j =index;
    2.   for(;j<s.length;j++){
    3.       if(g[i]<=s[j] ){
    4.           count++;
    5.           index =j+1;
    6.           break; //找到后跳出循环
    7.       }
    8.   }

    } return count;

}; ```