贪心算法题leetcode（C语言伪代码）

455 分发饼干
假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。

对每个孩子 i，都有一个胃口值 g[i]，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j，都有一个尺寸 s[j] 。如果 s[j] >= g[i]，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。
来源：力扣（LeetCode）

void quicksort(int *k,int low,int high);
int findContentChildren(int* g, int gSize, int* s, int sSize){
    int pivot ;
    int low,high;
    int i = 0;
    int j = 0;
    
    quicksort(g,low,high);//快速排序
    quicksort(s,low,high);

    for(;j <= sSize && i <= gSize;)
    {
        if(s[j] >= g[i])
        {
            j++;
            i++;
        }
        else
        {
            j++;
        }
    }
    return i; 

}

int partition(int *d,int low,int high)//分割函数得pivot（第一趟排序）
{
    int *k;
    int pivot;

    k = d;
    pivot = k[0];
    pivot = k[low];
    if (low == high)//只有一个数
    {
        return low;
    }
    else{
        for(;low < high;)
        {
            for(;k[high] >= pivot;)
            {
                high--;
            }
            k[low] = k[high];
            for(;k[low] <= pivot;)
            {
                low++;
            }
            k[high] = k[low];
        }
        k[low] = k[0];//记录中间的数
        return low;  
    }    
}
void quicksort(int *k,int low,int high)
{
    int pivot;

    pivot = partition(k, low, high);
    quicksort(k, low, pivot-1);//左边递归
    quicksort(k, pivot+1, high);//右边递归
}

452. 用最少数量的箭引爆气球
     在二维空间中有许多球形的气球。对于每个气球，提供的输入是水平方向上，气球直径的开始和结束坐标。由于它是水平的，所以纵坐标并不重要，因此只要知道开始和结束的横坐标就足够了。开始坐标总是小于结束坐标。

一支弓箭可以沿着 x 轴从不同点完全垂直地射出。在坐标 x 处射出一支箭，若有一个气球的直径的开始和结束坐标为 xstart，xend， 且满足 xstart ≤ x ≤ xend，则该气球会被引爆。可以射出的弓箭的数量没有限制。 弓箭一旦被射出之后，可以无限地前进。我们想找到使得所有气球全部被引爆，所需的弓箭的最小数量。

给你一个数组 points ，其中 points [i] = [xstart,xend] ，返回引爆所有气球所必须射出的最小弓箭数。

来源：力扣（LeetCode）

int findMinArrowShots(int** points, int pointsSize, int* pointsColSize){
int count=0;//箭数
int i;
int j = 2;
int points[5][3] ={{10,16},{2,8},{1,6},{7,12}};

points = sort(points,pointsSize)//按右边界排序
for(i = 1; i <= pointsSize;i = j+1)
{
    for (i = 1 ;point[i][1] >= points[j][0] && j <= pointsize;)
    {
        j++;//气球数
    }
    count++;
}
}

void sort(int **d, int pointsSize)//冒泡排序
{
    int i = 1;
    int j = 0;
    int temp1,temp2;
    int m = pointsSize;
    int flag =1;//记录本轮有没有发生交换，如果没有发生就不用继续排了

for (;m>0 && flag = 1;)
{
    for(i = 1; i <= m; i++)
    {
        flag = 0;
        if (d[i][1] > d[i+1][1])//前一个比后一个大交换
        {
            flag = 1;
            temp1 = d[i+1][0];
            temp2 = d[i+1][1];
            d[i+1][0] = d[i][0];
            d[i+1][1] = d[i+1][1];
            d[i][0] = temp1;
            d[i][1] = temp2;
        }
        m--;//
    }
}
    
}

322 零钱问题
给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1。
你可以认为每种硬币的数量是无限的。
来源：力扣（LeetCode）

#include 
int coinChange(int* coins, int coinsSize, int amount) {
    int i;

    coins[3] ={ 1,2,5 };
    amount = 11;
    int a = amount;
    int coinsSize = 0;

    sort(coins, 0, i);
    for (i = 2; i >= 0; i--)//最大的取不了则取下一个次大的
    {
        for (; coins[i] < a; coinsSize++)//贪心，每次都取最大的
        {
            a = a - coins[i];
        }
    }
    if (a = 0)
        return coinsSize;
    else
    {
        return -1;
    }
}

void sort(int* coins, int low, int high)//快速排序
{
    int pivotloc;
    if (low < high)
    {
        pivotloc = partition(coins, low, high);
        sort(coins, low, pivotloc - 1);
        sort(coins, pivotloc + 1, high);
    }

}

int partition(int* coins, int low, int high)
{
    int pivot = coins[low];
    for (; low < high;)
    {
        for (; low < high && coins[high] > pivot;)
        {
            high--;
        }
        coins[low] = coins[high];
        for (; low < high && coins[low] < pivot;) 
        {
            low++;
        }
        coins[high] = coins[low];
    }
    return low;
}

时间复杂度：快排O(nlogn)+贪心O(n^2)

1217 玩筹码
数轴上放置了一些筹码，每个筹码的位置存在数组 chips 当中。
你可以对 任何筹码 执行下面两种操作之一（不限操作次数，0 次也可以）：
将第 i 个筹码向左或者右移动 2 个单位，代价为 0。
将第 i 个筹码向左或者右移动 1 个单位，代价为 1。
最开始的时候，同一位置上也可能放着两个或者更多的筹码。
返回将所有筹码移动到同一位置（任意位置）上所需要的最小代价。
来源：力扣（LeetCode）

int minCostToMoveChips(int* position, int positionSize){
int i;
int odd;//奇数
int even;//偶数

for(i = 1 ; i <= positionSize; i++)//分别计算奇偶次数的个数
{
    if (position[i] % 2 = 0)//判断是否在偶数的位置上
    {
        even ++;
    }
    else
    {
        odd ++;
    }
}

if(even < odd)//相当于把所有的奇偶位置的数分别移到1和2号位，看哪边小就把所有移到另一边（我认为贪心就是这里）
{
    return even;
}
else
{
    return odd;
}

}
时间复杂度O(n)

1217 玩筹码
给定一个非负整数数组，你最初位于数组的第一个位置。

数组中的每个元素代表你在该位置可以跳跃的最大长度。

判断你是否能够到达最后一个位置。
来源：leetcode

#include 
bool canJump(int* nums, int numsSize) {
    int i = 0;
    int max = nums[0];//记录能达到最远的位置
    int sum;
    if (numsSize == 1 || numsSize == 0)//有0个或者有1个数，直接true
    {
        return true;
    }

    for (i = 0; i < numsSize; )//nums里面没有0，直接true
    {
        if (nums[i] != 0)
        {
            i++;
        }
    }
    if (i = numsSize - 1)
    {
        return true;
    }

    for (i = 1; i <= numsSize; i++)//其他情况（贪心）以累加来算max可到达最远的距离
    {
        if (i < max)
        {
            if (i + nums[i] > max)
            {
                max = i + nums[i];
            }
        }
        else
        {
            break;
        }
    }
    return max >= numsSize ? true : false;//判断是否可到达终点
}
时间复杂度O(n)