leetcode（二）

1、平面上有 n 个点，点的位置用整数座标表示 points[i] = [xi, yi]。请你计算访问所有这些点需要的最小时间（以秒为单位）
你可以按照下面的规则在平面上移动：

• 每一秒沿水平或者竖直方向移动一个单位长度，或者跨过对角线（可以看作在一秒内向水平和竖直方向各移动一个单位长度）
• 必须按照数组中出现的顺序来访问这些点
  

int minTimeToVisitAllPoints(int** points, int pointsSize, int* pointsColSize){
int sum=0;
int a,b;
for(int i=0;i<pointsSize-1;i++)
{
    a=abs(points[i][0]-points[i+1][0]);//横座标
    b=abs(points[i][1]-points[i+1][0]);//纵座标
    sum=sum+abs(a-b);
    if(a>b)
    {
        sum=sum+b;
    }
    else
    {
        sum=sum+a;
    }
}
    *pointsColSize=sum;
    return sum;
}

2、请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点，你将只被给定要求被删除的节点。

现有一个链表 – head = [4,5,1,9]，它可以表示为:

void deleteNode(struct ListNode* node) {
node->val = node->next->val;
node->next = node->next->next;    
}

3、实现一种算法，删除单向链表中间的某个节点（除了第一个和最后一个节点，不一定是中间节点），假定你只能访问该节点。

void deleteNode(struct ListNode* node) {
    while(node->next!=NULL)
    {
        node->val=node->next->val;
        node->next=node->next->next;
    }
}

4、给你一个单链表的引用结点 head。链表中每个结点的值不是 0 就是 1。已知此链表是一个整数数字的二进制表示形式。请你返回该链表所表示数字的 十进制值 。

int getDecimalValue(struct ListNode* head){
int sum=0;
struct ListNode *a=head;
while(a!=NULL)
{
    sum=sum*2+a->val;
    a=a->next;
}
return sum;
}

5、实现一种算法，找出单向链表中倒数第 k 个节点。返回该节点的值。

int kthToLast(struct ListNode* head, int k){
struct ListNode *a=head;
struct ListNode *b=head;
    while(k--)
    {
        a=a->next;
    }
    while(a!=NULL)
    {
        a=a->next;
        b=b->next;
    }
return b->val;
}

6、输入数字 n，按顺序打印出从 1 到最大的 n 位十进制数。比如输入 3，则打印出 1、2、3 一直到最大的 3 位数 999。

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* printNumbers(int n, int* returnSize){
int s=1;
    while(n!=0)
    {
        s=s*10;
        n--;
    }
int *a=malloc(sizeof(int)*(s-1));
for(int j=0;j<s-1;j++)
{
    a[j]=j+1;
}
*returnSize=s-1;
return a;
}

7、给你一个 m * n 的矩阵 grid，矩阵中的元素无论是按行还是按列，都以非递增顺序排列。 请你统计并返回 grid 中 负数 的数目。

int countNegatives(int** grid, int gridSize, int* gridColSize){
int m=gridSize;
int n=*gridColSize;
int s=0;
for(int i=0;i<m;i++)
{
    for(int j=0;j<n;j++)
    {
        if(grid[i][j]<0)
        s++;
    }
}
return s;
}

8、在一个「平衡字符串」中，‘L’ 和 ‘R’ 字符的数量是相同的。
给出一个平衡字符串 s，请你将它分割成尽可能多的平衡字符串。
返回可以通过分割得到的平衡字符串的最大数量。

int balancedStringSplit(char * s){
int i=strlen(s);
int a=0;
int b=0;
int sum=0;
for(int j=0;j<i;j++)
{
    {
        if(s[j]=='R')
            a++;
        else if(s[j]=='L')
            b++;
    }
if(a==b)
sum++;
}

return sum;
}

9、请实现一个函数，把字符串 s 中的每个空格替换成"%20"

char* replaceSpace(char* s){
int i=strlen(s);
int m=0;
int n=0;
for(int j=0;j<i;j++)
{
    if(s[j]==' ')
    m++;
}
int *a=malloc(sizeof(int)*(m*3+i+1));
    for(int j=0;j<i;j++)
    {
        if(s[j]!=' ')
        {
            a[n++]=s[j];
        }
        else
        {
            a[n++]='%';
            a[n++]='2';
            a[n++]='0';
        }
    }
a[m*3+i]='\0';
return a;
}

10、桌上有 n 堆力扣币，每堆的数量保存在数组 coins 中。我们每次可以选择任意一堆，拿走其中的一枚或者两枚，求拿完所有力扣币的最少次数。

int minCount(int* coins, int coinsSize){
int sum=0;
for(int j=0;j<coinsSize;j++)
{
    while(coins[j]!=0)
    {
        if(coins[j]%2==0)
        {
            coins[j]=coins[j]-2;
            sum++;
        }
        else
        {
            coins[j]=coins[j]-1;
            sum++;
        }
}
}
return sum;
}