*********0*****6*******************6**********************************1
*
* Algorithm 2.2.3T (Topological Sort)
*
* This algorithm inputs a sequence of relations j<k, indicating that
* object j precedes object k in a certain partial ordering, assuming
* that 1<=j, k<=n.  The output is a set of n objects embedded in
* linear order. The internal tables used are:
*   QLINK[0]
*   COUNT[1] = QLINK[1]
*   COUNT[2] = QLINK[2]
*   ...
*   COUNT[n] = QLINK[n]

* Other variables:
*   TOP[1]
*   TOP[2]
*   ...
*   TOP[n]
*   a storage pool with one node for each input relation and with
*     SUC and NEXT fields
*   P, a link variable used to refer to the nodes in the storage pool
*   F and R, integer-valued variables used to refer to the front and
*     and rear of a queue whose links are in the QLINK table
*   N, a variable that counts how many objects have yet to be output
*
*********0*****6*******************6**********************************1
*
*  T1. [Initialize.]
*
*  [1] Input the value of n
*  [2] Set COUNT(k)<-0            (Defined with initial values.)
*  [3] Set TOP(k)<-0 for 1=<k=<n. (Defined with initial values.)
*  [4] Set N<-n
*
*********0*****6*******************6**********************************1
*
*  T2. [Next relation.]
*
*  [5] Get the next relation "j<k" from the input
*  [6] If the input has been exhausted
*  [7]    then go to T4
*
*********0*****6*******************6**********************************1
*
*  T3. [Record the relation.]
*
*  [8] Increase COUNT(k) by one
*  [9] Set P<=AVAIL
* [10] Set SUC(P)<-k
* [11] Set NEXT(P)<-TOP(j)
* [12] Set TOP(j)<-P.
* [13] Go back to step T2
*
*********0*****6*******************6**********************************1
*
*  T4. [Scan for zeroes.]
* [14] Set R<-0
* [15] Set QLINK(0)<-0
* [16] For 1=<k=<n
* [17]   If COUNT(k)=0
* [18]      Set QLINK(R)<-k
* [19]      Set R<-k
* [20]   EndIf
* [21] EndFor
* [22] Set F<-QLINK(0)
*
*********0*****6*******************6**********************************1
*
*  T5. [Output front of queue.]
* [23] Output the value of F
* [24] If F=0
* [25]    Then go to step T8
* [26]    Else
* [27]       Set N <- N-1
* [28]       Set P<-TOP(F)
* [29] EndIf
*
*********0*****6*******************6**********************************1
*
*  T6. [Erase relations.]
* [30] Do While( P /= 0 )
* [31]    Set COUNT(SUC(P)) <- COUNT(SUC(P))-1
* [32]    If COUNT(SUC(P)) = 0
* [33]       Then set QLINK(R)<-SUC(P)
* [34]            set R<-SUC(P)
* [35]    EndIf
* [36]    Set P<-NEXT(P)
* [37] EndDo
*
*********0*****6*******************6**********************************1
*
*  T7. [Remove from queue.]
* [38] Set F<-QLINK(F)
* [39] Go back to step T5
*
*********0*****6*******************6**********************************1
*
*  T8. [End of process.]
* [40] The algorithm terminates.  If N=0, we have output all of the
*      object numbers in the desired "topological order," followed by
*      a zero.  Otherwise, the N object numbers not yet output contain
*      a loop, in violation of the hypothesis of partial order.
*
*********0*****6*******************6**********************************1
*