leetcode 455. Assign Cookies（C语言，堆排序）28

贴原题：

Assume you are an awesome parent and want to give your children some cookies. But, you should give each child at most one cookie. Each child i has a greed factor gi, which is the minimum size of a cookie that the child will be content with; and each cookie j has a size sj. If sj >= gi, we can assign the cookie j to the child i, and the child i will be content. Your goal is to maximize the number of your content children and output the maximum number.

Note: You may assume the greed factor is always positive. You cannot assign more than one cookie to one child.

Example 1: Input: [1,2,3], [1,1]

Output: 1

Explanation: You have 3 children and 2 cookies. The greed factors of 3 children are 1, 2, 3. And even though you have 2 cookies, since their size is both 1, you could only make the child whose greed factor is 1 content. You need to output 1.

Example 2: Input: [1,2], [1,2,3]

Output: 2

Explanation: You have 2 children and 3 cookies. The greed factors of 2 children are 1, 2. You have 3 cookies and their sizes are big enough to gratify all of the children, You need to output 2.

解析：
　　本题的题目说的有点复杂，简单来说就是给出两个数组，求数组２big enough于数组２元素的个数。换言之，就是求数组２中元素>=数组１中元素的个数。
　　我的思路很简单，就是把两个数组从小到大排序，然后依次比较各位元素的大小，如果big enough则计数器加一，否则换数组２中下一个较大的值与之比较，直到其中一个数组的元素都比较完。

Ｃ代码：

void heapAjust(int* array, int size, int root)//堆调整，构建最大顶堆
{
    int left=2*root;
    int right=left+1;
    int largest=root;
    if(left<size && *(array+left)>*(array+largest))
    {
        largest=left;
    }
    if(right<size && *(array+right)>*(array+largest))
    {
        largest=right;
    }
    if(largest!=root)
    {
        *(array+largest)=*(array+largest)^*(array+root);
        *(array+root)=*(array+largest)^*(array+root);
        *(array+largest)=*(array+largest)^*(array+root);
        heapAjust(array, size, largest);
    }
}
void heapSort(int* array, int size)//堆排序
{
    for(int i=size/2; i>=0; i--)
    {
        heapAjust(array, size, i);
    }
    for(int i=size-1; i>0; i--)
    {
        *array=*array^*(array+i);
        *(array+i)=*array^*(array+i);
        *array=*array^*(array+i);
        heapAjust(array, i, 0);
    }
}
int findContentChildren(int* g, int gSize, int* s, int sSize) {
    heapSort(g, gSize);
    heapSort(s, sSize);
    int cnt=0;//计数器
    int i=0, j=0;
    while(i<gSize && j<sSize)
    {
        if(*(g+i)<=*(s+j))//big enough
        {
            cnt++;//计数器加一
            i++;//继续比较下一个
            j++;
        }
        else//否则用s数组的下一个较大值与当前g[i]做比较
        {
            j++;
        }
    }
    return cnt;
}