Indirect priority queue implementation - c++

Question

I am reading indirect priority queues in Robert Sedgewick's Algorithms in C++.
The implementation below maintains pq as an array of indices into some client array. For example, if the client defines operator< for arguments of type Index, then, when fixUp compares pq[j] with pq[k], it is comparing data.grade[pq[j]] with data.grade[pq[k]], as desired. We assume that Index is a wrapper class whose object can index arrays, so that we can keep the heap position corresponding to index value k in qp[k], which allows us to implement "change priority" and "remove". We maintain the invariant pq[qp[k]]=qp[pq[k]]=k for all k in the heap.
template <class Index>
class PQ
{
private:
int N; Index* pq; int* qp;
void exch(Index i, Index j)
{
int t;
t = qp[i]; qp[i] = qp[j]; qp[j] = t;
pq[qp[i]] = i; pq[qp[j]] = j;
}
void fixUp(Index a[], int k);
void fixDown(Index a[], int k, int N);
public:
PQ(int maxN)
{
pq = new Index[maxN+1];
qp = new int[maxN+1]; N = 0;
}
int empty() const { return N == 0; }
void insert(Index v) { pq[++N] = v; qp[v] = N; fixUp(pq, N); }
Index getmax()
{
exch(pq[1], pq[N]);
fixDown(pq, 1, N-1);
return pq[N--];
}
void change(Index k)
{
fixUp(pq, qp[k]);
fixDown(pq, qp[k], N);
}
};
The main disadvantage of using indirection in this way is the extra space used. The size of the index arrays has to be the size of the data array, when the maximum size of the priority queue could be much less. Another approach to building a priority queue on top of existing data in an array is to have the client program make records consisting of a key with its array index as associated information, or to use an index key with a client-supplied overloaded operator<. Then, if the implementation uses a linked-allocation representation. Then the space used by the priority queue would be proportional to the maximum number of elements on the queue at any one time. Such approaches would be preferred over Program 9.12 if space must be conserved and if the priority queue involves only a small fraction of the data array.
What does the author mean by the below?
We assume that Index is a wrapper class whose object can index arrays
In improvement, the author is suggesting:
Another approach to building a priority queue on top of existing data in an array is to have the client program make records consisting of a key with its array index as associated information, or to use an index key with a client-supplied overloaded operator<. Then, if the implementation uses a linked-allocation representation
What does author mean here in the two points he is suggesting?