mirror of
https://github.com/Linloir/GraphBuilder.git
synced 2025-12-16 19:58:12 +08:00
883 lines
30 KiB
C++
883 lines
30 KiB
C++
#include "graph_implement.h"
|
|
#include <QDebug>
|
|
|
|
AbstractGraph::~AbstractGraph(){}
|
|
|
|
void ALVex::visit(){
|
|
if(visited)
|
|
return;
|
|
info->gVex->visit(true);
|
|
visited = true;
|
|
}
|
|
|
|
void ALVex::access(const QString &hint){
|
|
info->gVex->access(hint);
|
|
}
|
|
|
|
void ALArc::visit(){
|
|
gArc->visit(true);
|
|
}
|
|
|
|
void ALArc::access(){
|
|
gArc->access();
|
|
}
|
|
|
|
ALGraph::~ALGraph(){
|
|
int i = vexList.size() - 1;
|
|
while(i >= 0)
|
|
DelVex(i--);
|
|
vexList.clear();
|
|
}
|
|
|
|
void ALGraph::AddVex(MyGraphicsVexItem *gvex){
|
|
ALVex newVex(gvex);
|
|
vexList.push_back(newVex);
|
|
}
|
|
|
|
void ALGraph::AddVex(VexInfo *info){
|
|
ALVex newVex(info);
|
|
vexList.push_back(newVex);
|
|
}
|
|
|
|
void ALGraph::AddArc(MyGraphicsLineItem *garc, int weight){
|
|
int strtVex = GetIdOf(garc->stVex());
|
|
int endVex = GetIdOf(garc->edVex());
|
|
|
|
ALArc *temp = vexList[strtVex].firstArc;
|
|
ALArc *newArc = new ALArc(garc, endVex, temp);
|
|
newArc->weight = weight;
|
|
vexList[strtVex].firstArc = newArc;
|
|
|
|
if(type == UDG){
|
|
temp = vexList[endVex].firstArc;
|
|
newArc = new ALArc(garc, strtVex, temp);
|
|
vexList[endVex].firstArc = newArc;
|
|
}
|
|
}
|
|
|
|
void ALGraph::DelVex(MyGraphicsVexItem *gvex){
|
|
int vexID = GetIdOf(gvex);
|
|
DelVex(vexID);
|
|
}
|
|
|
|
void ALGraph::DelVex(int vexID){
|
|
//Delete out arc
|
|
ALArc *curArc = vexList[vexID].firstArc;
|
|
while(curArc != nullptr){
|
|
ALArc *next = curArc->nextArc;
|
|
delete curArc;
|
|
curArc = next;
|
|
}
|
|
//Delete in arc and adjust arcs
|
|
for(int i = 0; i < vexList.size(); i++){
|
|
if(i == vexID) continue;
|
|
ALArc *dummyHead = new ALArc(nullptr, 0, vexList[i].firstArc);
|
|
ALArc *preArc = dummyHead;
|
|
while(preArc->nextArc != nullptr){
|
|
if(preArc->nextArc->eVexID == vexID){
|
|
ALArc *next = preArc->nextArc;
|
|
preArc->nextArc = next->nextArc;
|
|
delete next;
|
|
continue;
|
|
}
|
|
if(preArc->nextArc->eVexID > vexID)
|
|
preArc->nextArc->eVexID--;
|
|
preArc = preArc->nextArc;
|
|
}
|
|
vexList[i].firstArc = dummyHead->nextArc;
|
|
delete dummyHead;
|
|
}
|
|
vexList.erase(vexList.begin() + vexID);
|
|
}
|
|
|
|
void ALGraph::DelArc(MyGraphicsLineItem *garc){
|
|
int sVex = GetIdOf(garc->stVex());
|
|
int eVex = GetIdOf(garc->edVex());
|
|
DelArc(sVex, eVex);
|
|
}
|
|
|
|
void ALGraph::DelArc(int sVexID, int eVexID){
|
|
//Delete sVex -> eVex
|
|
if(vexList[sVexID].firstArc != nullptr){
|
|
if(vexList[sVexID].firstArc->eVexID == eVexID){
|
|
ALArc *awaitDel = vexList[sVexID].firstArc;
|
|
vexList[sVexID].firstArc = awaitDel->nextArc;
|
|
delete awaitDel;
|
|
}
|
|
else{
|
|
ALArc *preArc = vexList[sVexID].firstArc;
|
|
while(preArc->nextArc != nullptr && preArc->nextArc->eVexID != eVexID)
|
|
preArc = preArc->nextArc;
|
|
if(preArc->nextArc != nullptr){
|
|
ALArc *awaitDel = preArc->nextArc;
|
|
preArc->nextArc = awaitDel->nextArc;
|
|
delete awaitDel;
|
|
}
|
|
}
|
|
}
|
|
//Delete eVex -> sVex
|
|
if(type == UDG && vexList[eVexID].firstArc != nullptr){
|
|
if(vexList[eVexID].firstArc->eVexID == sVexID){
|
|
ALArc *awaitDel = vexList[eVexID].firstArc;
|
|
vexList[eVexID].firstArc = awaitDel->nextArc;
|
|
delete awaitDel;
|
|
}
|
|
else{
|
|
ALArc *preArc = vexList[eVexID].firstArc;
|
|
while(preArc->nextArc != nullptr && preArc->nextArc->eVexID != sVexID)
|
|
preArc = preArc->nextArc;
|
|
if(preArc->nextArc != nullptr){
|
|
ALArc *awaitDel = preArc->nextArc;
|
|
preArc->nextArc = awaitDel->nextArc;
|
|
delete awaitDel;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
int ALGraph::GetIdOf(MyGraphicsVexItem *gvex){
|
|
int i = 0;
|
|
while(i < vexList.size() && !vexList[i].info->gVex->equalTo(gvex))
|
|
i++;
|
|
return i == vexList.size() ? -1 : i;
|
|
}
|
|
|
|
ALArc* ALGraph::FindArc(int sID, int eID){
|
|
if(sID < 0 || sID >= vexList.size())
|
|
return nullptr;
|
|
ALArc *p = vexList[sID].firstArc;
|
|
while(p != nullptr){
|
|
if(p->eVexID == eID)
|
|
return p;
|
|
p = p->nextArc;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
void ALGraph::SetWeight(MyGraphicsLineItem *garc, int weight){
|
|
int strtVex = GetIdOf(garc->stVex());
|
|
int endVex = GetIdOf(garc->edVex());
|
|
ALArc *p = vexList[strtVex].firstArc;
|
|
while(p != nullptr){
|
|
if(p->eVexID == endVex){
|
|
p->weight = weight;
|
|
p->gArc->setText(QString::asprintf("%d", weight));
|
|
}
|
|
p = p->nextArc;
|
|
}
|
|
if(type == UDG){
|
|
p = vexList[endVex].firstArc;
|
|
while(p != nullptr){
|
|
if(p->eVexID == strtVex){
|
|
p->weight = weight;
|
|
}
|
|
p = p->nextArc;
|
|
}
|
|
}
|
|
}
|
|
|
|
void ALGraph::ConvertType(int _type){
|
|
if(_type == type) return;
|
|
type = _type;
|
|
if(type == UDG){
|
|
for(int i = 0; i < vexList.size(); i++){
|
|
ALArc *dummyHead = new ALArc(nullptr, i, vexList[i].firstArc);
|
|
ALArc *pre = dummyHead;
|
|
while(pre->nextArc != nullptr){
|
|
if(pre->nextArc->eVexID == GetIdOf(pre->nextArc->gArc->edVex())){
|
|
ALArc *temp = vexList[pre->nextArc->eVexID].firstArc;
|
|
vexList[pre->nextArc->eVexID].firstArc = new ALArc(pre->nextArc->gArc, i, temp);
|
|
pre->nextArc->gArc->setDirection(false);
|
|
}
|
|
pre = pre->nextArc;
|
|
}
|
|
delete dummyHead;
|
|
}
|
|
}
|
|
else{
|
|
for(int i = 0; i < vexList.size(); i++){
|
|
ALArc *dummyHead = new ALArc(nullptr, i, vexList[i].firstArc);
|
|
ALArc *pre = dummyHead;
|
|
while(pre->nextArc != nullptr){
|
|
if(pre->nextArc->eVexID != GetIdOf(pre->nextArc->gArc->edVex())){
|
|
ALArc *temp = pre->nextArc;
|
|
pre->nextArc = temp->nextArc;
|
|
temp->gArc->setDirection(true);
|
|
delete temp;
|
|
continue;
|
|
}
|
|
pre = pre->nextArc;
|
|
}
|
|
vexList[i].firstArc = dummyHead->nextArc;
|
|
delete dummyHead;
|
|
}
|
|
}
|
|
}
|
|
|
|
void ALGraph::ClearVisit(){
|
|
for(int i = 0; i < vexList.size(); i++){
|
|
vexList[i].visited = false;
|
|
vexList[i].info->gVex->visit(false);
|
|
}
|
|
}
|
|
|
|
void ALGraph::ResetDistance(){
|
|
for(int i = 0; i < vexList.size(); i++){
|
|
vexList[i].info->strtVexInfo = nullptr;
|
|
vexList[i].info->distance = VexInfo::INF;
|
|
vexList[i].info->preVexID = -1;
|
|
vexList[i].info->gVex->access("", false);
|
|
}
|
|
}
|
|
|
|
void ALGraph::DFS(int strtID){
|
|
if(strtID == -1)
|
|
return;
|
|
vector<int> awaitVexList;
|
|
vector<ALArc*> awaitArcList;
|
|
awaitVexList.push_back(strtID);
|
|
while(awaitVexList.size() > 0){
|
|
int nextVex = awaitVexList.back();
|
|
ALArc *nextArc = awaitArcList.size() > 0 ? awaitArcList.back() : nullptr;
|
|
awaitVexList.pop_back();
|
|
if(nextArc)
|
|
awaitArcList.pop_back();
|
|
for(ALArc *p = vexList[nextVex].firstArc; p != nullptr; p = p->nextArc){
|
|
if(vexList[p->eVexID].visited == false){
|
|
awaitVexList.push_back(p->eVexID);
|
|
awaitArcList.push_back(p);
|
|
if(type == UDG && GetIdOf(p->gArc->edVex()) != p->eVexID)
|
|
p->gArc->reverseDirection();
|
|
}
|
|
}
|
|
if(nextArc && !vexList[nextArc->eVexID].visited)
|
|
nextArc->visit();
|
|
vexList[nextVex].visit();
|
|
}
|
|
}
|
|
|
|
void ALGraph::BFS(int strtID){
|
|
if(strtID == -1)
|
|
return;
|
|
vector<int> awaitVexList;
|
|
vector<ALArc*> awaitArcList;
|
|
awaitVexList.push_back(strtID);
|
|
while(awaitVexList.size() > 0){
|
|
int nextVex = awaitVexList[0];
|
|
ALArc *nextArc = awaitArcList.size() > 0 ? awaitArcList[0] : nullptr;
|
|
awaitVexList.erase(awaitVexList.begin());
|
|
if(nextArc)
|
|
awaitArcList.erase(awaitArcList.begin());
|
|
for(ALArc *p = vexList[nextVex].firstArc; p != nullptr; p = p->nextArc){
|
|
if(vexList[p->eVexID].visited == false){
|
|
awaitVexList.push_back(p->eVexID);
|
|
awaitArcList.push_back(p);
|
|
if(type == UDG && GetIdOf(p->gArc->edVex()) != p->eVexID)
|
|
p->gArc->reverseDirection();
|
|
}
|
|
}
|
|
if(nextArc && !vexList[nextArc->eVexID].visited)
|
|
nextArc->visit();
|
|
vexList[nextVex].visit();
|
|
}
|
|
}
|
|
|
|
void ALGraph::Dijkstra(int strtID){
|
|
//Clear previous result
|
|
ClearVisit();
|
|
ResetDistance();
|
|
//Set start vex info to all vertexes
|
|
for(int i = 0; i < vexList.size(); i++)
|
|
vexList[i].info->strtVexInfo = vexList[strtID].info;
|
|
//Start dijkstra
|
|
vexList[strtID].info->distance = 0;
|
|
vexList[strtID].access("strt");
|
|
while(true){
|
|
//Find next
|
|
int minVexID = -1;
|
|
for(int i = 0; i < vexList.size(); i++){
|
|
if(vexList[i].visited || vexList[i].info->distance == VexInfo::INF)
|
|
continue;
|
|
if(minVexID == -1)
|
|
minVexID = i;
|
|
else if(vexList[i].info->distance < vexList[minVexID].info->distance)
|
|
minVexID = i;
|
|
}
|
|
if(minVexID == -1)
|
|
break;
|
|
//Set visit to edge and vex
|
|
ALArc *edge = FindArc(vexList[minVexID].info->preVexID, minVexID);
|
|
if(edge){
|
|
if(type == UDG && GetIdOf(edge->gArc->edVex()) != minVexID)
|
|
edge->gArc->reverseDirection();
|
|
edge->visit();
|
|
}
|
|
vexList[minVexID].visit();
|
|
//Find adjacent
|
|
for(ALArc *p = vexList[minVexID].firstArc; p != nullptr; p = p->nextArc){
|
|
if(!vexList[p->eVexID].visited){
|
|
if(GetIdOf(p->gArc->edVex()) != p->eVexID)
|
|
p->gArc->reverseDirection();
|
|
p->access();
|
|
if(vexList[p->eVexID].info->distance == VexInfo::INF ||
|
|
vexList[p->eVexID].info->distance > vexList[minVexID].info->distance + p->weight){
|
|
vexList[p->eVexID].info->preVexID = minVexID;
|
|
vexList[p->eVexID].info->distance = vexList[minVexID].info->distance + p->weight;
|
|
vexList[p->eVexID].access(QString::asprintf("%d", vexList[p->eVexID].info->distance));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
AMLGraph* ALGraph::ConvertToAML(){
|
|
AMLGraph *converted = new AMLGraph(type);
|
|
for(int i = 0; i < vexList.size(); i++){
|
|
converted->AddVex(vexList[i].info);
|
|
}
|
|
for(int i = 0; i < vexList.size(); i++){
|
|
ALArc *p = vexList[i].firstArc;
|
|
while(p != nullptr){
|
|
if(type == DG || (type == UDG && i == GetIdOf(p->gArc->edVex())))
|
|
converted->AddArc(p->gArc, p->weight);
|
|
p = p->nextArc;
|
|
}
|
|
}
|
|
return converted;
|
|
}
|
|
|
|
/**************************************************************************************/
|
|
|
|
void AMLVex::visit(){
|
|
if(visited)
|
|
return;
|
|
info->gVex->visit(true);
|
|
visited = true;
|
|
}
|
|
|
|
void AMLVex::access(const QString &hint){
|
|
info->gVex->access(hint);
|
|
}
|
|
|
|
void AMLArc::visit(){
|
|
gArc->visit(true);
|
|
}
|
|
|
|
void AMLArc::access(){
|
|
gArc->access();
|
|
}
|
|
|
|
AMLGraph::~AMLGraph(){
|
|
int i = outVexList.size() - 1;
|
|
while(i >= 0){
|
|
DelVex(i--);
|
|
}
|
|
outVexList.clear();
|
|
if(type == DG)
|
|
inVexList.clear();
|
|
}
|
|
|
|
void AMLGraph::AddVex(MyGraphicsVexItem *gvex){
|
|
AMLVex newVex(gvex);
|
|
outVexList.push_back(newVex);
|
|
|
|
if(type == DG){
|
|
inVexList.push_back(newVex);
|
|
}
|
|
}
|
|
|
|
void AMLGraph::AddVex(VexInfo *info){
|
|
AMLVex newVex(info);
|
|
outVexList.push_back(newVex);
|
|
|
|
if(type == DG){
|
|
inVexList.push_back(newVex);
|
|
}
|
|
}
|
|
|
|
void AMLGraph::AddArc(MyGraphicsLineItem *garc, int weight){
|
|
int strtVex = GetIdOf(garc->stVex());
|
|
int endVex = GetIdOf(garc->edVex());
|
|
|
|
AMLArc *nextOutArc = outVexList[strtVex].firstArc;
|
|
AMLArc *nextInArc = type == DG ? inVexList[endVex].firstArc : outVexList[endVex].firstArc;
|
|
AMLArc *newArc = new AMLArc(garc, strtVex, endVex, nextOutArc, nextInArc);
|
|
newArc->weight = weight;
|
|
outVexList[strtVex].firstArc = newArc;
|
|
if(type == DG)
|
|
inVexList[endVex].firstArc = newArc;
|
|
else
|
|
outVexList[endVex].firstArc = newArc;
|
|
}
|
|
|
|
void AMLGraph::DelVex(MyGraphicsVexItem *gvex){
|
|
int vexID = GetIdOf(gvex);
|
|
DelVex(vexID);
|
|
}
|
|
|
|
void AMLGraph::DelVex(int vexID){
|
|
if(type == DG){
|
|
//Delete out arc
|
|
AMLArc *outArc = outVexList[vexID].firstArc;
|
|
while(outArc != nullptr){
|
|
AMLArc *dummyHead = new AMLArc(nullptr, 0, 0, nullptr, inVexList[outArc->inVexID].firstArc);
|
|
AMLArc *preInArc = dummyHead;
|
|
while(preInArc->nextInArc != nullptr){
|
|
if(preInArc->nextInArc->outVexID == vexID){
|
|
AMLArc *next = preInArc->nextInArc;
|
|
preInArc->nextInArc = next->nextInArc;
|
|
delete next;
|
|
}
|
|
else
|
|
preInArc = preInArc->nextInArc;
|
|
}
|
|
inVexList[outArc->inVexID].firstArc = dummyHead->nextInArc;
|
|
delete dummyHead;
|
|
outArc = outArc->nextOutArc;
|
|
}
|
|
//Delete in arc and adjust ID
|
|
for(int i = 0; i < outVexList.size(); i++){
|
|
if(i == vexID) continue;
|
|
AMLArc *dummyHead = new AMLArc(nullptr, 0, 0, outVexList[i].firstArc, nullptr);
|
|
AMLArc *preOutArc = dummyHead;
|
|
while(preOutArc->nextOutArc != nullptr){
|
|
if(preOutArc->nextOutArc->inVexID == vexID){
|
|
AMLArc *next = preOutArc->nextOutArc;
|
|
preOutArc->nextOutArc = next->nextOutArc;
|
|
delete next;
|
|
continue;
|
|
}
|
|
if(preOutArc->nextOutArc->inVexID > vexID)
|
|
preOutArc->nextOutArc->inVexID--;
|
|
if(preOutArc->nextOutArc->outVexID > vexID)
|
|
preOutArc->nextOutArc->outVexID--;
|
|
preOutArc = preOutArc->nextOutArc;
|
|
}
|
|
outVexList[i].firstArc = dummyHead->nextOutArc;
|
|
delete dummyHead;
|
|
}
|
|
outVexList.erase(outVexList.begin() + vexID);
|
|
inVexList.erase(inVexList.begin() + vexID);
|
|
}
|
|
else{
|
|
//Traverse all and adjust ID
|
|
AMLArc *p = outVexList[vexID].firstArc;
|
|
while(p != nullptr){
|
|
if(p->outVexID == vexID){
|
|
AMLArc *temp = p->nextOutArc;
|
|
p->nextOutArc = nullptr;
|
|
p = temp;
|
|
}
|
|
else{
|
|
AMLArc *temp = p->nextInArc;
|
|
p->nextInArc = nullptr;
|
|
p = temp;
|
|
}
|
|
}
|
|
outVexList[vexID].firstArc = nullptr;
|
|
for(int i = 0; i < outVexList.size(); i++){
|
|
if(i == vexID) continue;
|
|
AMLArc *dummyHead = new AMLArc(nullptr, i, -1, outVexList[i].firstArc, nullptr);
|
|
AMLArc *preArc = dummyHead;
|
|
AMLArc *nextArc = preArc->nextOutArc;
|
|
while(nextArc != nullptr){
|
|
if(nextArc->inVexID == vexID || nextArc->outVexID == vexID){
|
|
if(preArc->outVexID == i){
|
|
if(nextArc->outVexID == i){
|
|
preArc->nextOutArc = nextArc->nextOutArc;
|
|
nextArc->nextOutArc = nullptr;
|
|
delete nextArc;
|
|
}
|
|
else{
|
|
preArc->nextOutArc = nextArc->nextInArc;
|
|
nextArc->nextInArc = nullptr;
|
|
delete nextArc;
|
|
}
|
|
}
|
|
else{
|
|
if(nextArc->outVexID == i){
|
|
preArc->nextInArc = nextArc->nextOutArc;
|
|
nextArc->nextOutArc = nullptr;
|
|
delete nextArc;
|
|
}
|
|
else{
|
|
preArc->nextInArc = nextArc->nextInArc;
|
|
nextArc->nextInArc = nullptr;
|
|
delete nextArc;
|
|
}
|
|
}
|
|
nextArc = preArc->outVexID == i ? preArc->nextOutArc : preArc->nextInArc;
|
|
continue;
|
|
}
|
|
preArc = nextArc;
|
|
nextArc = preArc->outVexID == i ? preArc->nextOutArc : preArc->nextInArc;
|
|
if(preArc->inVexID > vexID)
|
|
preArc->inVexID = - preArc->inVexID;
|
|
else if(preArc->inVexID < 0)
|
|
preArc->inVexID = - preArc->inVexID;
|
|
if(preArc->outVexID > vexID)
|
|
preArc->outVexID = - preArc->outVexID;
|
|
else if(preArc->outVexID < 0)
|
|
preArc->outVexID = - preArc->outVexID;
|
|
}
|
|
outVexList[i].firstArc = dummyHead->nextOutArc;
|
|
delete dummyHead;
|
|
}
|
|
//Delete vexID
|
|
outVexList.erase(outVexList.begin() + vexID);
|
|
}
|
|
}
|
|
|
|
void AMLGraph::DelArc(MyGraphicsLineItem *garc){
|
|
int sVex = GetIdOf(garc->stVex());
|
|
int eVex = GetIdOf(garc->edVex());
|
|
DelArc(sVex, eVex);
|
|
}
|
|
|
|
void AMLGraph::DelArc(int sVexID, int eVexID){
|
|
if(type == DG){
|
|
AMLArc *dummyHead;
|
|
AMLArc *preArc;
|
|
//Delete sVex -> eVex
|
|
dummyHead = new AMLArc(nullptr, sVexID, -1, outVexList[sVexID].firstArc, nullptr);
|
|
preArc = dummyHead;
|
|
while(preArc->nextOutArc != nullptr){
|
|
if(preArc->nextOutArc->inVexID == eVexID){
|
|
preArc->nextOutArc = preArc->nextOutArc->nextOutArc;
|
|
continue;
|
|
}
|
|
else
|
|
preArc = preArc->nextOutArc;
|
|
}
|
|
outVexList[sVexID].firstArc = dummyHead->nextOutArc;
|
|
delete dummyHead;
|
|
//Delete eVex -> sVex
|
|
dummyHead = new AMLArc(nullptr, -1, eVexID, nullptr, inVexList[eVexID].firstArc);
|
|
preArc = dummyHead;
|
|
while(preArc->nextInArc != nullptr){
|
|
if(preArc->nextInArc->outVexID == sVexID){
|
|
AMLArc *awaitDel = preArc->nextInArc;
|
|
preArc->nextInArc = preArc->nextInArc->nextInArc;
|
|
delete awaitDel;
|
|
continue;
|
|
}
|
|
else
|
|
preArc = preArc->nextInArc;
|
|
}
|
|
inVexList[eVexID].firstArc = dummyHead->nextInArc;
|
|
delete dummyHead;
|
|
}
|
|
else{
|
|
AMLArc *dummyHead;
|
|
AMLArc *preArc;
|
|
AMLArc *nextArc;
|
|
//Delete sVex -> eVex
|
|
dummyHead = new AMLArc(nullptr, sVexID, -1, outVexList[sVexID].firstArc, nullptr);
|
|
preArc = dummyHead;
|
|
nextArc = outVexList[sVexID].firstArc;
|
|
while(nextArc != nullptr){
|
|
if(nextArc->inVexID == eVexID || nextArc->outVexID == eVexID){
|
|
if(preArc->outVexID == sVexID){
|
|
if(nextArc->outVexID == sVexID){
|
|
preArc->nextOutArc = nextArc->nextOutArc;
|
|
nextArc->nextOutArc = nullptr;
|
|
}
|
|
else{
|
|
preArc->nextOutArc = nextArc->nextInArc;
|
|
nextArc->nextInArc = nullptr;
|
|
}
|
|
}
|
|
else{
|
|
if(nextArc->outVexID == sVexID){
|
|
preArc->nextInArc = nextArc->nextOutArc;
|
|
nextArc->nextOutArc = nullptr;
|
|
}
|
|
else{
|
|
preArc->nextInArc = nextArc->nextInArc;
|
|
nextArc->nextInArc = nullptr;
|
|
}
|
|
}
|
|
nextArc = preArc->outVexID == sVexID ? preArc->nextOutArc : preArc->nextInArc;
|
|
continue;
|
|
}
|
|
else{
|
|
preArc = nextArc;
|
|
nextArc = preArc->outVexID == sVexID ? preArc->nextOutArc : preArc->nextInArc;
|
|
}
|
|
}
|
|
outVexList[sVexID].firstArc = dummyHead->nextOutArc;
|
|
delete dummyHead;
|
|
//Delete eVex -> sVex and release arc
|
|
dummyHead = new AMLArc(nullptr, -1, eVexID, nullptr, outVexList[eVexID].firstArc);
|
|
preArc = dummyHead;
|
|
nextArc = outVexList[eVexID].firstArc;
|
|
while(nextArc != nullptr){
|
|
if(nextArc->inVexID == sVexID || nextArc->outVexID == sVexID){
|
|
if(preArc->outVexID == eVexID){
|
|
if(nextArc->outVexID == eVexID){
|
|
preArc->nextOutArc = nextArc->nextOutArc;
|
|
delete nextArc;
|
|
}
|
|
else{
|
|
preArc->nextOutArc = nextArc->nextInArc;
|
|
delete nextArc;
|
|
}
|
|
}
|
|
else{
|
|
if(nextArc->outVexID == eVexID){
|
|
preArc->nextInArc = nextArc->nextOutArc;
|
|
delete nextArc;
|
|
}
|
|
else{
|
|
preArc->nextInArc = nextArc->nextInArc;
|
|
delete nextArc;
|
|
}
|
|
}
|
|
nextArc = preArc->outVexID == eVexID ? preArc->nextOutArc : preArc->nextInArc;
|
|
continue;
|
|
}
|
|
else{
|
|
preArc = nextArc;
|
|
nextArc = preArc->outVexID == eVexID ? preArc->nextOutArc : preArc->nextInArc;
|
|
}
|
|
}
|
|
outVexList[eVexID].firstArc = dummyHead->nextInArc;
|
|
delete dummyHead;
|
|
}
|
|
}
|
|
|
|
int AMLGraph::GetIdOf(MyGraphicsVexItem *gvex){
|
|
int i = 0;
|
|
while(i < outVexList.size() && outVexList[i].info->gVex != gvex)
|
|
i++;
|
|
return i == outVexList.size() ? -1 : i;
|
|
}
|
|
|
|
AMLArc* AMLGraph::FindArc(int strtID, int endID){
|
|
if(strtID < 0 || strtID >= outVexList.size())
|
|
return nullptr;
|
|
AMLArc *p = outVexList[strtID].firstArc;
|
|
while(p != nullptr){
|
|
if(p->outVexID == endID || p->inVexID == endID)
|
|
return p;
|
|
p = p->outVexID == strtID ? p->nextOutArc : p->nextInArc;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
void AMLGraph::SetWeight(MyGraphicsLineItem *garc, int weight){
|
|
int strtVex = GetIdOf(garc->stVex());
|
|
int endVex = GetIdOf(garc->edVex());
|
|
AMLArc *p = outVexList[strtVex].firstArc;
|
|
while(p != nullptr){
|
|
if(p->inVexID == endVex || p->outVexID == endVex){
|
|
p->weight = weight;
|
|
p->gArc->setText(QString::asprintf("%d", weight));
|
|
}
|
|
p = p->inVexID == strtVex ? p->nextInArc : p->nextOutArc;
|
|
}
|
|
if(type == DG){
|
|
p = inVexList[endVex].firstArc;
|
|
while(p != nullptr){
|
|
if(p->inVexID == strtVex || p->outVexID == strtVex){
|
|
p->weight = weight;
|
|
p->gArc->setText(QString::asprintf("%d", weight));
|
|
}
|
|
p = p->inVexID == endVex ? p->nextInArc : p->nextOutArc;
|
|
}
|
|
}
|
|
}
|
|
|
|
void AMLGraph::ConvertType(int _type){
|
|
if(_type == type) return;
|
|
type = _type;
|
|
if(type == UDG){
|
|
for(int i = 0; i < inVexList.size(); i++){
|
|
AMLArc *p = inVexList[i].firstArc;
|
|
while(p != nullptr && p->nextInArc != nullptr){
|
|
p->gArc->setDirection(false);
|
|
p = p->nextInArc;
|
|
}
|
|
AMLArc *temp = outVexList[i].firstArc;
|
|
if(p){
|
|
outVexList[i].firstArc = inVexList[i].firstArc;
|
|
p->nextInArc = temp;
|
|
}
|
|
while(temp != nullptr){
|
|
temp->gArc->setDirection(false);
|
|
temp = temp->nextOutArc;
|
|
}
|
|
}
|
|
}
|
|
else{
|
|
inVexList.clear();
|
|
inVexList.assign(outVexList.begin(), outVexList.end());
|
|
for(int i = 0; i < inVexList.size(); i++)
|
|
inVexList[i].firstArc = nullptr;
|
|
for(int i = 0; i < outVexList.size(); i++){
|
|
AMLArc *dummyHead = new AMLArc(nullptr, i, -1, outVexList[i].firstArc, nullptr);
|
|
AMLArc *pre = dummyHead;
|
|
AMLArc *next = outVexList[i].firstArc;
|
|
while(next != nullptr){
|
|
next->gArc->setDirection(true);
|
|
if(next->outVexID != i){
|
|
//A reversed edge
|
|
pre->nextOutArc = next->nextInArc;
|
|
AMLArc *temp = inVexList[next->inVexID].firstArc;
|
|
inVexList[next->inVexID].firstArc = next;
|
|
next->nextInArc = temp;
|
|
next = pre->nextOutArc;
|
|
continue;
|
|
}
|
|
pre = next;
|
|
next = pre->nextOutArc;
|
|
}
|
|
outVexList[i].firstArc = dummyHead->nextOutArc;
|
|
delete dummyHead;
|
|
}
|
|
}
|
|
}
|
|
|
|
void AMLGraph::ClearVisit(){
|
|
for(int i = 0; i < outVexList.size(); i++){
|
|
outVexList[i].visited = false;
|
|
outVexList[i].info->gVex->visit(false);
|
|
}
|
|
if(type == DG)
|
|
for(int i = 0; i < inVexList.size(); i++)
|
|
inVexList[i].visited = false;
|
|
}
|
|
|
|
void AMLGraph::ResetDistance(){
|
|
for(int i = 0; i < outVexList.size(); i++){
|
|
outVexList[i].info->strtVexInfo = nullptr;
|
|
outVexList[i].info->distance = VexInfo::INF;
|
|
outVexList[i].info->preVexID = -1;
|
|
outVexList[i].info->gVex->access("", false);
|
|
}
|
|
if(type == DG)
|
|
for(int i = 0; i < outVexList.size(); i++){
|
|
inVexList[i].info->strtVexInfo = nullptr;
|
|
inVexList[i].info->distance = VexInfo::INF;
|
|
inVexList[i].info->preVexID = -1;
|
|
}
|
|
}
|
|
|
|
void AMLGraph::DFS(int strtID){
|
|
if(strtID == -1)
|
|
return;
|
|
vector<int> awaitVexList;
|
|
vector<AMLArc*>awaitArcList;
|
|
awaitVexList.push_back(strtID);
|
|
while(awaitVexList.size() > 0){
|
|
int nextVex = awaitVexList.back();
|
|
AMLArc *nextArc = awaitArcList.size() > 0 ? awaitArcList.back() : nullptr;
|
|
awaitVexList.pop_back();
|
|
if(nextArc)
|
|
awaitArcList.pop_back();
|
|
for(AMLArc *p = outVexList[nextVex].firstArc; p != nullptr; p = p->outVexID == strtID ? p->nextOutArc : p->nextInArc){
|
|
int endID = p->outVexID == nextVex ? p->inVexID : p->outVexID;
|
|
if(outVexList[endID].visited == false){
|
|
awaitVexList.push_back(endID);
|
|
awaitArcList.push_back(p);
|
|
if(type == UDG && GetIdOf(p->gArc->edVex()) != endID)
|
|
p->gArc->reverseDirection();
|
|
}
|
|
}
|
|
if(nextArc && !outVexList[nextVex].visited)
|
|
nextArc->visit();
|
|
outVexList[nextVex].visit();
|
|
}
|
|
}
|
|
|
|
void AMLGraph::BFS(int strtID){
|
|
if(strtID == -1)
|
|
return;
|
|
vector<int> awaitVexList;
|
|
vector<AMLArc*> awaitArcList;
|
|
awaitVexList.push_back(strtID);
|
|
while(awaitVexList.size() > 0){
|
|
int nextVex = awaitVexList[0];
|
|
AMLArc *nextArc = awaitArcList.size() > 0 ? awaitArcList[0] : nullptr;
|
|
awaitVexList.erase(awaitVexList.begin());
|
|
if(nextArc)
|
|
awaitArcList.erase(awaitArcList.begin());
|
|
for(AMLArc *p = outVexList[nextVex].firstArc; p != nullptr; p = p->outVexID == strtID ? p->nextOutArc : p->nextInArc){
|
|
int endID = p->outVexID == nextVex ? p->inVexID : p->outVexID;
|
|
if(outVexList[endID].visited == false){
|
|
awaitVexList.push_back(endID);
|
|
awaitArcList.push_back(p);
|
|
if(type == UDG && GetIdOf(p->gArc->edVex()) != endID)
|
|
p->gArc->reverseDirection();
|
|
}
|
|
}
|
|
if(nextArc && !outVexList[nextVex].visited)
|
|
nextArc->visit();
|
|
outVexList[nextVex].visit();
|
|
}
|
|
}
|
|
|
|
void AMLGraph::Dijkstra(int strtID){
|
|
//Clear previous result
|
|
ClearVisit();
|
|
ResetDistance();
|
|
//Set start vex info to all vertexes
|
|
for(int i = 0; i < outVexList.size(); i++)
|
|
outVexList[i].info->strtVexInfo = outVexList[strtID].info;
|
|
//Start dijkstra
|
|
outVexList[strtID].info->distance = 0;
|
|
outVexList[strtID].access("strt");
|
|
while(true){
|
|
//Find next
|
|
int minVexID = -1;
|
|
for(int i = 0; i < outVexList.size(); i++){
|
|
if(outVexList[i].visited || outVexList[i].info->distance == VexInfo::INF)
|
|
continue;
|
|
if(minVexID == -1)
|
|
minVexID = i;
|
|
else if(outVexList[i].info->distance < outVexList[minVexID].info->distance)
|
|
minVexID = i;
|
|
}
|
|
if(minVexID == -1)
|
|
break;
|
|
//Set visit to edge and vex
|
|
AMLArc *edge = FindArc(outVexList[minVexID].info->preVexID, minVexID);
|
|
if(edge){
|
|
if(type == UDG && GetIdOf(edge->gArc->edVex()) != minVexID)
|
|
edge->gArc->reverseDirection();
|
|
edge->visit();
|
|
}
|
|
outVexList[minVexID].visit();
|
|
//Find adjacent
|
|
for(AMLArc *p = outVexList[minVexID].firstArc; p != nullptr; p = p->outVexID == strtID ? p->nextOutArc : p->nextInArc){
|
|
int endID = p->outVexID == minVexID ? p->inVexID : p->outVexID;
|
|
if(!outVexList[endID].visited){
|
|
if(GetIdOf(p->gArc->edVex()) != endID)
|
|
p->gArc->reverseDirection();
|
|
p->access();
|
|
if(outVexList[endID].info->distance == VexInfo::INF ||
|
|
outVexList[endID].info->distance > outVexList[minVexID].info->distance + p->weight){
|
|
outVexList[endID].info->preVexID = minVexID;
|
|
outVexList[endID].info->distance = outVexList[minVexID].info->distance + p->weight;
|
|
outVexList[endID].access(QString::asprintf("%d", outVexList[endID].info->distance));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
ALGraph* AMLGraph::ConvertToAL(){
|
|
ALGraph *converted = new ALGraph(type);
|
|
for(int i = 0; i < outVexList.size(); i++)
|
|
converted->AddVex(outVexList[i].info);
|
|
for(int i = 0; i < outVexList.size(); i++){
|
|
AMLArc *p = outVexList[i].firstArc;
|
|
while(p != nullptr){
|
|
if(p->outVexID == i)
|
|
converted->AddArc(p->gArc);
|
|
p = p->outVexID == i ? p->nextOutArc : p->nextInArc;
|
|
}
|
|
}
|
|
return converted;
|
|
}
|