soberhofer
/
Algorithmen_Datenstrukturen
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

3.2 solved

This commit is contained in:
Samuel Oberhofer 2022-06-07 23:13:32 +02:00
parent 95ee5f84d1
commit a8af581125
5 changed files with 460 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
Uebung 3/Uebung3_2/Makefile Normal file
View File

@ -0,0 +1,51 @@
# Name of the binary for Development
BINARY = main
# Name of the binary for Release
FINAL = prototyp
# Object files
OBJS = extendedgraph2.o main.o
# Compiler flags
CFLAGS = -Werror -Wall -std=c++17 -fsanitize=address,undefined -g
# Linker flags
LFLAGS = -fsanitize=address,undefined
#Which Compiler to use
COMPILER = c++
# all target: builds all important targets
all: binary
final : ${OBJS}
${COMPILER} ${LFLAGS} -o ${FINAL} ${OBJS}
binary : ${OBJS}
${COMPILER} ${LFLAGS} -o ${BINARY} ${OBJS}
# Links the binary
${BINARY} : ${OBJS}
${COMPILER} ${LFLAGS} -o ${BINARY} ${OBJS}
# Compiles a source-file (any file with file extension .c) into an object-file
#
# "%" is a wildcard which matches every file-name (similar to * in regular expressions)
# Such a rule is called a pattern rule (because it matches a pattern, see https://www.gnu.org/software/make/manual/html_node/Pattern-Rules.html),
# which are a form of so called implicit rules (see https://www.gnu.org/software/make/manual/html_node/Implicit-Rules.html)
# "$@" and "$<" are so called automatic variables (see https://www.gnu.org/software/make/manual/html_node/Automatic-Variables.html)
%.o : %.cpp
${COMPILER} -c ${CFLAGS} -o $@ $<
# Rules can not only be used for compiling a program but also for executing a program
run: ${BINARY}
./${BINARY}
# Delete all build artifacts
clean :
rm -rf ${BINARY} ${OBJS}
# all and clean are a "phony" targets, meaning they are no files
.PHONY : all clean

20
Uebung 3/Uebung3_2/edge.h Normal file
View File

@ -0,0 +1,20 @@
#include <string>
#pragma once
/* -- Struct Edge -- */
class Edge {
private:
std::string m_src; // string source; beginning of the directed connection
std::string m_dest; // string destination; end of the directed connection
int m_weight; // weight
public:
Edge(std::string src, std::string dest, int weight)
: m_src(src), m_dest(dest), m_weight(weight){};
const int &getWeight() const { return this->m_weight; };
void setWeight(int weight) { this->m_weight = weight; };
const std::string &getSrc() const { return this->m_src; };
void setSrc(std::string src) { this->m_src = src; };
const std::string &getDest() const { return this->m_dest; };
void setDest(std::string dest) { this->m_dest = dest; };
};

243
Uebung 3/Uebung3_2/extendedgraph2.cpp Normal file
View File

@ -0,0 +1,243 @@
#include "extendedgraph2.h"
#include <map>
ExtendedGraph::ExtendedGraph() { // Default Constructor
this->vertices =
std::vector<std::string>(0); // Empty Vector for this->vertices
this->adjacencyMatrix.resize(
0, std::vector<int>(0)); // 0x0 Matrix for this->adjacencyMatrix
}
/* --
Constructor with params
-- */
ExtendedGraph::ExtendedGraph(const std::vector<std::string> &vertices,
const std::vector<Edge> &edges) {
this->vertices = vertices; // definition of this->vertex through parameter
// vertices (type: std::vector<std::string>)
this->adjacencyMatrix.resize(
vertices.size(),
std::vector<int>(
this->vertices.size())); // creation of an NxN Matrix, based on the
// size of vertices
for (int i = 0; i < edges.size(); i++) {
insertEdge(edges[i]); // edges are added one by one, utilizing the
// insertEdge()-Function
}
}
/* -- /
Function to insert a vertex into the Graph;
- takes one argument of type std::string that represents a vertex
- returns void
/ -- */
void ExtendedGraph::insertVertex(const std::string &vertex) {
if (this->resolveVertex(vertex) != -1) { /* -- */
std::cerr
<< "Vertex already in Graph!\n"; /* Calls this->resolveVertex to check
if a given vertex is already in the
Graph. Returns with an error, if
this is the case. */
return; /* -- */
}
this->vertices.push_back(vertex); // adds a vertetx via the push_back
// function provided by std::vector
this->adjacencyMatrix.resize(
this->vertices.size(),
std::vector<int>(this->vertices.size())); // resizes the adjacencyMatrix
// to the new size
for (int i = 0; i < this->vertices.size(); i++) { /* -- */
adjacencyMatrix[i].resize(
this->vertices.size()); /* resizes every "sub" vector of the matrix to
the new size */
} /* -- */
}
/* -- /
Function to delete a vertex from the Graph;
- takes one argument of type std::string that represents a vertex
- returns void
/ -- */
void ExtendedGraph::deleteVertex(const std::string &vertex) {
int index = this->resolveVertex(vertex);
if (index == -1) { /* -- */
std::cerr << "Vertex not found\n"; /* Calls this->resolveVertex to check if
a given vertex is already in the
Graph. Returns with an error, if this
is the case. */
return; /* -- */
}
this->vertices.erase(
this->vertices.begin() +
index); // erases the vertex at position "index" from this->vertices
this->adjacencyMatrix.erase(
this->adjacencyMatrix.begin() +
index); // erases the entries from the adjacencyMatrix at "column"
// position "index"
for (int i = 0; i < this->adjacencyMatrix[0].size(); i++) { /* -- */
this->adjacencyMatrix[i].erase(this->adjacencyMatrix[i].begin() +
index); /* erases the entries from the
adjacencyMatrix in every "row" */
} /* -- */
}
/* -- /
Function to insert an Edge
- takes one argument of type Edge that represents an edge
- returns void
/ -- */
void ExtendedGraph::insertEdge(const Edge &edge) {
int col = this->resolveVertex(
edge.getSrc()); // resolves the src of the edge to the index within the
// adjacencyMatrix
int row = this->resolveVertex(
edge.getDest()); // resolves the dest of the edge to the index within the
// adjacencyMatrix
if (col == -1 || row == -1) { /* -- */
std::cerr << "Vertex not found!\n"; /* Calls this->resolveVertex to check
if a given vertex is already in the
Graph. Returns with an error, if this
is the case. */
return; /* -- */
}
this->adjacencyMatrix[col][row] =
edge.getWeight(); // sets the value of the adjacencyMatrix at position
// [col][row] to the weight of the edge
}
/* -- /
Function to delete an Edge
- takes one argument of type Edge that represents an edge
- returns void
/ -- */
void ExtendedGraph::deleteEdge(const Edge &edge) {
int col = this->resolveVertex(
edge.getSrc()); // resolves the src of the edge to the index within the
// adjacencyMatrix
int row = this->resolveVertex(
edge.getDest()); // resolves the dest of the edge to the index within the
// adjacencyMatrix
if (col == -1 || row == -1) { /* -- */
std::cerr << "Vertex not found!\n"; /* Calls this->resolveVertex to check
if a given vertex is already in the
Graph. Returns with an error, if this
is the case. */
return; /* -- */
}
this->adjacencyMatrix[col][row] =
0; // sets the value of the adjacencyMatrix at position [col][row] to 0
}
/* -- /
Function to check whether vertex v2 is adjacent to vertex v1
- takes one argument of type Edge that represents an edge
- returns void
/ -- */
bool ExtendedGraph::adjacent(const std::string &vertex1,
const std::string &vertex2) {
int indexVertex1 = this->resolveVertex(vertex1);
int indexVertex2 = this->resolveVertex(vertex2);
if (indexVertex1 == -1 || indexVertex2 == -1) {
std::cerr << "Vertex not found!\n";
return false;
}
// As adjacency is an equivalency relation, we need to check for a possible
// relation in both direction. This can be achieved by swapping the the
// position specifications of the adjacencyMatrix (from
// [indexVertex1][indexVertex2] to [indexVertex2][indexVertex1]).
if (this->adjacencyMatrix[indexVertex1][indexVertex2] != 0 ||
this->adjacencyMatrix[indexVertex2][indexVertex1] != 0) {
return true; // if a connection (in any direction) is found, return true
} else {
return false; // else, return false
}
}
/* -- /
Function that returns an std::vector of std::string representing the
neighbouring vertices of the parameter std::string vertex. Other than adjacent,
neighbourhood is a directed relationship, which means that a vertex "A" can be
the neighbour of "B", but this does not automatically imply that "B" is the
neighbour of "A".
- takes one argument of type std::string that represents a vertex
- returns a std::vector of std::string
/ -- */
std::vector<std::string> ExtendedGraph::neighbours(const std::string &vertex) {
int indexVertex = this->resolveVertex(
vertex); // resolves the vertex to the index within the adjacencyMatrix
std::vector<std::string> resVector =
{}; // initializes an empty std::vetor of std::string
for (int i = 0; i < this->adjacencyMatrix[indexVertex].size();
i++) { /* Loops through all entries of the subvector of
adjacencyMatrix[indexVertex] */
if (this->adjacencyMatrix[indexVertex][i] !=
0) { /* and checks if the entry at position [indexVertex][i] is not 0.
*/
resVector.push_back(
this->vertices[i]); /* If the condition is fulfilled, add the vertex
(name) to the result vector resVector */
}
}
return resVector;
}
/* -- /
Function that prints the current Graph's adjacencyMatrix.
- prints the Graph by utilizing std::cout
- returns void
/ -- */
void ExtendedGraph::printGraph() {
std::cout << "--------------------------------------------\n";
std::cout << "\t\t\t";
for (int i = 0; i < this->vertices.size(); i++) {
std::cout << this->vertices[i] << "\t";
}
std::cout << "\n";
for (int i = 0; i < this->vertices.size(); i++) {
std::cout << " " << this->vertices[i] << "\t\t-->\t";
for (int j = 0; j < this->vertices.size(); j++) {
std::cout << this->adjacencyMatrix[i][j] << "\t";
}
std::cout << "\n";
}
std::cout << "--------------------------------------------\n";
};
/* -- /
Function that resolves a parameter std::string name and returns it's index
within the this->vertices vector; between vertices of type std::string and the
corresponding index (in the adjacencyMatrix) of type int.
- takes one argument of type std::string that represents a vertex
- returns an int representing the vertex's index in the adjacencyMatrix;
- function returns -1 in case the resolution of the name is unsuccessful
/ -- */
int ExtendedGraph::resolveVertex(const std::string &vertexName) {
for (int i = 0; i < this->vertices.size(); i++) {
if (this->vertices[i] == vertexName) {
return i;
}
}
return -1;
}
void ExtendedGraph::depthFirstSearch(std::string vertex) {
std::vector<bool> visited;
visited.resize(this->vertices.size(), false);
this->doTheDFS(vertex, visited);
std::cout << std::endl;
}
void ExtendedGraph::doTheDFS(std::string vertex, std::vector<bool> &visited) {
std::cout << vertex << std::flush;
visited[resolveVertex(vertex)] = true;
std::vector<std::string> theneighbours = this->neighbours(vertex);
for (int i = 0; i < theneighbours.size(); i++) {
if (!visited[resolveVertex(theneighbours[i])]) {
std::cout << " --> ";
doTheDFS(theneighbours[i], visited);
}
}
}

72
Uebung 3/Uebung3_2/extendedgraph2.h Normal file
View File

@ -0,0 +1,72 @@
#include <iostream> /* cout, cerr */
#include <limits.h> /* INT_MAX */
#include <sstream> /* type stringstream to easily concat a result string */
#include <string> /* type string */
#include <vector> /* type vector */
#include "edge.h"
#pragma once
void vectorToString(std::vector<std::string> vector);
/* -- Class Graph -- */
class ExtendedGraph {
private:
std::vector<std::string> vertices; // vector connecting vertices with
// indicies; needed for name resolution
std::vector<bool> visited = {false};
public:
ExtendedGraph(); // default constructor
ExtendedGraph(const std::vector<std::string> &vertices,
const std::vector<Edge> &edges); // param. constructor
std::vector<std::vector<int>>
adjacencyMatrix; // vector of vectors containing integers (the adjacency
// matrix)
/* --
Resolves a given string of a vertex and returns its position in the
adjacencyMatrix (as integer). Returns -1 if name could not be resolved,
which indicates the the name was not found.
-- */
int resolveVertex(const std::string &name);
void
printGraph(); // prints out the graph with vertices and the adjacencyMatrix
/* --
Graph Manipulation Functions
-- */
void insertVertex(
const std::string &vertex); // inserts a new vertex; throws error, if
// vertex already exists in Graph
void deleteVertex(
const std::string &vertex); // deletes a vertex from the Graph; throws an
// error, if vertex does not exist
void insertEdge(
const Edge &edge); // inserts a new edge; parameter can be {std::string,
// std::string} due to implicit cast...
// ...does not check if the edge already exists, nor
// notifies user/programmer
void deleteEdge(
const Edge &edge); // deletes an edge; parameter can be {std::string,
// std::string} due to implicit cast...
// ...does not check if edge exists
bool adjacent(const std::string &vertex1,
const std::string
&vertex2); // checks if vertex1 and vertex2 are adjacent;
// returns boolean; adjacency indicates that...
// ...a direct connection between a <--> b
// (direction NOT important) exists
std::vector<std::string>
neighbours(const std::string
&vertex); // returns a vector of strings, containing all
// neighbouring vertices of the parameter vertex...
// ...Neighbours are all vertices that a given
// vertex is connected to through OUTGOING edges
void depthFirstSearch(std::string vertex);
void doTheDFS(std::string vertex, std::vector<bool> &visited);
int getEdgeWeight(std::string sourceVertex, std::string targetVertex);
};

74
Uebung 3/Uebung3_2/main.cpp Normal file
View File

@ -0,0 +1,74 @@
#include "edge.h"
#include "extendedgraph2.h"
#include <iostream> /* cout, cerr */
#include <sstream> /* type stringstream to easily concat a result string */
#include <string> /* type string */
#include <vector> /* type vector */
int main() {
/* Creation of Graph */
std::vector<std::string> vertices = {
"London", "Mailand", "Wien", "Madrid", "Rom",
"Paris", "Amsterdam", "Moskau", "Berlin", "Lyon"};
std::vector<Edge> edges = {
{"London", "Mailand", 2}, {"London", "Wien", 2},
{"Mailand", "London", 2}, {"Mailand", "Wien", 6},
{"Mailand", "Madrid", 5}, {"Wien", "London", 2},
{"Wien", "Mailand", 6}, {"Wien", "Rom", 4},
{"Wien", "Paris", 5}, {"Madrid", "Mailand", 5},
{"Madrid", "Rom", 5}, {"Madrid", "Lyon", 3},
{"Rom", "Wien", 4}, {"Rom", "Madrid", 5},
{"Rom", "Moskau", 3}, {"Rom", "Lyon", 4},
{"Amsterdam", "Paris", 1}, {"Amsterdam", "Moskau", 1},
{"Moskau", "Rom", 3}, {"Moskau", "Paris", 1},
{"Moskau", "Amsterdam", 1}, {"Moskau", "Berlin", 2},
{"Berlin", "Moskau", 2}, {"Berlin", "Lyon", 2},
{"Lyon", "Madrid", 3}, {"Lyon", "Rom", 4},
{"Lyon", "Paris", 2}, {"Lyon", "Berlin", 2}};
ExtendedGraph g(vertices, edges);
g.printGraph();
g.depthFirstSearch("London");
g.depthFirstSearch("Madrid");
/* insertVertices */
// g.insertVertex("D");
// g.insertVertex("H");
// g.printGraph();
/* insertEdges */
// g.insertEdge({"C", "D"});
// g.insertEdge({"F", "H"});
// g.insertEdge({"G", "H"});
// g.insertEdge({"D", "H"});
// g.printGraph();
/* deleteEdges */
// g.deleteEdge({"D", "H"});
// g.printGraph();
/* Delete Vertices */
// g.deleteVertex("C");
// g.printGraph();
/* Adjacency */
// std::cout << "Adjacent B --> A? " << g.adjacent("B", "A") << "\n";
// std::cout << "Adjacent A --> B? " << g.adjacent("A", "B") << "\n";
// std::cout << "Adjacent A --> H? " << g.adjacent("A", "H") << "\n";
/* Neighbourhood */
// std::cout << "\n";
// std::cout << "Neighbours of B: ";
// vectorToString(g.neighbours("B"));
// std::cout << "Neighbours of A: ";
// vectorToString(g.neighbours("A"));
// std::cout << "Neighbours of H: ";
// vectorToString(g.neighbours("H"));
}
void vectorToString(std::vector<std::string> vector) {
for (int i = 0; i < vector.size(); i++) {
std::cout << vector[i] << "\t";
}
std::cout << "\n";
}