AOV拓扑排序

原创 2007年09月16日 12:20:00

这是一个AOV拓扑排序的例子,为了应付公司测试而作,写起来也不容易,给记录一下。

在Visual C++2005下做的,这个版本的IDE环境用起来还不错。

aov.h

 

//data structure
//linked graph

#include 
<iostream>
#include 
<vector>
#include 
<string>
#include 
<map>

class EdgeNode
{
public:
    
int adjvex;
    
//double weight;   useless in this program.
    EdgeNode *nextarc;
public:
    EdgeNode(
const int idx)
    
{
        adjvex 
= idx;
        nextarc 
= 0;
    }

}
;

// table head
class VNode 
{
public:
    std::
string data;
    EdgeNode 
*firstarc;
public:
    VNode(
const char* data, EdgeNode * firstarc)
    
{
        
if(data != 0)
            
this->data = data;
        
else
            printf(
"check test file. VNode Constructor. ");
        
this->firstarc = firstarc;
    }

}
;

class Graph
{
public:
    
int vnum;
    std::vector
<VNode> Vertices;
private:
    std::map
<std::stringint> node_map;//pretend to be hash_map
public:
    Graph()
    
{
        vnum 
= 0;
    }

    
int addNode(VNode& node);
    
int getNode(const char* name); //return the index in Vertices.
    void clear();
}
;

aov.cpp

 

//Normal return 0, otherwise -1
//Graph DAG, which records clothes information.
//
#include "aov.h"

using namespace std;

int Graph::addNode(VNode& node)
{
    node_map.insert(map
<std::stringint>::value_type(node.data, vnum++));
    Vertices.push_back(node);
    
return 0;
}


int Graph::getNode(const char* name)
{
    map
<stringint>::iterator it;
    it 
= node_map.find(name);
    
if(it != node_map.end())
        
return it->second;
    
return -1;
}


void Graph::clear()
{
    vector
<EdgeNode*> needtodel;
    
for(vector<VNode>::iterator it = Vertices.begin(); it != Vertices.end(); ++it)
    
{
        EdgeNode
* next = it->firstarc;
        
while(next)
        
{
            needtodel.push_back(next);
            next 
= next->nextarc;
        }

    }

    
for(vector<EdgeNode*>::iterator it = needtodel.begin(); it != needtodel.end(); ++it)
    
{
        delete 
*it;
    }

}

 

test.h

 

#include "aov.h"

#define PATH_LEN 256

class AOVTest
{
    Graph G;
    std::vector
<int> outputArray;
public:
    
int prepare(const char* file);
    
int TopologicalSort();
    
int output(const char* file);
}
;

 

test.cpp

 

#include "test.h"
#include 
<fstream>
#include 
<stack>
using namespace std;

#define BUFFER_SIZE 1024

int AOVTest::TopologicalSort()
{
    
int count = 0;
    
int* indegree = (int*)calloc(G.vnum, sizeof(int));
    
if(!indegree)
    
{
        printf( 
"Can't allocate memory " );
        
return -1;
    }


    
for(int i = 0; i < G.vnum; ++i)
    
{
        EdgeNode
* t = G.Vertices[i].firstarc;
        
while(t)
        
{
            indegree[t
->adjvex]++;
            t 
= t->nextarc;
        }

    }


    stack
<int> S;
    
for(int i = 0; i<G.vnum; ++i)
    
{
        
if(indegree[i] == 0)
            S.push(i);
    }

    count 
= 0;
    
while(!S.empty())
    
{
        
int idx = S.top();
        outputArray.push_back(idx);
        S.pop();
        
++count;
        
for(EdgeNode* t = G.Vertices[idx].firstarc; t ; t = t->nextarc)
        
{
            
int k = t->adjvex;
            indegree[k]
--;
            
if(indegree[k] == 0)
                S.push(k);
        }

    }

    
if(count < G.vnum)
    
{
        free(indegree);
        
return -1;
    }

    free(indegree);
    
return 0;
}


//
//create graph from test file
int AOVTest::prepare(const char* file)
{
    fstream fs(file, ios::
in);
    
if(!fs)
    
{
        cout 
<< "in file open failed!" << endl;
        
return -1;
    }


    
while(!fs.eof())
    
{
        
char buffer[BUFFER_SIZE];
        memset(buffer, 
0, BUFFER_SIZE);
        fs.getline(buffer, BUFFER_SIZE);

        
string line(buffer);
        
if(line.empty())
            
continue;

        
string::size_type pos = 0;
        pos 
= line.find("->"0);
        
if(pos != string::npos)
        
{
            
//handle with first cloth
            string sfirst = line.substr(0, pos);
            
if(sfirst.empty())
            
{
                printf(
"Error format. check test file. //->first one not exist!");
                
return -1;
            }

            
int idx1 = G.getNode(sfirst.c_str());
            
if(idx1 == -1)
            
{  //find in VNode
                idx1 = G.vnum;
                VNode vnode1(sfirst.c_str(), 
0);
                G.addNode(vnode1);
            }


            
//handle with last cloth
            string slast = line.substr(pos + 2, line.length() - pos - 2);
            
if(slast.empty())
            
{
                printf(
"Error format. check test file. //->last one not exist!");
                
return -1;
            }

            
int idx2 = G.getNode(slast.c_str());
            
if(idx2 == -1)
            
{  //find in VNode
                idx2 = G.vnum;
                VNode vnode2(slast.c_str(), 
0);
                G.addNode(vnode2);
            }


            
//connection reverse
            EdgeNode* plink = new EdgeNode(idx2);
            EdgeNode
* next = G.Vertices[idx1].firstarc;
            
if(!next)
                G.Vertices[idx1].firstarc 
= plink;
            
else
            
{
                EdgeNode
* current;
                
while(next)
                
{
                    current 
= next;
                    next 
= next->nextarc;
                }

                current
->nextarc = plink;
            }

        }
    
    }

    
return 0;
}


int AOVTest::output(const char* file)
{
    fstream fs(file, ios::
out);
    
if(!fs)
    
{
        cout 
<< "out file open failed!" << endl;
        
return -1;
    }


    
for(vector<int>::iterator it = outputArray.begin(); it != outputArray.end(); ++it)
    
{
        fs 
<< G.Vertices[*it].data << endl;
    }

    
return 0;
}

 

最后的了,main.cpp

 

#include "test.h"

#define USAGE_MSG "Usage: AOV [infile] + options
               
-o refer to output file.
               
default -is result.txt. "
int main(int argc, char** argv)
{
    
if(argc < 2)
    
{
        
//printf("Usage: AOV [infile] + options
        
//       -o refer to output file.
        
//       default -o is result.txt. ");
        printf(USAGE_MSG);
        getchar();
        
return -1;
    }


    
char infile[256];
    
char outfile[256];
    memset(outfile, 
0sizeof(outfile));

    
for(int i = 1; i < argc; ++i)
    
{
        
if(argv[i][0!= '-')
        
{
            
if(i == 1)
                strcpy(infile, argv[i]);
            
else if(i == 3)
                strcpy(outfile, argv[i]);
            
else
            
{
                printf(USAGE_MSG);
                getchar();
                
return -1;
            }


        }

        
else
        
{
            
if(argv[i][1!= 'o' || strlen(argv[i]) > 2)
            
{
                printf(USAGE_MSG);
                getchar();
                
return -1;
            }

        }

    }

    
if(!outfile)
    
{
        strcpy(outfile, 
"result.txt");
    }


    AOVTest ts;
    
int ret = 0;
    ret 
= ts.prepare(infile);
    
if(ret)
        _ASSERT(
0);
    ret 
= ts.TopologicalSort();
    
if(ret)
        _ASSERT(
0);
    ret 
= ts.output(outfile);
    
if(ret)
        _ASSERT(
0);

    getchar();
    
return 0;
}

AOV 数据结构中 拓扑排序

  • 2009年07月17日 20:02
  • 6KB
  • 下载

AOV网与拓扑排序

  • 2011年11月26日 16:52
  • 35KB
  • 下载

算法:AOV网(Activity on Vextex Network)与拓扑排序

在一个表示工程的有向图中,用顶点表示活动,用弧表示活动之间的优先关系,这样的有向图为顶点表示活动的网,我们称之为AOV网(Activity on Vextex Network)。AOV网中的弧表示活动...

数据结构之AOV网的拓扑排序算法

  • 2010年04月28日 00:57
  • 17KB
  • 下载

【数据结构】算法7.12 AOV-网 拓扑排序

#include #include #include#define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEAS...

数据结构之AOV网与拓扑排序

AOV网(Activity On Vertex Network ) 网:带权图。若在带权的有向图中,以顶点表示事件,以边(或者弧)表示活动,弧的权值表示活动的开销,则此带权有向图称为用边表示活动的...

数据结构 学习笔记(九):图(下):最小生成树(Prim,Kruskal 算法),拓扑排序 AOV,关键路径 AOE

最小生成树什么是最小生成树解决最小生成树有很多算法,但是归结起来都是贪心算法。贪心算法: 什么是“贪”:每一步都要最好的 什么是“好”:权重最小的边 但是因为是最小生成树,所以这个贪心算法还需要约束:...
  • Jurbo
  • Jurbo
  • 2017年07月10日 15:43
  • 779

关键路径(AOE)—基于拓扑排序(AOV)

数据结构讲到图的部分,实现一些比较经典的算法。测试数据是网上提供的。 关键路径的实现基于拓扑排序,同时用到了栈结构。//Stack.h #ifndef STACK_H #define STACK_H...

数据结构 — 图 之 拓扑排序 (AOV网)

【度娘说】: 对一个有向无环图(Directed Acyclic Graph简称DAG)G进行拓扑排序,是将G中所有顶点排成一个线性序列,使得图中任意一对顶点u和v,若边(u,v)∈E(G),则...

最小生成树_AOV网(拓扑排序)_AOE网(关键路径)_最短路径

最小生成树   通俗的讲,最小生成树就是用一条路径将图中的所有顶点链接起来,并且保证该路径上的权值之和是最小的.以保证该路径的唯一.重点就在于权值的最小. 算法 普里姆算法: 该算法利用两个集合,一个...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:AOV拓扑排序
举报原因:
原因补充:

(最多只允许输入30个字)