csdn2

977. 有序数组的平方

难度简单790收藏分享切换为英文接收动态反馈

给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

示例1：

输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]

示例2：

输入：nums = [-7,-3,2,3,11]
输出：[4,9,9,49,121]

提示：

• 1 <= nums.length <= 104

• -104 <= nums[i] <= 104

• nums 已按 非递减顺序 排序

  示例代码:

/**
* Note: The returned array must be malloced, assume caller calls free().
*/
int* sortedSquares(int* nums, int numsSize, int* returnSize){
   int i,j,t;
for(i=0;i<numsSize;i++)
{
   nums[i]=nums[i]*nums[i];
}
*returnSize=numsSize;
for(i=0;i<numsSize-1;i++)
{
   for(j=i+1;j<numsSize;j++)
   {
       if(nums[i]>nums[j])
       {
           t=nums[i];
           nums[i]=nums[j];
           nums[j]=t;
       }
   }
}
return nums;
}

*returnSize 是一个指向返回数组大小的指针变量。

在这个函数中，我们需要动态地分配并返回一个新的数组，因此需要一个指针来指示新数组的大小。由于在 C 语言中不允许直接返回数组，而且在函数内部定义的数组在函数结束后会被销毁，所以我们需要使用动态分配内存的方式来创建一个新的数组，并将其作为函数的返回值。

因此，*returnSize=numsSize; 的作用是将返回数组的大小设置为原始数组的元素数量，即相当于 *returnSize 指向了一个整数变量，它的值等于参数 numsSize 的值。这样，调用者就可以根据返回数组的大小来处理返回的数组。

2095. 删除链表的中间节点

难度中等38

给你一个链表的头节点 head 。删除 链表的 中间节点 ，并返回修改后的链表的头节点 head 。

长度为 n 链表的中间节点是从头数起第 ⌊n / 2⌋ 个节点（下标从 0 开始），其中 ⌊x⌋ 表示小于或等于 x 的最大整数。

• 对于 n = 1、2、3、4 和 5 的情况，中间节点的下标分别是 0、1、1、2 和 2 。

示例 1：

输入：head = [1,3,4,7,1,2,6]
输出：[1,3,4,1,2,6]
解释：
上图表示给出的链表。节点的下标分别标注在每个节点的下方。
由于 n = 7 ，值为 7 的节点 3 是中间节点，用红色标注。
返回结果为移除节点后的新链表。 

示例 2：

输入：head = [1,2,3,4]
输出：[1,2,4]
解释：
上图表示给出的链表。
对于 n = 4 ，值为 3 的节点 2 是中间节点，用红色标注。

示例 3：

输入：head = [2,1]
输出：[2]
解释：
上图表示给出的链表。
对于 n = 2 ，值为 1 的节点 1 是中间节点，用红色标注。
值为 2 的节点 0 是移除节点 1 后剩下的唯一一个节点。

提示：

• 链表中节点的数目在范围 [1, 105] 内

• 1 <= Node.val <= 105

  示例代码:

• /**
   * Definition for singly-linked list.
   * struct ListNode {
   *     int val;
   *     struct ListNode *next;
   * };
   */
  
  struct ListNode* deleteMiddle(struct ListNode* head){
  struct ListNode* l=head;
  struct ListNode* p=head;
  struct ListNode* tail=head;
  if(head->next==NULL)
      return NULL;
  int t=0,i;
  while(l->next!=NULL)
  {
      t=t+1;
      l=l->next;
  }
  for(i=1;i<=t/2+1;i++)
  {
      tail=p;
      p=p->next;
      if(t%2==0)
      {
          if(i==t/2)
          {
              tail->next=p->next;
          }
      }
      else
      {
          {
              if(i==t/2+1)
              {
                  tail->next=p->next;
              }
          }
      }
  }
  return head;
  }
  

11. 盛最多水的容器

难度中等4273

给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。

找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

返回容器可以储存的最大水量。

**说明：**你不能倾斜容器。

示例 1：

输入：[1,8,6,2,5,4,8,3,7]
输出：49 
解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。

示例 2：

输入：height = [1,1]
输出：1

提示：

• n == height.length

• 2 <= n <= 105

• 0 <= height[i] <= 104

  示例代码:

int maxArea(int* h, int n){
int i,max=0,new=0;
int l=0,r=n-1;
if(h[l]>=h[r])
max=h[r]*(n-1);
else 
max=h[l]*(n-1);
while(r!=l){
    if(h[l]>h[r]){
    r--;
    if(h[l]>h[r])
        {
            new=h[r]*(r-l);
            if(new>max)
            {
                max=new;
            }
        }
    else
        {
            new=h[l]*(r-l);
            if(new>max)
            {
                max=new;
            }
        }
    }
    else 
    {
        l++;
        if(h[l]>=h[r])
        {
            new=h[r]*(r-l);
            if(new>max)
            {
                max=new;
            }
        }
    else
        {
            new=h[l]*(r-l);
            if(new>max)
            {
                max=new;
            }
        }
    }
}
return max;
}

这个题写的时候没有仔细考虑，其实应该直接将所有的步骤可以放在循环中，以下是简化版

int maxArea(int* height, int heightSize){
    int left = 0, right = heightSize -1;
    int max = 0, tmp = 0;

    while (left < right) {
        if (height[left] < height[right]) {
            tmp = height[left] * (right - left);
            left++;
        } else {
            tmp = height[right] * (right - left);
            right--;
        }
        if (tmp > max) max = tmp;
    }

    return max;
}