FDS Week 8: Topological Sort

Topological Sort

---

简单方法：时间复杂度(Nv)^2

bool TopSort( LGraph Graph, Vertex TopOrder[] )
{
    PtrToAdjVNode temp = (PtrToAdjVNode)malloc(sizeof(PtrToAdjVNode));
    int Indegree[MaxVertexNum]={0};
    int i;
    Vertex j, index;
    for ( i=0; iNv; i++ )
    {
        temp = Graph->G[i].FirstEdge;
        while(temp!=NULL)
        {
            Indegree[temp->AdjV]++;//Store the indegrees of each vertex 
            temp = temp->Next;      
        }       
    }
    for ( i=0; iNv; i++ )
    {
        index = -1;
        for (j=0; jNv; j++ )
        {
            if(Indegree[j]==0)
            {
                Indegree[j]--;
                index = j;
                temp = Graph->G[index].FirstEdge;
                while(temp!=NULL)
                {
                    Indegree[temp->AdjV]--;//Store the indegrees of each vertex 
                    temp = temp->Next;          
                }       
                break;
            }
        }
        if(index==-1) return false;
        else TopOrder[i] = index;
    }
    return true;
}

优化：时间复杂度(Nv+Ne)

typedef struct st *Stack;
typedef Vertex ElementType;
struct st{
    int Capacity;
    int Top;
    ElementType *Array;
};

int IsEmpty(Stack S);
Stack CreateStack(int MaxElements);
void MakeEmpty(Stack S);
void Push(ElementType X, Stack S);
void Pop(Stack S);
ElementType TopAndPop(Stack S);

Stack CreateStack(int MaxElements)
{
    Stack S = (Stack)malloc(sizeof(Stack));
    S->Array = (ElementType*)malloc(sizeof(ElementType)*MaxElements);
    S->Capacity = MaxElements;
    MakeEmpty(S);
    return S;
}

int IsEmpty(Stack S)
{
    return S->Top == -1;
}

void MakeEmpty(Stack S)
{
    S->Top = -1;
}

void Push(ElementType X, Stack S)
{
    S->Array[++S->Top] = X;
}

void Pop(Stack S)
{
    if(!IsEmpty(S))
        S->Top--;
}

ElementType TopAndPop(Stack S)
{
    if(!IsEmpty(S))
        return S->Array[S->Top--];
}
bool TopSort( LGraph Graph, Vertex TopOrder[] )
{
    Stack ZeroIndegree =CreateStack(MaxVertexNum); 
    PtrToAdjVNode temp = (PtrToAdjVNode)malloc(sizeof(PtrToAdjVNode));
    int Indegree[MaxVertexNum]={0};
    int i, counter=0;
    Vertex j, index;
    for ( i=0; iNv; i++ )
    {
        temp = Graph->G[i].FirstEdge;
        while(temp!=NULL)
        {
            Indegree[temp->AdjV]++;
            temp = temp->Next;      
        }       
    }

    for(i=0; iNv; i++)
    {
        if(Indegree[i]==0)
        {
            Push(i,ZeroIndegree);
        }
    }

    while(!IsEmpty(ZeroIndegree))
    {
        index = TopAndPop(ZeroIndegree);
        TopOrder[counter++] = index;
        temp = Graph->G[index].FirstEdge;
        while(temp!=NULL)
        {
            if(--Indegree[temp->AdjV]==0)
            {
                Push(temp->AdjV,ZeroIndegree);
            }
            temp = temp->Next;          
        }
    }
    if(counter!=Graph->Nv) return false;
    else return true;
}