LeetCode 149题：直线上最多点的C语言解法

1. 问题背景与核心挑战

给定一个二维平面上的点集，如何找出位于同一条直线上点的最大数量？这是LeetCode第149题"直线上最多的点数"要解决的核心问题。乍看简单，实则暗藏玄机。

我在第一次遇到这个问题时，以为只需要计算两两点之间的斜率就能轻松解决。但实际编码时发现，浮点数精度问题、垂直线特殊情况、重复点处理等细节会让代码迅速变得复杂。经过多次调试和优化，最终总结出一套可靠的C语言解法。

2. 基础解法思路分析

2.1 暴力枚举法

最直观的解法是三重循环：对于每个点，计算它与其他所有点组成的直线，然后统计每条直线上的点数。这种方法时间复杂度高达O(n³)，在LeetCode上会直接超时。

c复制// 伪代码示例（实际不可行）
int maxPoints = 0;
for (int i = 0; i < n; i++) {
    for (int j = i+1; j < n; j++) {
        int count = 2;
        for (int k = j+1; k < n; k++) {
            if (isCollinear(points[i], points[j], points[k])) {
                count++;
            }
        }
        maxPoints = max(maxPoints, count);
    }
}

2.2 斜率统计优化

更聪明的做法是：对于每个点，计算它与其他所有点的斜率，用哈希表统计相同斜率的频次。这样可以将时间复杂度降到O(n²)。

关键观察点：

1. 同一个点会被多次计算，需要特殊处理
2. 垂直线（斜率无穷大）需要单独处理
3. 浮点数精度问题可能导致相同的斜率被误判为不同

3. C语言实现详解

3.1 数据结构定义

c复制typedef struct {
    int x;
    int y;
} Point;

// 简化分数表示（避免浮点精度问题）
typedef struct {
    int dx;
    int dy;
} Fraction;

3.2 斜率计算函数

c复制Fraction getSlope(Point p1, Point p2) {
    int dx = p2.x - p1.x;
    int dy = p2.y - p1.y;
    
    // 处理垂直线
    if (dx == 0) return (Fraction){0, 1};
    
    // 处理水平线
    if (dy == 0) return (Fraction){1, 0};
    
    // 计算最大公约数
    int gcd_val = gcd(dx, dy);
    
    // 返回最简分数形式
    return (Fraction){dx/gcd_val, dy/gcd_val};
}

3.3 最大公约数实现

c复制int gcd(int a, int b) {
    while (b != 0) {
        int temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

4. 核心算法实现

4.1 主函数逻辑

c复制int maxPoints(Point* points, int pointsSize) {
    if (pointsSize <= 2) return pointsSize;
    
    int max_count = 0;
    
    for (int i = 0; i < pointsSize; i++) {
        // 用于统计相同斜率的点数
        Fraction* slopes = malloc((pointsSize - 1) * sizeof(Fraction));
        int slope_count = 0;
        int same_point = 0;
        int current_max = 0;
        
        for (int j = 0; j < pointsSize; j++) {
            if (i == j) continue;
            
            if (points[i].x == points[j].x && points[i].y == points[j].y) {
                same_point++;
                continue;
            }
            
            slopes[slope_count++] = getSlope(points[i], points[j]);
        }
        
        // 统计斜率频次
        qsort(slopes, slope_count, sizeof(Fraction), compareFractions);
        
        if (slope_count > 0) {
            int count = 1;
            for (int k = 1; k < slope_count; k++) {
                if (slopes[k].dx == slopes[k-1].dx && 
                    slopes[k].dy == slopes[k-1].dy) {
                    count++;
                } else {
                    current_max = current_max > count ? current_max : count;
                    count = 1;
                }
            }
            current_max = current_max > count ? current_max : count;
        }
        
        // 加上当前点本身和重复点
        current_max = current_max + 1 + same_point;
        max_count = max_count > current_max ? max_count : current_max;
        
        free(slopes);
    }
    
    return max_count;
}

4.2 分数比较函数

c复制int compareFractions(const void* a, const void* b) {
    Fraction* fa = (Fraction*)a;
    Fraction* fb = (Fraction*)b;
    
    if (fa->dx == fb->dx && fa->dy == fb->dy) return 0;
    if (fa->dx * fb->dy < fb->dx * fa->dy) return -1;
    return 1;
}

5. 关键问题与优化技巧

5.1 浮点数精度问题

直接使用浮点数存储斜率会导致精度问题：

c复制double slope = (double)(p2.y - p1.y) / (p2.x - p1.x); // 不推荐

解决方案：

1. 使用分数表示法（分子分母约分后存储）
2. 比较斜率时使用交叉相乘避免除法

5.2 重复点处理

当输入中包含多个相同坐标的点时：

• 这些点自然在同一条直线上
• 需要在统计时特殊处理

5.3 垂直线特殊情况

当两点x坐标相同时：

• 斜率为无穷大
• 需要单独表示为(0,1)或其他标记值

5.4 哈希表优化

上述实现使用了排序+遍历统计频次，更高效的做法是使用哈希表：

c复制// 伪代码示例（需要实现哈希函数）
HashMap* map = createHashMap();
for (每个点) {
    Fraction slope = getSlope(p1, p2);
    int count = getFromHashMap(map, slope);
    putToHashMap(map, slope, count + 1);
}

6. 复杂度分析

• 时间复杂度：O(n²)

  • 外层循环：O(n)
  • 内层循环：O(n)
  • 斜率统计：O(n log n)（排序）

• 空间复杂度：O(n)

  • 存储斜率需要O(n)空间

7. 测试用例设计

验证算法正确性的关键测试场景：

1. 常规情况：

c复制[(1,1),(2,2),(3,3)] → 3

2. 包含重复点：

c复制[(1,1),(1,1),(2,2)] → 3

3. 垂直线：

c复制[(1,1),(1,2),(1,3)] → 3

4. 混合情况：

c复制[(1,1),(2,2),(3,3),(0,0),(1,2)] → 4

5. 所有点相同：

c复制[(0,0),(0,0),(0,0)] → 3

8. 实际编码中的坑

1. 内存管理：

   • 每次外层循环都需要重新分配斜率数组
   • 记得释放内存避免泄漏

2. 边界条件：

   • 点数≤2时直接返回
   • 所有点相同时的特殊处理

3. 比较函数实现：

   • 分数比较需要正确处理符号
   • 避免整数溢出（使用long long）

4. 斜率哈希：

   • 自定义分数结构体的哈希函数需要保证：
     • 相同斜率产生相同哈希值
     • 不同斜率尽量产生不同哈希值

9. 性能优化进阶

对于大规模点集（虽然LeetCode不需要）：

1. 随机采样：

   • 随机选择部分点计算，近似最大共线点数

2. 空间分割：

   • 将平面划分为网格，先粗粒度筛选可能共线的点集

3. 并行计算：

   • 不同起始点的斜率统计可以并行处理

10. 算法扩展思考

这个问题可以延伸到：

1. 三维空间中的共面点检测
2. 图像处理中的直线检测（Hough变换）
3. 计算几何中的共线性检测

在实际工程中，类似的思路可用于：

• 图像中边缘检测
• 点云数据处理
• 轨迹分析中的异常检测