所有操作的時間消耗和空間消耗越低越好，其中排序演算法時間複雜度不能超過O(nlogn)，極端情況下也不可以退化為n^2

#include <iostream>
#include <vector>
#include <time.h>
#include <algorithm>
#include <windows.h>
using namespace std;

struct Sign    //簽到ID和時間
{
	int ID;
	time_t time;
	Sign()
	{
		ID = 0;
		time = 0;
	}
};

bool compareByID(const Sign& a, const Sign& b)
{
	return a.ID < b.ID;
}
bool compareByTime(const Sign& a, const Sign& b)
{
	return a.time < b.time;
}

class Machine
{
private:
	vector<Sign> signs;
public:
	Machine()
	{
		vector<Sign> signs(0);
	}

	void clear()
	{
		vector<Sign>(0).swap(signs);
	}

	int count() const
	{
		return signs.size();
	}

	void sign(const int& ID, const time_t& time)    //簽到
	{
		Sign sign;
		sign.ID = ID;
		sign.time = time;
		signs.push_back(move(sign));
	}

	int partition(vector<Sign>& signs, int l, int r) {
		if (l >= r)
			return l;
		int i = l;
		int j = r;
		Sign k = signs[i];
		while (i < j) {
			while (i < j && signs[j].time >= k.time)
				--j;
			signs[i] = signs[j];
			while (i < j && signs[i].time <= k.time)
				++i;
			signs[j] = signs[i];
		}
		signs[i] = k;
		return i;
	}

	int findNthToTail(const int n)     //查詢倒數第n個打卡的
	{
		int k = signs.size() - n + 1;
		int l = 0, r = signs.size() - 1;
		int index = partition(signs, l, r);
		while (index != k - 1) {
			if (index < k - 1) {
				l = index + 1;
				index = partition(signs, l, r);
			}
			else if (index > k - 1) {
				r = index - 1;
				index = partition(signs, l, r);
			}
		}

		return signs[index].ID;
	}

	void maxHeapDown(vector<Sign>& signs, int i, int n, bool(*func)(const Sign&, const Sign&))
	{
		int j = 2 * i + 1;
		Sign temp = signs[i];
		while (j < n){
			if (j + 1 < n && func(signs[j], signs[j+1]))
				++j;
			if (func(signs[j], temp))
				break;
			else{
				signs[i] = signs[j];
				i = j;
				j = 2 * i + 1;
			}
		}
		signs[i] = temp;
	}

	void heapSort(vector<Sign>& signs, bool(*func)(const Sign&, const Sign&))    //堆排
	{
		for (int i = signs.size() / 2 - 1; i >= 0; i--)
			maxHeapDown(signs, i, signs.size(), func);
		for (int i = signs.size() - 1; i >= 1; i--){
			swap(signs[i], signs[0]);
			maxHeapDown(signs, 0, i, func);
		}
	}

	void print(bool (*func)(const Sign&, const Sign&))  //根據傳入的排序方式排序
	{
		//sort(signs.begin(), signs.end(), func);
		heapSort(signs, func);
		for (int i = 0; i < signs.size(); ++i)
		{
			cout << signs[i].ID << " ";
		}
		cout << endl;
	}
};

class Employee
{
private:
	int ID;
public:
	Employee(int ID)
	{
		this->ID = ID;
	}
	virtual void sign(Machine& machine)  //簽到
	{
		time_t t = time(NULL);
		machine.sign(ID, t);
	}
};

class Stuff : public Employee           //員工
{
public:
	Stuff(int ID) : Employee(ID)
	{

	}
};

class Manager : public Employee         //主管
{
public:
	Manager(int ID) : Employee(ID)
	{

	}
	int count(Machine& machine) const   //統計打卡數量
	{
		return machine.count();
	}
	void newDay(Machine& machine)       //新的一天
	{
		machine.clear();
	}
	void printByID(Machine& machine)     //根據ID順序列印打卡員工的ID
	{
		machine.print(compareByID);
	}
	void printByTime(Machine& machine)   //根據打卡順序列印打卡員工的ID
	{
		machine.print(compareByTime);
	}
	int findNthToTail(Machine& machine, int n)    //查詢倒數第n個打卡的人的id
	{
		return machine.findNthToTail(n);
	}
};

int main()
{
	Machine machine;
	Stuff* stuff1 = new Stuff(1);
	Stuff* stuff2 = new Stuff(2);
	Stuff* stuff3 = new Stuff(3);
	Stuff* stuff4 = new Stuff(4);
	Stuff* stuff5 = new Stuff(5);
	Stuff* stuff6 = new Stuff(6);
	Stuff* stuff7 = new Stuff(7);

	Manager* manager1 = new Manager(4);

	cout << manager1->count(machine) << endl;

	stuff1->sign(machine);
	Sleep(1000);
	stuff3->sign(machine);
	Sleep(1000);
	stuff2->sign(machine);
	Sleep(1000);
	stuff5->sign(machine);
	Sleep(1000);
	stuff7->sign(machine);
	Sleep(1000);
	stuff6->sign(machine);
	Sleep(1000);

	manager1->printByID(machine);
	manager1->printByTime(machine);
	cout << manager1->findNthToTail(machine, 3);


	return 0;
}