406 java_406.根据身高重建队列

文章目录

一，406.根据身高重建队列

二， 解题思路分析

1， 大致情况分为两种分别

2， 身高相同的情况

3， 身高不同的情况

4， 在这里面有一个非常关键概念就是：当前要插入身高数小的数已经插入进入了， 而比它大身高数没有插入进入呢！！！ ， 所以在当前这个数前面有几个数就空出几个位置，放比他的身高数大数

三，解题代码

**C**

四， 总结

一，406.根据身高重建队列

假设有打乱顺序的一群人站成一个队列。 每个人由一个整数对 (h, k) 表示，其中 h 是这个人的身高，k 是应该排在这个人前面且身高大于或等于 h 的人数。 例如：[5,2] 表示前面应该有 2 个身高大于等于 5 的人，而 [5,0] 表示前面不应该存在身高大于等于 5 的人。

编写一个算法，根据每个人的身高 h 重建这个队列，使之满足每个整数对 (h, k) 中对人数 k 的要求。

示例：

输入：[[7,0], [4,4], [7,1], [5,0], [6,1], [5,2]]

输出：[[5,0], [7,0], [5,2], [6,1], [4,4], [7,1]]

提示：

总人数少于 1100 人。

通过次数69,646提交次数97,421

二， 解题思路分析

1， 大致情况分为两种分别

身高相同的

身高不同的

下面我们就分析身高分析

2， 身高相同的情况

身高相同的，前面人数越多(k)是一定在后面的

例如:

( 4 , 3 ) ( 4 , 0 ) ( 4 , 2 ) ( 4 , 1 ) (4, 3)(4, 0)(4, 2)(4, 1)(4,3)(4,0)(4,2)(4,1)

( 4.0 ) 和 ( 4 ， 1 ) 坐 标 中 ( 4 ， 1 ) 一 定 是 在 ( 4 ， 0 ) 后 面 的 (4.0)和(4， 1)坐标 中(4， 1)一定是在(4， 0)后面的(4.0)和(4，1)坐标中(4，1)一定是在(4，0)后面的

3， 身高不同的情况

这个时候我们需要单独拿出一些数据来分析：

( 2 , 0 ) , ( 4 , 0 ) , ( 5 , 0 ) , ( 3 , 1 ) (2, 0), (4,0),(5,0),(3, 1)(2,0),(4,0),(5,0),(3,1)

我们可以这样不同的身高按照身高从小到大的排序

得到( 2 , 0 ) , ( 3 , 1 ) , ( 4 , 0 ) , ( 5 , 0 ) (2, 0),(3, 1), (4,0),(5,0)(2,0),(3,1),(4,0),(5,0)

如果是一个4的数组中 都没有使用，那么在第一个放( 2 , 0 ) (2, 0)(2,0),到放( 3 , 1 ) (3, 1)(3,1)时 我检查前面是否为空如果是空记一个当到2个空再插入(3,1)数据 , 说明在( 3 , 1 ) (3,1)(3,1)前面有一个大身高3的人，所以需要跳一个1位置,所以到( 4 , 0 ) (4,0)(4,0)主要有一个空位置可以插入进入了,( 5 , 0 ) (5,0)(5,0)也是这样的处理的

4， 在这里面有一个非常关键概念就是：当前要插入身高数小的数已经插入进入了， 而比它大身高数没有插入进入呢！！！ ， 所以在当前这个数前面有几个数就空出几个位置，放比他的身高数大数

三，解题代码

C

int pratition(int **people, int start, int end)

{

int value = people[start][0];

int right = start;

int left = end+1;

while (1)

{

//找到最大的数的下标

while ( people[++right][0] == value? people[right][1] > people[start][1] : people[start][0] > people[right][0] )

{

if(right == end)

{

break;

}

}

//最小的值

while ( people[--left][0] == value? people[left][1] < people[start][1] : people[start][0] < people[left][0] /*people[--left][1] < value*/)

{

if (left == start)

{

break;

}

}

if (left <= right)

{

break;

}

int * temp= people[right];

people[right] = people[left];

people[left] = temp;

}

int* temp = people[start];

people[start] = people[left];

people[left] = temp;

return left;

}

void sort(int **people, int start, int end)

{

if (end <= start)

{

return;

}

int p = pratition(people, start, end);

sort(people, start, p-1);

sort(people, p+1, end);

}

/**

*快速排序

*/

void quick_sort(int **people, int size)

{

if (people == NULL || size <= 0)

{

return;

}

sort(people, 0, size-1);

}

/**

* Return an array of arrays of size *returnSize.

* The sizes of the arrays are returned as *returnColumnSizes array.

* Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().

*/

int comp(const void * ptr1, const void * ptr2)

{

const int * value1 = *(const int **)ptr1;

const int * value2 = *(const int **)ptr2;

//a[0] == b[0] ? b[1] - a[1] : a[0] - b[0]

return (value1[0] == value2[0]) ? value2[1] - value1[1] : value1[0] - value2[0];

}

int** reconstructQueue(int** people, int peopleSize, int* peopleColSize, int* returnSize, int** returnColumnSizes)

{

*returnSize = 0;

// [[7,0],[4,4],[7,1],[5,0],[6,1],[5,2]]

//1. 快速排序 [[5,2],[5,0],[6,1],[7,0],[4,4],[7,1]]

quick_sort(people, peopleSize);

// 2. [[4,4],[5,2],[5,0],[6,1],[7,1],[7,0]]

// qsort(people, peopleSize, sizeof(int *), comp );

// *returnSize = peopleSize;

// *returnColumnSizes = peopleColSize;

// return people;

int **arrays = malloc(sizeof(int *) * peopleSize);

*returnColumnSizes = malloc(sizeof(int) * peopleSize);

memset(*returnColumnSizes, 0, sizeof(int)*peopleSize);

for (int i = 0; i < peopleSize; ++i)

{

int split = people[i][1] +1;

for (int j = 0; j < peopleSize; ++j)

{

if ((*returnColumnSizes)[j] == 0)

{

--split;

if (!split)

{

(*returnColumnSizes)[j] = 2;

arrays[j] = malloc(sizeof(int) * 2);

arrays[j][0] = people[i][0];

arrays[j][1] = people[i][1];

break;

}

}

}

}

*returnSize = peopleSize;

return arrays;

}

四， 总结

总结：当前要插入身高数小的数已经插入进入了， 而比它大身高数没有插入进入呢！！！ ， 所以在当前这个数前面有几个数就空出几个位置，放比他的身高数大数

源码地址:https://github.com/chensongpoixs/cleet_code