topological sorting

Stack is a special linear table, and the operation of inserting or deleting stack elements can only be done at one end of the table, which is called stack top and stack bottom. Queue is also a special linear table (the basic operation is a subset of linear operation).

Features: LIFO

Stack is also called LIFO linear table, LIFO table for short.

The chain implementation of stack is to use linked list as the storage structure of stack, and realize the basic operation of stack on this storage structure. The chain implementation of stack is called chain stack.

2. Directed acyclic graph

An effective tool to describe expressions with common subexpressions;

An effective tool to describe the progress of a project or system.

3. Some concepts

Usually, we regard planning, construction process, production flow and program flow as a project. A large project is often divided into many smaller subprojects, which are called activities. When these activities are completed, the whole project will be completed.

We use directed graphs to represent these projects, plans, etc. In this directed graph, vertices represent activities, and directed edges represent the priority relationship of activities. This directed graph, which uses vertices to represent activities and arcs to represent the priority relationship between activities, is called the vertex network (Actire? Open? Vertex) is called AOV network for short.

Topological sorting:

Suppose that G=(V, e) is a directed graph with n vertices, and vn in the vertex sequence v 1, v2,.., V is called topological order, if and only if the vertex sequence satisfies the following conditions: If there is a path from vertex vi to vj in the directed graph G, vertex vi must precede vertex vj in the vertex sequence. Generally, in AOV networks, the process of arranging all activities into a Topological sequence is called topological ordering (topological? Sort).

Directed rings should not appear in AOV networks. Because the existence of a ring means that an activity will be based on itself, it is obviously impossible to form a topological sequence.

The method to judge whether there is a ring in the network is to construct a topological ordered sequence of its vertices for a directed graph. If all vertices in the network appear in their topological ordered sequence, there must be no rings in the AOV network.

4. Topological sorting algorithm.

Enter the AOV network. Order? n？ Is the number of vertices.

(1) Select a vertex without a direct predecessor in the AOV network and output it;

(2) Delete vertices from the graph. At the same time, delete all directed edges it sends out;

Repeat the above steps until all vertices have been output to form a topological ordered sequence, and the topological sorting is completed; Or there are vertices in the graph that have not been output, but have jumped out of the processing cycle. This shows that there are still some vertices left in the graph, all of which have direct precursors, and no vertices without precursors can be found any more. At this time, there must be a directed ring in the AOV network.

5. C language description of topological sorting algorithm.

In the algorithm of topological sorting, adjacency list is used as the storage structure of directed graph, each vertex is set with a single linked list, each single linked list has a head node, and a field count for storing vertex degrees is added to the head node to form an array.

In order to avoid repeatedly detecting points with permeability of 0, another stack is set to store all points with permeability of 0.

For a directed graph with n vertices and e edges, the time to establish a vertex stack with an in-degree of 0 in a for cycle is o (n); If there is no directed loop in the process of topological sorting, then the operations of popping, popping and subtracting 1 of each vertex are executed e times in the while loop statement, so the total time cost of topological sorting is o? (noun+noun).

6. C language implementation of topological sorting algorithm.

# contains "stdio.h"

# Definition? Maximum number of vertices 20

# contains "conio.h"

# contains "stdlib.h"

# Definition? STACK_INIT_SIZE 16

# Definition? Stack increment 5

typedef？ int？ SElemType

typedef？ charVertexType

typedef？ Structure

{

SElemType？ * base number;

SElemType？ * top

int？ stacksize

} SqStack

//We still use adjacency list to draw the storage structure.

typedef？ struct？ ArcNode{

int？ adjvex

struct？ ArcNode？ * nextarc

int？ Information;

} ArcNode？ //Table node type

typedef？ struct？ VNode{

VertexType？ Data;

int？ Count;

ArcNode？ * firstarc

}VNode，adj list[MAX _ VERTEX _ NUM]； //Head node

typedef？ Structure {

AdjList？ Vertex; ? //adjacency list

int？ vexnum，arcnum

} ALGraph

int？ init stack(sq stack & amp； s)

{

s . base =(selem type *)malloc(STACK _ INIT _ SIZE * sizeof(selem type))；

If (! American base)? Exit (-1);

s . top = s . base；

S.stacksize = STACK _ INIT _ SIZE

Return? 1;

}//Initialize the stack

int？ Push (SqStack & amps, SElemType? e)

{

if((s . top-s . base)& gt； =S.stacksize)

{

s . base =(selem type *)realloc(s . base，(s . stack size+stack increment)* sizeof(selem type))；

If (! American base)? Exit (-1);

s . top = s . base+s . stack size；

s . stack size+= stack increment；

}//If

*(s . top)= e；

s . top++；

Return? 1;

}//Push

int？ pop(SqStack & amp； s，SElemType？ & ampe)

{

if(S.top==S.base)return？ 0;

-s . top；

e = * S.top

Return? 1;

}//popup

int？ StackEmpty(sq stack & amp； s)

{

if(S.top==S.base)return？ 1;

Or what? Return? 0;

}//StackEmpty

int？ LocateVex(ALGraphG，char？ u)

{

int？ Me;

For what? (I = 0； I<g. Vixnum; i++)

{? If(u==G.vertices[i]. data)? Return? Me; ? }

What if? (i==G.vexnum)？ {printf ("Error? u！ \ n ")； Exit (1); }

Return? 0;

}

voidCreateALGraph _ adj list(ALGraph？ & ampg)

{

int？ I，j，k，w；

Charles? V 1, v2, press enter;

ArcNode？ * p；

Printf ("input? Vicksnam? & amparcnum:\ n ")；

Scanf("%d ",& vexnum);

scanf("%d "，& ampg . arcnum)；

Printf ("input? Vertex (separating data by carriage return): \ n ");

For what? (I = 0； I<g. Vixnum; i++)

{ ? Scanf("%c%c ",& enter & vertex [i]. Data); //Attention, explain.

Vertex [i] firstarc = NULL

}//for

Printf ("Input Arcs (V 1, V2, w) separate data with carriage return: \ n ");

For what? (k = 0； k & ltG.arcnumk++)

{

Scanf("%c%c ",& input & amp1);

Scanf("%c%c ",& input & v2);

//scanf("%d "，& ampw)；

i=LocateVex(G，v 1)；

j=LocateVex(G，v2)；

p =(ArcNode *)malloc(sizeof(ArcNode))；

p->； adj vex = j；

//p-& gt； Information? =? w；

p->； nextarc=G.vertices[i]。 firstarc？ //Pre-insertion method, that is, it is inserted behind the head node every time.

Vertex [i] first arc = p；

printf(" Next \ n ")；

}//for

Return;

}//CreateALGraph_adjlist

voidFindInDegree(ALGraph？ & ampg)

{

int？ I，j；

for(I = 0； I<g. Vixnum; i++)

{

Vertex [i] count = 0；

}//for

for(j = 0； J<g. Vicksnum; j++)

{

//G.vertices[i]。 count++；

for(ArcNode*p=G.vertices[j].firstarcp； p = p-& gt； nextarc)

G. Vertex [p->; adjvex】。 count++；

}//for

}//findingree

int？ Topological sorting (ALGraph & ampg)

{

SqStack？ s；

FindInDegree(G)；

InitStack

for(inti = 0； I<g. Vixnum; i++)

if(G.vertices[i].count==0)？ Push (s, I);

int？ countt = 0；

And (! Stack top)

{

int？ I, m;

m=Pop(S，I)；

printf("？ %c "，G.vertices[i]。 Data); ? ++ countt；

for(ArcNode？ *p=G.vertices[i]。 firstarcp； p = p-& gt； nextarc)

{ int？ k；

k = p-& gt； adjvex

If (! (- G.vertices[k])。 Count))? Push(S，k)；

}//for

}//When

if(countt & lt； G.vexnum)？ Return? 0;

Or what? Return? 1;

}//Topological sorting

int？ Master ()

{

ALGraph？ g；

create algraph _ adj list(G)；

Topological ordering (g);

Return? 1;

}

7.malloc function and realloc function

realloc:？ Invalid? *realloc(void？ * piece,? size_t？ Size), adjust the memory block pointed by the block to size, and return the address of the new block. If the requirements can be met, the content of the new block is consistent with the original block; If the requirements cannot be met, NULL is returned and the original block remains unchanged.

Invalid? *malloc(size_t？ Size): Allocate a storage block with size, and return the address of the storage block; if not, return NULL.