图结构的实现并用邻接表储存

图结构的实现并用邻接表储存

你好！ 这是我第一次使用 Markdown编辑器 ！我很激动

图类

// 图的基类
class Edge;{                                        //边类
public :
    int from, to, weight;                           //from是起点，to是终点，weight是权重
    Edge(){                                         //缺省构造函数
        from = -1; to = -1; weight = 0;
    }
    Edge(int f, int t, int w){                      //给定参数的构造函数
        from = f; to = t; weight = w;
    }
};

class Graph{
public :
    int numVertex;                                  //图中顶点的个数
    int numEdge;                                    //图中边的条数
    int *Mark;                                      //标记图的顶点是否被访问过
    int *Indegree;                                  //存放图中顶点的入度
    Graph(int numVert){                             //图的构造函数
        numVertex = numVert;                        
        numEdge = 0;
        Indegree = new int[numVertex];
        Mark = new int[numVertex]
        for(int i = 0; i < numVertex; i++ ){
            Mark[i] = UNVISITED;                    //标志位UNVISITED
            Indegree[i] = 0;                        //入度设为0
        }
    }
    ～Graph(){                                      //析构函数
        delete [] Mark;                             //释放Mark数组
        delete [] Indegree;                         //释放Indegree数组
    }
    int VerticesNum(){                              //返回图中顶点的个数
        return numVertex;
    }
    bool IsEdge(Edge oneEdge){                      //oneEdge是否是边
        if(oneEdge.weight > 0 && oneEdge.weight < INFINITY && oneEdge.to >= 0)
            return true;
        else return false;
    }
};

邻接表存储

//邻接表存储
struct listUnit{                                    //邻接表重边节点结构体定义
    int vertex;                                     //边的终点
    int weight;                                     //边的权重
};

template < class Elem >                             //链表元素类
class Link{                                         
public:
    Elem element;                                   //表目的数据
    Link *next;                                     //指向下一个链表元素的指针
    Link(const Elem& elemval, Link *nextval = NULL){//构造函数
        element = elemval;
        next = nextval;
    }
    Link(Link *nextval = NULL){                     //构造函数
        next = nextval;
    }
};

template < class Elem >
class LList{                                        //链表类
public:
    Link < Elem > *head;                            //定义一个头指针方便操作
    LList(){                                        //构造函数
        head = new Link <Elem> ();
    }
};

class Graphl:public Graph{
private:
    LList <listUnit> *graList;                      //保存所有边表的数组
public: 
    Graphl(int numVert):Graph(numVert){             //构造函数
        graList = new LList<listUnit>[numVertex];
    }

    Edge FirstEdge(int oneVertex){                  //返回依附于顶点oneVertex的第一条边
        Edge myEdge;
        myEdge.from = oneVertex;                    //将顶点oneVertex作为边的始点
        Link <listUnit> *temp = graList[oneVertex].head;//temp指向边表的第一个元素
        if(temp->next != NULL){                     //如果顶点oneVertex边表非空
            myEdge.to = temp->next->element.vertex;
            myEdge.weight = temp->next->element.weight;
        }
        return myEdge;
    }

    Edge NextEdge(Edge preEdge){                    //返回与preEdge有相同顶点的下一条边
        Edge myEdge;                                
        myEdge.from = preEdge.from;                 //边的始点与preEdge的始点相同
        Link <listUnit> *temp = graList[preEdge.from].head;//temp指向边表的第一个元素
        while(temp->next != next != NULL && temp->next->element.vertex <= preEdge.to)
            temp = temp->next;                      //确定preEdge的位置
        if(temp->next != NULL){                     //如果preEdge的吓一跳边存在
            myEdge.to = temp->next->element.vertex;
            myEdge.weight = temp->next->element.weight;
        }
        return myEdge;
    }
}

第一次发好爽