Pseudocode to perform topological sort

void Shellsort( int A[ ], int N )

        {

            int i, j, Increment;

            int Tmp;

/* 1*/      for( Increment = N / 2; Increment > 0; Increment /= 2 )

/* 2*/          for( i = Increment; i < N; i++ )

                {

/* 3*/              Tmp = A[ i ];

/* 4*/              for( j = i; j >= Increment; j -= Increment )

/* 5*/                  if( Tmp < A[ j - Increment ] )

/* 6*/                      A[ j ] = A[ j - Increment ];

                        else

/* 7*/                      break;

/* 8*/              A[ j ] = Tmp;

                }

        }

        /* Lpos = start of left half, Rpos = start of right half */

        void Merge( int A[ ], int TmpArray[ ],

                        int Lpos, int Rpos, int RightEnd )

        {

            int i, LeftEnd, NumElements, TmpPos;

            LeftEnd = Rpos - 1;

            TmpPos = Lpos;

            NumElements = RightEnd - Lpos + 1;

            /* main loop */

            while( Lpos <= LeftEnd && Rpos <= RightEnd )

                if( A[ Lpos ] <= A[ Rpos ] )

                    TmpArray[ TmpPos++ ] = A[ Lpos++ ];

                else

                    TmpArray[ TmpPos++ ] = A[ Rpos++ ];

            while( Lpos <= LeftEnd )  /* Copy rest of first half */

                TmpArray[ TmpPos++ ] = A[ Lpos++ ];

            while( Rpos <= RightEnd ) /* Copy rest of second half */

                TmpArray[ TmpPos++ ] = A[ Rpos++ ];

            /* Copy TmpArray back */

            for( i = 0; i < NumElements; i++, RightEnd-- )

                A[ RightEnd ] = TmpArray[ RightEnd ];

        }

        void MSort( int A[ ], int TmpArray[ ],

                        int Left, int Right )

        {

            int Center;

            if( Left < Right )

            {

                Center = ( Left + Right ) / 2;

                MSort( A, TmpArray, Left, Center );

                MSort( A, TmpArray, Center + 1, Right );

                Merge( A, TmpArray, Left, Center + 1, Right );

            }

        }

        void Mergesort( int A[ ], int N )

        {

            int *TmpArray;

            TmpArray = malloc( N * sizeof( int ) );

            if( TmpArray != NULL )

            {

                MSort( A, TmpArray, 0, N - 1 );

                free( TmpArray );

            }

            else

                printf( "No space for tmp array!!!" );

        }