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;
}