C++

class Solution {
public:
    int findContentChildren(vector<int>& g, vector<int>& s) {
    sort(g.begin(),g.end());
    sort(s.begin(),s.end());
    int glength=g.size();
    int result=0;
    int count=0;
    int i=0;
    while(count<glength&&i<s.size())
    {
        for(;i<s.size();i++)
        {
            if(s[i]>=g[count]&&count<glength)
            {
                result++;
                count++;
            }
        }
    }
    return result;
    }
};

Java

public class Solution {
    public int findContentChildren(int[] g, int[] s) {
    Arrays.sort(g);
    Arrays.sort(s);
    int glength=g.length;
    int result=0;
    int count=0;
    int i=0;
    while(count<glength&&i<s.length)
    {
        for(;i<s.length;i++)
        {
            if(count<glength&&s[i]>=g[count])
            {
                result++;
                count++;
            }
        }
    }
    return result;
    }
}

Javascript

/**
 * @param {number[]} g
 * @param {number[]} s
 * @return {number}
 */
var findContentChildren = function(g, s) {
    g.sort(function(a,b){return a-b;});
    s.sort(function(a,b){return a-b;});
    var glength=g.length;
    var result=0;
    var count=0;
    var i=0;
    while(count<glength&&i<s.length)
    {
        for(;i<s.length;i++)
        {
            if(s[i]>=g[count])
            {
                result++;
                count++;
            }
        }
    }
    return result;
};

此处思路都是一样的，但是在各自语言下代码有些许差别，值得一提的是

C++中判断条件为 if(s[i]>=g[count]&&count<glength)

Java中判断条件为  if(count<glength&&s[i]>=g[count])

Javascript中判断条件为   if(s[i]>=g[count])

Javascript中当count大于数组g的长度后，g[count]=undefined，s[i]>undefined为false
C++中当count大于数组g的长度后，此处为<vector> int g; g[count]=0,s[i]>0为true
Java中当count大于数组g的长度后，会报错

最优解

时间复杂度（nlogn）
Java

只有排序花费了nlogn

我写了两个循环感觉多了,因为我第二个循环中的条件和第一个一样，可以合并