力扣网C语言编程题：盛最多水的容器

一. 简介

本文记录力扣网上的逻辑编程题，涉及数组方面的，主要以 C语言实现。

二. 力扣网C语言编程题：盛最多水的容器

题目：盛最多水的容器

给定一个长度为 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

解题思路一：（暴力解法，力扣网上编译显示超过时间限制，没有编译通过）

依次计算所有组合的容量，不断更新 max_capacity；

双层for循环实现轮询统计所有组合的容量；

C语言实现如下：

#include <stdio.h>

#define  MAX(a, b)    ((a) > (b) ? (a) : (b))

int maxArea(int* height, int heightSize) {
    if((height == NULL) || (!heightSize) || (1 == heightSize)) {
        return 0;
    }
    
    int i, j;
    int current_capacity = 0, max_capacity = 0;

    for(i = 0; i < (heightSize-1); i++) {
        for(j = 1; j < heightSize; j++) {
            if(height[i] > height[j]) {

                current_capacity = height[j] * (j-i);
            }
            else{
                current_capacity = height[i] * (j-i);
            }
            max_capacity = MAX(current_capacity, max_capacity);
        }
    }

    return max_capacity;
}

可以看出，上述实现逻辑上不存在问题，但是在力扣网上编译提示超过时间限制。可以看出这种实现方法的时间复杂度为 O(n*n)，接下来学习第二种解题思路。

解题思路二：

遍历一遍数组，使用类似双指针的功能，从数组的首尾两端开始统计最大容量。

影响容量大小的取决于元素值（即宽度）和两个元素之间的距离，因为从头部和尾部同时开始时是两个元素之间距离最大的时候，这时影响容量大小的就是元素值。

所以，比较两端元素值，当元素值小的一端则指针继续自增或自减（指针向前进）；

具体方法：

1. 遍历一遍数组，指定两个指针，首先计算当前容量，更新最大容量值；

2. 判断首部元素与尾部元素大小，值小的那端指针自增或自减（再查找最大元素值的元素）；

C语言实现如下：

#include <stdio.h>

#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define MAX(a, b) ((a) > (b) ? (a) : (b))


int maxArea(int* height, int heightSize) {
    if((height == NULL) || (!heightSize) || (1 == heightSize)) {
        return 0;
    }

    int current_capacity = 0;
    int max_capacity = 0;
    int left = 0;
    int right = heightSize-1;

    while(left < right) {
        current_capacity = MIN(height[left], height[right]) *(right-left);
        max_capacity = MAX(current_capacity, max_capacity);
        if(height[left] < height[right]) {
            left++;
        }
        else {
            right--;
        }
    }

    return max_capacity;
}

可以看出，这种实现方法的时间复杂度为O(n)，空间复杂度为 O(1)。

解题思路二还有下面一种实现方法（两种方法进行比较，还是上面实现方法好一些，步骤比较少一些）：

#include <stdio.h>

#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define MAX(a, b) ((a) > (b) ? (a) : (b))


int maxArea(int* height, int heightSize) {
    if((height == NULL) || (!heightSize) || (1 == heightSize)) {
        return 0;
    }

    int current_capacity = 0;
    int max_capacity = 0;
    int left = 0;
    int right = heightSize-1;

    while(left < right) {
        if(height[left] < height[right]) {
            current_capacity = height[left] *(right-left);
            left++;
        }
        else {
            current_capacity = height[right] *(right-left);
            right--;
        }
         max_capacity = MAX(current_capacity, max_capacity);
    }
   

    return max_capacity;
}

可以看出，时间复杂度也是 O(n)，空间复杂度是 O(1)。