diff --git a/ErmlinEA/Dijkstra/include/DHeap.h b/ErmlinEA/Dijkstra/include/DHeap.h new file mode 100644 index 000000000..d320cf051 --- /dev/null +++ b/ErmlinEA/Dijkstra/include/DHeap.h @@ -0,0 +1,35 @@ +#pragma once +#include +#include +#include "Graph.h" + +#define maxSize 1000 +typedef int dataType; + +class Data { +public: + float priorities; +}; + +class DHeap { +protected: + Data **keys; + int d; + int lastIdx; +public: + DHeap(int d); + DHeap(const DHeap &heap); + ~DHeap(); + void add(Data *&key); + void addSet(Data **key, int num); + Data* erase(); + Data* erase(int i); + void transposition(int i, int j); + void surfacing(int i); + void immersion(int i); + void spudding(); + int isFull(); + int isEmpty(); +private: + int minChild(int i); +}; \ No newline at end of file diff --git a/ErmlinEA/Dijkstra/include/Deijkstra.h b/ErmlinEA/Dijkstra/include/Deijkstra.h new file mode 100644 index 000000000..b0475db4c --- /dev/null +++ b/ErmlinEA/Dijkstra/include/Deijkstra.h @@ -0,0 +1,16 @@ +#pragma once +#include "Graph.h" +#include "DHeap.h" +#include "priorityqueue.h" +#include + +class DataFloat : public Data { +public: + DataFloat(int v, float dist); + int v; +}; + +class Dijkstra { +public: + static void dijkstra(Graph *&graph, int s, float *&distance, int *&up); +}; \ No newline at end of file diff --git a/ErmlinEA/Dijkstra/include/Graph.h b/ErmlinEA/Dijkstra/include/Graph.h new file mode 100644 index 000000000..d33676452 --- /dev/null +++ b/ErmlinEA/Dijkstra/include/Graph.h @@ -0,0 +1,52 @@ +#pragma once + +#include +#include +#include + +#define maxSizeVertices 1000 + + +class WeightedEdge +{ +public: + int n; + int k; + float weight; + WeightedEdge(int n, int k, float weight); +}; + +class Graph +{ +private: + int ver; + int reb; + int current_reb; + int current_ver; + WeightedEdge** edges; + int* vertices; + void GenerateVertices(int &N, int &K); + float GenerateWeight(float minRange, float maxRange); + void Cleaner(); + int SearchEdge(int n, int k); + bool SearchVershinu(int ver); + void AddVershini(int n, int k); +public: + // Конструкторы + Graph(int n); + Graph(int n, int m); + ~Graph(); + void GenerateGraph(float minRange, float maxRange); + void AddEdge(int N, int K, float weight); + void RemoveEdge(int N, int K); + int GetVerticesNum(); + int GetEdgeSize(); + int GetRealSize(); + bool IsConnectivity(); + WeightedEdge** GetEdgeSet(); + WeightedEdge* GetEdge(int j); + float GetWeight(int N, int K); + void PrintList(); +}; + + diff --git a/ErmlinEA/Dijkstra/include/priorityqueue.h b/ErmlinEA/Dijkstra/include/priorityqueue.h new file mode 100644 index 000000000..b04c76423 --- /dev/null +++ b/ErmlinEA/Dijkstra/include/priorityqueue.h @@ -0,0 +1,42 @@ +#pragma once + +#include "DHeap.h" + +enum QueueID { + HEAP = 0, +}; + +class PriorityQueue { +public: + PriorityQueue() {}; + virtual void push(Data *&key) = 0; + virtual Data* pop() = 0; + virtual void refresh() = 0; + virtual int isFull() = 0; + virtual int isEmpty() = 0; +}; + +class PriorityQueueHeap : public PriorityQueue { +protected: + DHeap *heap; +public: + PriorityQueueHeap(int d = 4); + PriorityQueueHeap(const PriorityQueueHeap &queue); + PriorityQueueHeap(Data **keys, int num, int d = 4); + ~PriorityQueueHeap(); + virtual void push(Data *&key); + virtual Data* pop(); + virtual void refresh(); + virtual int isFull(); + virtual int isEmpty(); +}; + +class QueueFactory { +public: + static PriorityQueue* createQueue(QueueID qid) + { + PriorityQueue *queue; + queue = new PriorityQueueHeap(); + return queue; + } +}; \ No newline at end of file diff --git a/ErmlinEA/Dijkstra/samples/main.cpp b/ErmlinEA/Dijkstra/samples/main.cpp new file mode 100644 index 000000000..e9cb56efa --- /dev/null +++ b/ErmlinEA/Dijkstra/samples/main.cpp @@ -0,0 +1,122 @@ +#include "..//include/Deijkstra.h" +#include +#include +#include "locale.h" + +using namespace std; + +int main() +{ + setlocale(LC_ALL, "Rus"); + Graph* graph; + int n, m, s, nmenu; + try + { + cout << "Введите количество вершин:" << endl; + cin >> n; + cout << "Введите количество ребер:" << endl; + cin >> m; + graph = new Graph(n, m); + } + catch (...) + { + return -1; + } + cout << "1. Случайная генерация" << endl; + cout << "2. Ручной ввод" << endl; + cin >> nmenu; + switch (nmenu) + { + case 1: { + try + { + int minRange; + int maxRange; + cout << "Введите минимальное значение веса ребра:" << endl; + cin >> minRange; + cout << "Введите максимальное значение веса ребра:" << endl; + cin >> maxRange; + graph->GenerateGraph(minRange, maxRange); + } + catch (...) { + return -1; + } + break; + } + case 2: { + int nac_ver, kon_ver; + float weight; + try + { + for (int i = 0; i < m; i++) + { + cout << "Введите начальную вершину:" << endl; + cin >> nac_ver; + cout << "Введите конечную вершину:" << endl; + cin >> kon_ver; + cout << "Введите вес:" << endl; + cin >> weight; + graph->AddEdge(nac_ver, kon_ver, weight); + } + } + catch (...) + { + return -1; + } + break; + } + } + if (!graph->IsConnectivity()) + { + return -3; + } + cout << "Введите начальную вершину для алгоритма Дейкстры:" << endl; + cin >> s; + graph->PrintList(); + cout << endl; + float *dist; + int *up; + try { + Dijkstra::dijkstra(graph, s, dist, up); + } + catch (...) { + return -2; + } + cout << n << ' ' << m << endl; + cout << s << endl; + m = graph->GetRealSize(); + WeightedEdge* edge; + cout << "Matrix edges" << endl; + for (int j = 0; j < m; j++) + { + edge = graph->GetEdge(j); + cout << edge->n << ' ' << edge->k << ' ' << edge->weight << endl; + } + cout << "Расстояние от заданной вершины до i-ой вершины:" << endl; + for (int i = 0; i < n; i++) + { + if (dist[i] == FLT_MAX) + { + return -4; + } + cout << s << " -> " << i << " Дистанция = " << dist[i] << endl; + } + cout << endl << "Пути всех вершин:" << endl; + for (int i = 0; i < n; i++) + { + int temp = i; + cout << temp << " <- "; + while (up[temp] != s) + { + cout << up[temp] << " <- "; + temp = up[temp]; + } + cout << s << endl; + } + delete graph; + delete[]dist; + delete[]up; + cout << endl; + system("pause"); + return 0; +} \ No newline at end of file diff --git a/ErmlinEA/Dijkstra/sln/.vs/Dijkstra/v14/.suo b/ErmlinEA/Dijkstra/sln/.vs/Dijkstra/v14/.suo new file mode 100644 index 000000000..bf30e4295 Binary files /dev/null and b/ErmlinEA/Dijkstra/sln/.vs/Dijkstra/v14/.suo differ diff --git a/ErmlinEA/Dijkstra/sln/Debug/Dijkstra.ilk b/ErmlinEA/Dijkstra/sln/Debug/Dijkstra.ilk new file mode 100644 index 000000000..b99376406 Binary files /dev/null and b/ErmlinEA/Dijkstra/sln/Debug/Dijkstra.ilk differ diff --git a/ErmlinEA/Dijkstra/sln/Debug/Dijkstra.log b/ErmlinEA/Dijkstra/sln/Debug/Dijkstra.log new file mode 100644 index 000000000..2e6cc10bf --- /dev/null +++ b/ErmlinEA/Dijkstra/sln/Debug/Dijkstra.log @@ -0,0 +1,6 @@ +п»ї Dijkstra.cpp + main.cpp +..\samples\main.cpp(39): warning C4244: аргумент: преобразование "int" РІ "float", возможна потеря данных + Создание РєРѕРґР°... + Dijkstra.vcxproj -> C:\Users\Sort\Desktop\Ermiln\ErmlinEA\Dijkstra\sln\Debug\Dijkstra.exe + Dijkstra.vcxproj -> C:\Users\Sort\Desktop\Ermiln\ErmlinEA\Dijkstra\sln\Debug\Dijkstra.pdb (Full PDB) diff --git a/ErmlinEA/Dijkstra/sln/Debug/Dijkstra.pdb b/ErmlinEA/Dijkstra/sln/Debug/Dijkstra.pdb new file mode 100644 index 000000000..b1c548197 Binary files /dev/null and b/ErmlinEA/Dijkstra/sln/Debug/Dijkstra.pdb differ diff --git a/ErmlinEA/Dijkstra/sln/Debug/Dijkstra.tlog/CL.command.1.tlog b/ErmlinEA/Dijkstra/sln/Debug/Dijkstra.tlog/CL.command.1.tlog new file mode 100644 index 000000000..9fac5c375 Binary files /dev/null and b/ErmlinEA/Dijkstra/sln/Debug/Dijkstra.tlog/CL.command.1.tlog differ diff --git a/ErmlinEA/Dijkstra/sln/Debug/Dijkstra.tlog/CL.read.1.tlog b/ErmlinEA/Dijkstra/sln/Debug/Dijkstra.tlog/CL.read.1.tlog new file mode 100644 index 000000000..1a56673c3 Binary files /dev/null and b/ErmlinEA/Dijkstra/sln/Debug/Dijkstra.tlog/CL.read.1.tlog differ diff --git a/ErmlinEA/Dijkstra/sln/Debug/Dijkstra.tlog/CL.write.1.tlog b/ErmlinEA/Dijkstra/sln/Debug/Dijkstra.tlog/CL.write.1.tlog new file mode 100644 index 000000000..a3b88834c Binary files /dev/null and b/ErmlinEA/Dijkstra/sln/Debug/Dijkstra.tlog/CL.write.1.tlog differ diff --git a/ErmlinEA/Dijkstra/sln/Debug/Dijkstra.tlog/Dijkstra.lastbuildstate b/ErmlinEA/Dijkstra/sln/Debug/Dijkstra.tlog/Dijkstra.lastbuildstate new file mode 100644 index 000000000..733444397 --- /dev/null +++ b/ErmlinEA/Dijkstra/sln/Debug/Dijkstra.tlog/Dijkstra.lastbuildstate @@ -0,0 +1,2 @@ +#TargetFrameworkVersion=v4.0:PlatformToolSet=v140:EnableManagedIncrementalBuild=false:VCToolArchitecture=Native32Bit:WindowsTargetPlatformVersion=8.1 +Debug|Win32|C:\Users\Sort\Desktop\Ermiln\ErmlinEA\Dijkstra\sln\| diff --git a/ErmlinEA/Dijkstra/sln/Debug/Dijkstra.tlog/link.command.1.tlog b/ErmlinEA/Dijkstra/sln/Debug/Dijkstra.tlog/link.command.1.tlog new file mode 100644 index 000000000..b6f9444f2 Binary files /dev/null and b/ErmlinEA/Dijkstra/sln/Debug/Dijkstra.tlog/link.command.1.tlog differ diff --git a/ErmlinEA/Dijkstra/sln/Debug/Dijkstra.tlog/link.read.1.tlog b/ErmlinEA/Dijkstra/sln/Debug/Dijkstra.tlog/link.read.1.tlog new file mode 100644 index 000000000..55c00e5ca Binary files /dev/null and b/ErmlinEA/Dijkstra/sln/Debug/Dijkstra.tlog/link.read.1.tlog differ diff --git a/ErmlinEA/Dijkstra/sln/Debug/Dijkstra.tlog/link.write.1.tlog b/ErmlinEA/Dijkstra/sln/Debug/Dijkstra.tlog/link.write.1.tlog new file mode 100644 index 000000000..91842743f Binary files /dev/null and b/ErmlinEA/Dijkstra/sln/Debug/Dijkstra.tlog/link.write.1.tlog differ diff --git a/ErmlinEA/Dijkstra/sln/Debug/vc140.idb b/ErmlinEA/Dijkstra/sln/Debug/vc140.idb new file mode 100644 index 000000000..6d0276653 Binary files /dev/null and b/ErmlinEA/Dijkstra/sln/Debug/vc140.idb differ diff --git a/ErmlinEA/Dijkstra/sln/Debug/vc140.pdb b/ErmlinEA/Dijkstra/sln/Debug/vc140.pdb new file mode 100644 index 000000000..da7ab544f Binary files /dev/null and b/ErmlinEA/Dijkstra/sln/Debug/vc140.pdb differ diff --git a/ErmlinEA/Dijkstra/sln/Dijkstra.VC.db b/ErmlinEA/Dijkstra/sln/Dijkstra.VC.db new file mode 100644 index 000000000..c452d67f1 Binary files /dev/null and b/ErmlinEA/Dijkstra/sln/Dijkstra.VC.db differ diff --git a/ErmlinEA/Dijkstra/sln/Dijkstra.sln b/ErmlinEA/Dijkstra/sln/Dijkstra.sln new file mode 100644 index 000000000..af3322b8f --- /dev/null +++ b/ErmlinEA/Dijkstra/sln/Dijkstra.sln @@ -0,0 +1,28 @@ +п»ї +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 14 +VisualStudioVersion = 14.0.25420.1 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Dijkstra", "Dijkstra.vcxproj", "{CEE34450-5827-4CA3-AEA4-BD61959C08D7}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|x64 = Debug|x64 + Debug|x86 = Debug|x86 + Release|x64 = Release|x64 + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {CEE34450-5827-4CA3-AEA4-BD61959C08D7}.Debug|x64.ActiveCfg = Debug|x64 + {CEE34450-5827-4CA3-AEA4-BD61959C08D7}.Debug|x64.Build.0 = Debug|x64 + {CEE34450-5827-4CA3-AEA4-BD61959C08D7}.Debug|x86.ActiveCfg = Debug|Win32 + {CEE34450-5827-4CA3-AEA4-BD61959C08D7}.Debug|x86.Build.0 = Debug|Win32 + {CEE34450-5827-4CA3-AEA4-BD61959C08D7}.Release|x64.ActiveCfg = Release|x64 + {CEE34450-5827-4CA3-AEA4-BD61959C08D7}.Release|x64.Build.0 = Release|x64 + {CEE34450-5827-4CA3-AEA4-BD61959C08D7}.Release|x86.ActiveCfg = Release|Win32 + {CEE34450-5827-4CA3-AEA4-BD61959C08D7}.Release|x86.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/ErmlinEA/Dijkstra/sln/Dijkstra.vcxproj b/ErmlinEA/Dijkstra/sln/Dijkstra.vcxproj new file mode 100644 index 000000000..8928b6bdf --- /dev/null +++ b/ErmlinEA/Dijkstra/sln/Dijkstra.vcxproj @@ -0,0 +1,115 @@ +п»ї + + + + Debug + Win32 + + + Release + Win32 + + + Debug + x64 + + + Release + x64 + + + + {CEE34450-5827-4CA3-AEA4-BD61959C08D7} + Win32Proj + + + + Application + true + v140 + + + Application + false + v140 + + + Application + true + v140 + + + Application + false + v140 + + + + + + + + + + + + + + + + + + + + + true + + + true + + + + WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) + MultiThreadedDebugDLL + Level3 + ProgramDatabase + Disabled + + + MachineX86 + true + Console + + + + + WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + MultiThreadedDLL + Level3 + ProgramDatabase + + + MachineX86 + true + Console + true + true + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/ErmlinEA/Dijkstra/sln/Dijkstra.vcxproj.filters b/ErmlinEA/Dijkstra/sln/Dijkstra.vcxproj.filters new file mode 100644 index 000000000..6dee69b46 --- /dev/null +++ b/ErmlinEA/Dijkstra/sln/Dijkstra.vcxproj.filters @@ -0,0 +1,48 @@ +п»ї + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hh;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav + + + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + \ No newline at end of file diff --git a/ErmlinEA/Dijkstra/src/DHeap.cpp b/ErmlinEA/Dijkstra/src/DHeap.cpp new file mode 100644 index 000000000..4efe43fa3 --- /dev/null +++ b/ErmlinEA/Dijkstra/src/DHeap.cpp @@ -0,0 +1,146 @@ +#include "..//include/DHeap.h" + +DHeap::DHeap(int d) +{ + if (d <= 0) + throw "DAryHeap: Invalid d"; + this->d = d; + lastIdx = -1; + keys = new Data*[maxSize]; +} + +DHeap::DHeap(const DHeap &heap) +{ + this->d = heap.d; + keys = new Data*[maxSize]; + for (int i = 0; i <= heap.lastIdx; i++) + keys[i] = heap.keys[i]; + this->lastIdx = heap.lastIdx; +} + +DHeap::~DHeap() +{ + delete[] keys; +} + +void DHeap::add(Data *&key) +{ + if (isFull()) + throw "DAryHeap: No memory"; + lastIdx++; + keys[lastIdx] = key; + surfacing(lastIdx); +} + +void DHeap::addSet(Data **key, int num) +{ + if (lastIdx + num >= maxSize) + throw "DAryHeap: Too large set!"; + for (int i = lastIdx + 1; i < lastIdx + num + 1; i++) + { + keys[i] = key[i - lastIdx - 1]; + } + lastIdx += num; + spudding(); +} + +Data* DHeap::erase() +{ + if (isEmpty()) + throw "DAryHeap: No data!"; + Data* key = keys[lastIdx]; + lastIdx--; + return key; +} + +Data* DHeap::erase(int i) +{ + if (isEmpty()) + throw "DAryHeap: No data!"; + if ((i < 0) || (i > lastIdx)) + throw "DAryHeap: Invalid index"; + + Data* key = keys[i]; + if (i == lastIdx) + { + lastIdx--; + return key; + } + transposition(i, lastIdx); + lastIdx--; + immersion(i); + return key; +} + +void DHeap::transposition(int i, int j) +{ + if ((i < 0) || (j < 0) || (i > lastIdx) || (j > lastIdx)) + throw "DAryHeap: Invalid indexes"; + Data* tmp = keys[i]; + keys[i] = keys[j]; + keys[j] = tmp; +} + +void DHeap::surfacing(int i) +{ + if ((i < 0) || (i > lastIdx)) + throw "DAryHeap: Invalid index"; + + int p = (i - 1) / d; + while (i > 0) { + if (keys[p]->priorities < keys[i]->priorities) + break; + transposition(p, i); + i = p; + p = (i - 1) / d; + } +} + +void DHeap::immersion(int i) +{ + if ((i < 0) || (i > lastIdx)) + throw "DAryHeap: Invalid index"; + + int c = minChild(i); + while ((c != -1) && (keys[c]->priorities < keys[i]->priorities)) { + transposition(i, c); + i = c; + c = minChild(i); + } +} + +void DHeap::spudding() +{ + for (int i = lastIdx; i >= 0; i--) + immersion(i); +} + +int DHeap::isFull() +{ + return lastIdx >= maxSize - 1; +} + +int DHeap::isEmpty() +{ + return lastIdx == -1; +} + +int DHeap::minChild(int i) +{ + int f = i*d + 1; + if (f > lastIdx) + return -1; + + int l = std::min(i*d + d, lastIdx); + int c; + + Data* minKey = keys[f]; + c = f; + for (int k = f + 1; k <= l; k++) { + if (minKey->priorities > keys[k]->priorities) { + minKey = keys[k]; + c = k; + } + } + return c; +} \ No newline at end of file diff --git a/ErmlinEA/Dijkstra/src/Dijkstra.cpp b/ErmlinEA/Dijkstra/src/Dijkstra.cpp new file mode 100644 index 000000000..6fc47d88e --- /dev/null +++ b/ErmlinEA/Dijkstra/src/Dijkstra.cpp @@ -0,0 +1,68 @@ +#include "..//include/Deijkstra.h" + +DataFloat::DataFloat(int v, float dist) +{ + this->v = v; + priorities = dist; +} + +void Dijkstra::dijkstra(Graph *&graph, int s, float *&distance, int *&up) +{ + int n = graph->GetVerticesNum(); + int m = graph->GetRealSize(); + if ((s < 0) || (s >= n)) + { + throw "Dijkstra: Invalid start vertex!"; + } + Data** dist = new Data*[n]; + up = new int[n]; + PriorityQueue *queue = new PriorityQueueHeap(); + for (int i = 0; i < n; i++) + { + up[i] = i; + dist[i] = new DataFloat(i, FLT_MAX); + if (i == s) + { + dist[s]->priorities = 0; + } + queue->push(dist[i]); + } + WeightedEdge** edges = graph->GetEdgeSet(); + while (!queue->isEmpty()) + { + int vConsidered = ((DataFloat*)queue->pop())->v; + float delta; + for (int i = 0; i < m; i++) + { + int vIncident = -1; + if (edges[i]->k == vConsidered) + { + vIncident = edges[i]->n; + } + if (edges[i]->n == vConsidered) + { + vIncident = edges[i]->k; + } + if (vIncident == -1) continue; + float way = dist[vConsidered]->priorities + graph->GetWeight(vConsidered, vIncident); + delta = dist[vIncident]->priorities - way; + if (delta > 0) + { + dist[vIncident]->priorities = way; + up[vIncident] = vConsidered; + queue->refresh(); + } + } + } + distance = new float[n]; + for (int i = 0; i < n; i++) + { + distance[i] = dist[i]->priorities; + } + for (int i = 0; i < n; i++) + { + delete dist[i]; + } + delete[]dist; + delete queue; +} \ No newline at end of file diff --git a/ErmlinEA/Dijkstra/src/graph.cpp b/ErmlinEA/Dijkstra/src/graph.cpp new file mode 100644 index 000000000..df538520f --- /dev/null +++ b/ErmlinEA/Dijkstra/src/graph.cpp @@ -0,0 +1,253 @@ +#ifndef GRAPH_H +#define GRAPH_H + +#include "..//include/Graph.h" + +WeightedEdge::WeightedEdge(int n, int k, float weight) +{ + this->k = k; + this->n = n; + this->weight = weight; +} + +Graph::Graph(int ver) +{ + if ((ver < 0) || (ver > maxSizeVertices)) + { + throw "Err"; + } + else + { + this->ver = ver; + } + this->reb = ver * (ver - 1) / 2; + current_reb = 0; + vertices = new int[ver]; + edges = new WeightedEdge*[reb]; +} + +Graph::Graph(int ver, int reb) +{ + if ((ver < 0) || (ver > maxSizeVertices)) + { + throw "Err"; + } + else + { + this->ver = ver; + } + if ((reb < 0) || (reb > ver*(ver - 1) / 2) || (reb < ver - 1)) + { + throw "Err"; + } + else + { + this->reb = reb; + } + current_reb = 0; + current_ver = 0; + vertices = new int[ver]; + for (int i = 0; i < ver - 1; i++) + { + vertices[i] = -1; + } + edges = new WeightedEdge*[reb]; +} + + +Graph::~Graph() +{ + Cleaner(); + delete[] edges; + delete[] vertices; +} + + +int Graph::SearchEdge(int n, int k) +{ + for (int i = 0; i < current_reb; i++) + { + if ((edges[i]->k == k) && (edges[i]->n == n) || (edges[i]->n == k) && (edges[i]->k == n)) + { + return i; + } + } + return -1; +} +bool Graph::SearchVershinu(int ver) +{ + for (int i = 0; i < current_reb; i++) + { + if ((edges[i]->n == ver) || edges[i]->k == ver) + { + return true; + } + } + return false; +} +void Graph::AddVershini(int n, int k) +{ + if (!SearchVershinu(n)) + { + vertices[current_ver] = n; + current_ver++; + } + if (!SearchVershinu(k)) + { + vertices[current_ver] = k; + current_ver++; + } +} + +void Graph::GenerateVertices(int & nver, int & kver) +{ + do { + nver = rand() % ver; + kver = rand() % ver; + } while ((nver == kver) || (SearchEdge(nver, kver) != -1)); +} + +float Graph::GenerateWeight(float minRange, float maxRange) +{ + double d = minRange; + double c = (double)(maxRange - minRange) / RAND_MAX; + double result = c * rand() + d; + return result; +} + +void Graph::Cleaner() +{ + for (int i = 0; i < current_reb; i++) + { + delete edges[i]; + } +} + +void Graph::GenerateGraph(float minRange, float maxRange) +{ + int nver; + int kver; + float weight; + if (minRange > maxRange) + { + throw "Err"; + } + if (current_ver)// Если граф не пуст + { + Cleaner(); + current_ver = 0; + } + srand(time(NULL)); + for (int i = 0; i < reb; i++) + { + GenerateVertices(nver, kver); + weight = GenerateWeight(minRange, maxRange); + edges[i] = new WeightedEdge(nver, kver, weight); + AddVershini(nver, kver); + current_reb++; + } +} + + +void Graph::AddEdge(int nver, int kver, float weight) +{ + if (current_reb == reb) + { + throw "Err"; + } + if (nver == kver) + { + throw "Err"; + } + if (SearchEdge(nver, kver) != -1) + { + throw "Err"; + } + edges[current_reb] = new WeightedEdge(nver, kver, weight); + AddVershini(nver, kver); + current_reb++; +} + +void Graph::RemoveEdge(int nver, int kver) +{ + int j = SearchEdge(nver, kver); + if (j == -1) + { + throw "Err"; + } + delete edges[j]; + edges[j] = edges[current_reb - 1]; + current_reb--; +} + +int Graph::GetVerticesNum() +{ + return ver; +} + +int Graph::GetEdgeSize() +{ + return reb; +} + +int Graph::GetRealSize() +{ + return current_reb; +} +bool Graph::IsConnectivity() +{ + for (int i = 0; i < ver; i++) + { + if (vertices[i] < 0) + { + return false; + } + } + return true; +} + +WeightedEdge** Graph::GetEdgeSet() +{ + if (current_reb == 0) + { + return 0; + } + return edges; +} + +WeightedEdge* Graph::GetEdge(int j) +{ + return edges[j]; +} + +float Graph::GetWeight(int nver, int kver) +{ + int j = SearchEdge(nver, kver); + if (j == -1) + { + throw "Err"; + } + return edges[j]->weight; +} + +void Graph::PrintList() +{ + using namespace std; + for (int i = 0; i < ver; i++) + { + cout << i << " : "; + for (int j = 0; j < current_reb; j++) + { + if (edges[j]->n == i) + { + cout << edges[j]->k << '(' << edges[j]->weight << ')' << ", "; + } + if (edges[j]->k == i) + { + cout << edges[j]->n << '(' << edges[j]->weight << ')' << ", "; + } + } + cout << endl; + } +} +#endif \ No newline at end of file diff --git a/ErmlinEA/Dijkstra/src/priorityqueue.cpp b/ErmlinEA/Dijkstra/src/priorityqueue.cpp new file mode 100644 index 000000000..2f7884fe9 --- /dev/null +++ b/ErmlinEA/Dijkstra/src/priorityqueue.cpp @@ -0,0 +1,47 @@ +#include "..//include/priorityqueue.h" + +PriorityQueueHeap::PriorityQueueHeap(int d) +{ + heap = new DHeap(d); +} + +PriorityQueueHeap::PriorityQueueHeap(const PriorityQueueHeap &queue) +{ + this->heap = new DHeap(*(queue.heap)); +} + +PriorityQueueHeap::PriorityQueueHeap(Data **keys, int num, int d) +{ + heap = new DHeap(d); + heap->addSet(keys, num); +} + +PriorityQueueHeap::~PriorityQueueHeap() +{ + delete heap; +} + +void PriorityQueueHeap::push(Data *&key) +{ + heap->add(key); +} + +Data* PriorityQueueHeap::pop() +{ + return heap->erase(0); +} + +void PriorityQueueHeap::refresh() +{ + heap->spudding(); +} + +int PriorityQueueHeap::isFull() +{ + return heap->isFull(); +} + +int PriorityQueueHeap::isEmpty() +{ + return heap->isEmpty(); +}