1.4 LeetCode总结（线性表）_数组类

编程总结

每每刷完一道题后，其思想和精妙之处没有地方记录，本篇博客用以记录刷题过程中的遇到的算法和技巧

56. 合并区间

解题思路如下：
[1,3][2,6] -> [1,6]
先对输入数组按照区间左边的值进行升序排列
初始化一个变量 outputs，用于存储合并直接的区间结果
遍历排序后的所有区间，针对每个区间做如下的处理：
如果当前处理的区间是第一个区间的话，那么直接将区间加入到 outputs
当前区间为[2,6] 合并区间为[1,3]

否则没有重叠，没有重叠，那么直接将当前处理的区间加入到 outputs.

// 第一个元素从小到大排序, 如果第一个元素相等，则根据第二个元素从小到大排序
int cmp(const void *arr1, const void *arr2) {
	int *ar1 = *(int **)arr1, *ar2 = *(int **)arr2;

	if (ar1[0] != ar2[0]) {
		return ar1[0] - ar2[0];
	}
	return ar1[1] - ar2[1];
}

int **merge(int **intervals, int intervalsSize, int *intervalsColSize, int *returnSize, int **returnColumnSizes)
{
	int i;
	int cnt = 0;

	// 第一个元素从小到大排序；如果第一个元素相等，则根据第二个元素从小到大排序
	qsort(intervals, intervalsSize, sizeof(int *), cmp);

	// 定义返回值指针
	int **res = (int **)malloc(sizeof(int *) * intervalsSize);
	if (res == NULL) {
		return NULL;
	}
	for (i = 0; i < intervalsSize; i++) {
		res[i] = (int *)malloc(sizeof(int) * intervalsColSize[0]);
		if (res[i] == NULL) {
			return NULL;
		}
		memset(res[i], 0, sizeof(int) * intervalsColSize[0]);
	}

	res[0][0] = intervals[0][0];
	res[0][1] = intervals[0][1];
	// 合并区间 [1,3]
	// 当前区间 [2,6]
	// intervals [[1,3],[2,6]] --> [1,6]
	for (i = 1; i < intervalsSize; i++) {
		if (intervals[i][0] <= res[cnt][1] && intervals[i][1] >= res[cnt][1]) { // 当前区间起点小于合并区间终点，同时当前区间终点大于合并区间终点
			res[cnt][1] = intervals[i][1];                                      // 更新合并区间终点
		}
		else if (intervals[i][0] > res[cnt][1]) {                               // 当前区间起点大于合并区间终点
			cnt++;                                                              // 重新开辟合并区间
			res[cnt][0] = intervals[i][0];
			res[cnt][1] = intervals[i][1];
		}
	}

	// 结果返回
	*returnSize = cnt + 1;
	*returnColumnSizes = intervalsColSize;
	return res;
}

int main()
{
	int **intervals, intervalsSize = 2, *intervalsColSize = NULL, returnSize, *returnColumnSizes = NULL;

	returnColumnSizes = (int *)malloc(sizeof(int));
	intervalsColSize = (int *)malloc(sizeof(int));
	*intervalsColSize = 2;

	intervals = (int **)malloc(sizeof(int *) * intervalsSize);
	if (intervals == NULL) {
		return NULL;
	}
	for (int i = 0; i < intervalsSize; i++) {
		intervals[i] = (int *)malloc(sizeof(int) * intervalsColSize[0]);
		if (intervals[i] == NULL) {
			return NULL;
		}
		memset(intervals[i], 0, sizeof(int) * intervalsColSize[0]);
	}
	intervals[0][0] = 1;
	intervals[0][1] = 3;
	intervals[1][0] = 2;
	intervals[1][1] = 6;

	merge(intervals, intervalsSize, intervalsColSize, &returnSize, &returnColumnSizes);

	return 0;
}

2022. 将一维数组转变成二维数组

int **construct2DArray(int *original, int originalSize, int m, int n, int *returnSize, int **returnColumnSizes) {

	if (m * n != originalSize) { /* 不能转换的情况 */
		*returnSize = 0;
		return NULL;
	}

	int **result = (int **)malloc(sizeof(int*) * m);
	// int **returnColumnSizes = (int **)malloc(sizeof(int *) * 1); // 这个二维变量本身是有赋值空间的，但里面为空，需要malloc
	*returnColumnSizes = (int *)malloc(sizeof(int) * m); // *returnColumnSizes 整体是一个指针标量指向 m 个int类型数据空间.

	/* 生成二维数组m*n */
	for (int i = 0; i < m; i++) {
		result[i] = (int *)malloc(sizeof(int) * n);
		(*returnColumnSizes)[i] = n;
		for (int j = 0; j < n; j++) {
			result[i][j] = original[i * n + j];
		}
	}
	*returnSize = m;
	return result;
}