题目描述：

Suppose you have a random list of people standing in a queue. Each person is described by a pair of integers (h, k), where h is the height of the person and k is the number of people in front of this person who have a height greater than or equal to h. Write an algorithm to reconstruct the queue.

Note:
The number of people is less than 1,100.

Example

Input:
[[7,0], [4,4], [7,1], [5,0], [6,1], [5,2]]

Output:
[[5,0], [7,0], [5,2], [6,1], [4,4], [7,1]]

解题思路：

1. 从身高最矮的人开始。对传进来的数据进行排序，矮的在前，身高一样的话就比他高的人多的排在前面，然后对这个数据容器（vector）进行遍历。开辟一个空间重新存储这个队列。每次遍历容器的一个元素，则这个元素在新队列的位置由这个元素的第二个参数（比他高的人的数目）决定，这个数字是多少则在他前面应当刚好有这个数字的空位。如此遍历下来刚好能填满新空间。代码如下：

   struct person {
       int height;
       int heighterPeople;
       int flag;
       person() {
           flag = 0;//这个位置是否为空
           height = 0;
           heighterPeople = 0;
       }
   };
   class Solution {
   public:
       static bool sort_people(pair<int, int> & a, pair<int, int>& b) {
           if (a.first < b.first)
               return true;
           else if (a.first == b.first && a.second > b.second)
               return true;
           return false;
       }
       vector<pair<int, int>> reconstructQueue(vector<pair<int, int>>& people) {
           if (people.size() == 0)
               return people;
           sort(people.begin(), people.end(), sort_people);
           person * p = new person[people.size()];
           vector<pair<int, int>>::iterator iter = people.begin();
           for (; iter != people.end(); ++iter) {
               int count = 0, insertPosition = 0;
               for (int insertPosition = 0; insertPosition < people.size(); ++insertPosition) {
                   if (p[insertPosition].flag == 0 && iter->second == count) {
                       p[insertPosition].flag = 1;
                       p[insertPosition].height = iter->first;
                       p[insertPosition].heighterPeople = iter->second;
                       break;
                   }
                   if (p[insertPosition].flag == 0) {
                       count++;
                   }
               }
           }
           vector<pair<int, int>> temp;
           pair <int, int> store;
           for (int i = 0; i < people.size(); ++i) {
               store.second = p[i].heighterPeople;
               store.first = p[i].height;
               temp.push_back(store);
           }
           return temp;
       }
   };

2. 从身高最高的人开始。按身高对数据进行排序，身高一样则比其身高高的人数小的排在前面。遍历这个数据容器（vector），每次都将遍历的元素放到新容器中，位置则是容器的开始位置加上元素的第二个参数（比其身高高的人数）代码如下：

   vector<pair<int, int>> reconstructQueue(vector<pair<int, int>>& people) {
       auto comp = [](const pair<int, int>& p1, const pair<int, int>& p2)
       { return p1.first > p2.first || (p1.first == p2.first && p1.second < p2.second); };
       sort(people.begin(), people.end(), comp);
       vector<pair<int, int>> res;
       for (auto& p : people)
           res.insert(res.begin() + p.second, p);
       return res;
   }

3. 注意一下第一种方法中的排序函数的实现：
   
   1. 需要声明为静态的
   2. 要确保无论哪一种情况都有return值，所以这个函数最后一行代码不能删除。