From 5eb900cf95f18bdf75ea41704e4ba16727be60b4 Mon Sep 17 00:00:00 2001
From: Usova Marina A <oppabang@mail.ru>
Date: Thu, 20 Apr 2017 23:53:24 +0300
Subject: [PATCH 1/6] Realization

---
 app/main.cpp                 |  22 ++-
 include/Dijkstra.h           |  23 +++
 include/RBtree.h             | 331 +++++++++++++++++++++++++++++++++++
 include/RBtreeNode.h         |  19 ++
 include/add.h                |   6 -
 include/d_heap.h             |  39 +++++
 include/graph.h              |  53 ++++++
 include/priority_queue.h     |  76 ++++++++
 src/Dijkstra.cpp             | 111 ++++++++++++
 src/RB_tree.cpp              |   3 +
 src/add.cpp                  |   3 -
 src/d_heap.cpp               | 147 ++++++++++++++++
 src/graph.cpp                | 153 ++++++++++++++++
 src/priority_queue.cpp       |  49 ++++++
 test/test_Dijkstra.cpp       |  85 +++++++++
 test/test_RBtree.cpp         |  88 ++++++++++
 test/test_add.cpp            |   7 -
 test/test_d_heap.cpp         | 290 ++++++++++++++++++++++++++++++
 test/test_graph.cpp          | 109 ++++++++++++
 test/test_priority_queue.cpp | 126 +++++++++++++
 20 files changed, 1721 insertions(+), 19 deletions(-)
 create mode 100644 include/Dijkstra.h
 create mode 100644 include/RBtree.h
 create mode 100644 include/RBtreeNode.h
 delete mode 100644 include/add.h
 create mode 100644 include/d_heap.h
 create mode 100644 include/graph.h
 create mode 100644 include/priority_queue.h
 create mode 100644 src/Dijkstra.cpp
 create mode 100644 src/RB_tree.cpp
 delete mode 100644 src/add.cpp
 create mode 100644 src/d_heap.cpp
 create mode 100644 src/graph.cpp
 create mode 100644 src/priority_queue.cpp
 create mode 100644 test/test_Dijkstra.cpp
 create mode 100644 test/test_RBtree.cpp
 delete mode 100644 test/test_add.cpp
 create mode 100644 test/test_d_heap.cpp
 create mode 100644 test/test_graph.cpp
 create mode 100644 test/test_priority_queue.cpp

diff --git a/app/main.cpp b/app/main.cpp
index 4485790..8e90d7c 100644
--- a/app/main.cpp
+++ b/app/main.cpp
@@ -1,6 +1,22 @@
-#include "add.h"
-#include <iostream>
+#include "Dijkstra.h"
+#include "graph.h"
 
 int main() {
-  std::cout << "2 + 2 = " << add(2, 2) << std::endl;
+  Graph *graph = new Graph(8, 13);
+  graph->insert_edge(0, 1, 3);
+  graph->insert_edge(1, 2, 1);
+  graph->insert_edge(1, 3, 4);
+  graph->insert_edge(1, 4, 1);
+  graph->insert_edge(2, 4, 1);
+  graph->insert_edge(2, 5, 10);
+  graph->insert_edge(3, 4, 1);
+  graph->insert_edge(3, 6, 1);
+  graph->insert_edge(4, 5, 7);
+  graph->insert_edge(4, 6, 8);
+  graph->insert_edge(4, 7, 4);
+  graph->insert_edge(5, 7, 6);
+  graph->insert_edge(6, 7, 1);
+  int min = HeapDijkstra(&graph, 0);
+  std::cout << " Min way from start position - " << min << std::endl;
+  return 0;
 }
diff --git a/include/Dijkstra.h b/include/Dijkstra.h
new file mode 100644
index 0000000..3974241
--- /dev/null
+++ b/include/Dijkstra.h
@@ -0,0 +1,23 @@
+#ifndef INCLUDE_DIJKSTRA_H_
+#define INCLUDE_DIJKSTRA_H_
+
+#include "graph.h"
+#include "d_heap.h"
+#include "priority_queue.h"
+#include "RBtree.h"
+
+const int INF = 10000000;
+
+class Dijkstra_Data: public Data {
+ public:
+  int num;
+  Dijkstra_Data(int num, int p) {
+    this->num = num;
+    priority = p;
+  }
+};
+
+int HeapDijkstra(Graph ** _graph, int start);
+std::vector<int> TreeDijkstra(std::vector < std::vector < std::pair<int, int> > > g, int start);
+
+#endif  // INCLUDE_DIJKSTRA_H_
diff --git a/include/RBtree.h b/include/RBtree.h
new file mode 100644
index 0000000..2d44903
--- /dev/null
+++ b/include/RBtree.h
@@ -0,0 +1,331 @@
+#ifndef INCLUDE_RBTREE_H_
+#define INCLUDE_RBTREE_H_
+
+#include "RBtreeNode.h"
+#include <stdio.h>
+
+template <class T>
+class RBTree {
+  RBtreeNode<T>* root;
+
+  void left_rotate(RBtreeNode<T> *node);
+  void right_rotate(RBtreeNode<T> *node);
+  void fixup_after_insert(RBtreeNode<T> *node);
+  void fixup_after_delete(RBtreeNode<T> *node);
+ public:
+  RBTree();
+  explicit RBTree(T _val);
+  ~RBTree(void);
+  RBtreeNode<T>* get_root();
+
+  void RB_insert(T _val);
+  void RB_delete(T _val);
+  RBtreeNode<T>* RB_find(T _val);
+  RBtreeNode<T>* get_min();
+};
+
+/* Конструкторы */
+template <class T>
+RBTree<T>::RBTree() {
+  root = reinterpret_cast<RBtreeNode<T>*>(NullNode);
+}
+
+template <class T>
+RBTree<T>::RBTree(T _val) {
+  root = new RBtreeNode<T>;
+  root->value = _val;
+  root->color = COLOR_BLACK;
+  root->left = root->right = reinterpret_cast<RBtreeNode<T>*>(NullNode);
+  root->parent = 0;
+}
+
+/* Деструктор */
+template <class T>
+RBTree<T>::~RBTree(void) {
+  while (root != reinterpret_cast<RBtreeNode<T>*>(NullNode))
+    RB_delete(root->value);
+}
+
+template <class T>
+RBtreeNode<T>* RBTree<T>::get_root() {
+  return root;
+}
+
+/* Левый поворот */
+template <class T>
+void RBTree<T>::left_rotate(RBtreeNode<T> *node) {
+  RBtreeNode<T> *right = node->right;
+  node->right = right->left;
+
+  if (right->left != reinterpret_cast<RBtreeNode<T>*>(NullNode))
+    right->left->parent = node;
+  right->parent = node->parent;
+
+  if (node->parent != 0) {
+    if (node == node->parent->left) {
+      node->parent->left = right;
+    } else {
+      node->parent->right = right;
+    }
+  } else {
+    root = right;
+  }
+  right->left = node;
+  node->parent = right;
+}
+
+/* Правый поворот */
+template <class T>
+void RBTree<T>::right_rotate(RBtreeNode<T> *node) {
+  RBtreeNode<T> *left = node->left;
+  node->left = left->right;
+
+  if (left->right != reinterpret_cast<RBtreeNode<T>*>(NullNode))
+    left->right->parent = node;
+  left->parent = node->parent;
+
+  if (node->parent != 0) {
+    if (node == node->parent->left) {
+      node->parent->left = left;
+    } else {
+      node->parent->right = left;
+    }
+  } else {
+    root = left;
+  }
+  left->right = node;
+  node->parent = left;
+}
+
+/* Восстановление свойств после добавления */
+template <class T>
+void RBTree<T>::fixup_after_insert(RBtreeNode<T> *node) {
+  while ((node != root) && (node->parent->color == COLOR_RED)) {
+    // узел в левом поддереве grandfather
+    if (node->parent == node->parent->parent->left) {
+      RBtreeNode<T> *uncle = node->parent->parent->right;
+      if (uncle->color == COLOR_RED) {
+        // случай 1 - uncle RED
+        node->parent->color = COLOR_BLACK;
+        uncle->color = COLOR_BLACK;
+        node->parent->parent->color = COLOR_RED;
+        node = node->parent->parent;
+      } else {
+        // случаи 2 и 3 - uncle BLACK
+        if (node == node->parent->right) {
+          // сведение случая 2 к случаю 3
+          node = node->parent;
+          left_rotate(node);
+        }
+        // случай 3
+        node->parent->color = COLOR_BLACK;
+        node->parent->parent->color = COLOR_RED;
+        right_rotate(node->parent->parent);
+      }
+    } else {
+      // узел в правом поддереве grandfather
+      RBtreeNode<T> *y = node->parent->parent->left;
+      if (y->color == COLOR_RED) {
+        // случай 4 - uncle RED
+        node->parent->color = COLOR_BLACK;
+        y->color = COLOR_BLACK;
+        node->parent->parent->color = COLOR_RED;
+        node = node->parent->parent;
+      } else {
+        // случаи 5 и 6 - uncle BLACK
+        if (node == node->parent->left) {
+          // сведение случая 5 к случаю 6
+          node = node->parent;
+          right_rotate(node);
+        }
+        // случай 6
+        node->parent->color = COLOR_BLACK;
+        node->parent->parent->color = COLOR_RED;
+        left_rotate(node->parent->parent);
+      }
+    }
+  }
+  root->color = COLOR_BLACK;
+}
+
+/* Добавление узла */
+template <class T>
+void RBTree<T>::RB_insert(T _val) {
+  RBtreeNode<T> *node = root, *parent = 0, *newnode = 0;
+
+  // поиск листа для нового элемента
+  while (node != reinterpret_cast<RBtreeNode<T>*>(NullNode)) {
+    if (node->value == _val)
+      throw std::logic_error("Input error: such value alreade exist.\n");
+    parent = node;
+    if (_val < node->value) {
+      node = node->left;
+    } else {
+      node = node->right;
+    }
+  }
+  newnode = new RBtreeNode<T>;
+  newnode->value = _val;
+  newnode->color = COLOR_RED;
+  newnode->left = reinterpret_cast<RBtreeNode<T>*>(NullNode);
+  newnode->right = reinterpret_cast<RBtreeNode<T>*>(NullNode);
+  newnode->parent = parent;
+
+  if (parent == 0) {
+    root = newnode;
+  } else {
+    if (_val < parent->value) {
+      parent->left = newnode;
+    } else {
+      parent->right = newnode;
+    }
+  }
+  fixup_after_insert(newnode);
+}
+
+/* Восстановление свойств после удаления */
+template <class T>
+void RBTree<T>::fixup_after_delete(RBtreeNode<T> *node) {
+  while ((node != root) && (node->color == COLOR_BLACK)) {
+    // узел в левом поддереве grandfather
+    if (node == node->parent->left) {
+      RBtreeNode<T> *uncle = node->parent->right;
+      if (uncle->color == COLOR_RED) {
+        // случай 1 - uncle RED
+        uncle->color = COLOR_BLACK;
+        node->parent->color = COLOR_RED;
+        left_rotate(node->parent);
+        uncle = node->parent->right;
+      }
+      if ((uncle->left->color == COLOR_BLACK) &&
+        (uncle->right->color == COLOR_BLACK)) {
+        // случаи 2 и 3 - uncle BLACK
+        uncle->color = COLOR_RED;
+        node = node->parent;
+      } else {
+        // случай 3
+        if (uncle->right->color == COLOR_BLACK) {
+          uncle->left->color = COLOR_BLACK;
+          uncle->color = COLOR_RED;
+          right_rotate(uncle);
+          uncle = node->parent->right;
+        }
+        // случай 4
+        uncle->color = node->parent->color;
+        node->parent->color = COLOR_BLACK;
+        uncle->right->color = COLOR_BLACK;
+        left_rotate(node->parent);
+        node = root;
+      }
+    } else {
+      // узел в левом поддереве grandfather
+      RBtreeNode<T> *uncle = node->parent->left;
+      if (uncle->color == COLOR_RED) {
+        uncle->color = COLOR_BLACK;
+        node->parent->color = COLOR_RED;
+        right_rotate(node->parent);
+        uncle = node->parent->left;
+      }
+      if ((uncle->right->color == COLOR_BLACK) &&
+        (uncle->left->color == COLOR_BLACK)) {
+        // случаи 6 и 7 - uncle BLACK
+        uncle->color = COLOR_RED;
+        node = node->parent;
+      } else {
+        // случай 7
+        if (uncle->left->color == COLOR_BLACK) {
+          uncle->right->color = COLOR_BLACK;
+          uncle->color = COLOR_RED;
+          left_rotate(uncle);
+          uncle = node->parent->left;
+        }
+        // случай 8
+        uncle->color = node->parent->color;
+        node->parent->color = COLOR_BLACK;
+        uncle->left->color = COLOR_BLACK;
+        right_rotate(node->parent);
+        node = root;
+      }
+    }
+  }
+  node->color = COLOR_BLACK;
+}
+
+/* Удаление узла */
+template <class T>
+void RBTree<T>::RB_delete(T _val) {
+  RBtreeNode<T> *node, *parent, *_node;
+
+  _node = root;
+  while (_node != reinterpret_cast<RBtreeNode<T>*>(NullNode)) {
+    if (_node->value == _val) {
+      break;
+    } else {
+      if (_val < _node->value) {
+        _node = _node->left;
+      } else {
+        _node = _node->right;
+      }
+    }
+  }
+
+  if (_node == reinterpret_cast<RBtreeNode<T>*>(NullNode))
+    throw std::logic_error("Input error: value doesn't exist.\n");
+  if ((_node->left == reinterpret_cast<RBtreeNode<T>*>(NullNode)) ||
+    (_node->right == reinterpret_cast<RBtreeNode<T>*>(NullNode))) {
+    parent = _node;
+  } else {
+    parent = _node->right;
+    while (parent->left != reinterpret_cast<RBtreeNode<T>*>(NullNode))
+      parent = parent->left;
+  }
+  if (parent->left != reinterpret_cast<RBtreeNode<T>*>(NullNode)) {
+    node = parent->left;
+  } else {
+    node = parent->right;
+  }
+  node->parent = parent->parent;
+  if (parent->parent != 0) {
+    if (parent == parent->parent->left) {
+      parent->parent->left = node;
+    } else {
+      parent->parent->right = node;
+    }
+  } else {
+    root = node;
+  }
+  if (parent != _node)
+    _node->value = parent->value;
+  if (parent->color == COLOR_BLACK)
+    fixup_after_delete(node);
+  delete parent;
+}
+
+/* Поиск по значению */
+template <class T>
+RBtreeNode<T>* RBTree<T>::RB_find(T _val) {
+  RBtreeNode<T> *cur = root;
+  while (cur != 0) {
+    if (_val == cur->value) {
+      return cur;
+    } else {
+      if (_val < cur->value) {
+        cur = cur->left;
+      } else {
+        cur = cur->right;
+      }
+    }
+  }
+  throw std::logic_error("Don't found.\n");
+}
+
+template<class T>
+RBtreeNode<T>* RBTree<T>::get_min() {
+  RBtreeNode<T>* node = root;
+  while (node->left != reinterpret_cast<RBtreeNode<T>*>(NullNode)) {
+    node = node->left;
+  }
+  return node;
+}
+
+#endif  // INCLUDE_RBTREE_H_
diff --git a/include/RBtreeNode.h b/include/RBtreeNode.h
new file mode 100644
index 0000000..2805087
--- /dev/null
+++ b/include/RBtreeNode.h
@@ -0,0 +1,19 @@
+#ifndef INCLUDE_RBTREENODE_H_
+#define INCLUDE_RBTREENODE_H_
+
+#define COLOR_RED 1
+#define COLOR_BLACK 0
+#define NullNode &EmptyNode
+
+template <class T>
+struct RBtreeNode {
+  T value;
+  int color;
+  RBtreeNode *left;
+  RBtreeNode *right;
+  RBtreeNode *parent;
+};
+
+extern RBtreeNode<int> EmptyNode;
+
+#endif  // INCLUDE_RBTREENODE_H_
diff --git a/include/add.h b/include/add.h
deleted file mode 100644
index ebb1c94..0000000
--- a/include/add.h
+++ /dev/null
@@ -1,6 +0,0 @@
-#ifndef INCLUDE_ADD_H_
-#define INCLUDE_ADD_H_
-
-int add(int x, int y);
-
-#endif  // INCLUDE_ADD_H_
diff --git a/include/d_heap.h b/include/d_heap.h
new file mode 100644
index 0000000..0f3203d
--- /dev/null
+++ b/include/d_heap.h
@@ -0,0 +1,39 @@
+#ifndef INCLUDE_D_HEAP_H_
+#define INCLUDE_D_HEAP_H_
+
+#include <iostream>
+#define MAXsize 1000
+
+struct Data {
+  int priority;
+};
+
+class D_Heap {
+ protected:
+  Data **key;
+  int d;
+  int size;
+
+ public:
+  explicit D_Heap(int d);
+  D_Heap(const D_Heap &heap);
+  ~D_Heap();
+
+  int Child(int i);
+  int Parent(int i);
+  int isFull();
+  int isEmpty();
+
+  void insert(Data **i);
+  void insert_group(Data **keys, int num);
+  Data* erase();
+  Data* erase(int i);
+  void transposition(int i, int j);
+  void surfacing(int i);
+  void immersion(int i);
+  void hilling();
+
+  int min_Child(int i);
+};
+
+#endif  // INCLUDE_D_HEAP_H_
diff --git a/include/graph.h b/include/graph.h
new file mode 100644
index 0000000..f5a454c
--- /dev/null
+++ b/include/graph.h
@@ -0,0 +1,53 @@
+#ifndef INCLUDE_GRAPH_H_
+#define INCLUDE_GRAPH_H_
+#include <vector>
+#include <iostream>
+#include <ctime>
+#define MAXver 1000
+
+/* Рёбра графа */
+class Edges {
+ public:
+  int x;
+  int y;
+  int weight;
+  Edges(int _x, int _y, int _w) {
+    this->x = _x;
+    this->y = _y;
+    this->weight = _w;
+  }
+};
+
+class Graph {
+ private:
+  int verices;
+  int edge;
+  int size;
+  int* ver_mas;
+  Edges** edge_mas;
+
+ public:
+  explicit Graph(int _ver);
+  Graph(int _ver, int _edge);
+  ~Graph();
+
+  int get_ver();
+  int get_edge_num();
+  int get_size();
+  int get_weight(int _x, int _y);
+  Edges* get_edge(int i);
+  Edges** get_edge_mas();
+
+  int isFull();
+  int isEmpty();
+
+  void create_ver(int *x, int *y);
+  void create_graph(int min_w, int max_w);
+  void insert_edge(int _x, int _y, int _w);
+  void delete_edge(int _x, int _y);
+  int find_edge_num(int _x, int _y);
+};
+
+std::vector < std::vector < std::pair<int, int> > > make_graph(char filename[]);
+
+#endif  // INCLUDE_GRAPH_H_
diff --git a/include/priority_queue.h b/include/priority_queue.h
new file mode 100644
index 0000000..46611ee
--- /dev/null
+++ b/include/priority_queue.h
@@ -0,0 +1,76 @@
+#ifndef INCLUDE_PRIORITY_QUEUE_H_
+#define INCLUDE_PRIORITY_QUEUE_H_
+#include "d_heap.h"
+#include "RBtree.h"
+
+/*----------------------------------------------------*/
+/*           Приоритетная очередь на 2-куче           */
+/*----------------------------------------------------*/
+
+class PriorityQueueHeap {
+ protected:
+  D_Heap *heap;
+ public:
+  explicit PriorityQueueHeap(int d);
+  PriorityQueueHeap(Data **keys, int num, int d);
+  ~PriorityQueueHeap();
+  int isFull();
+  int isEmpty();
+
+  void add(Data **key);
+  Data* pop(int i);
+  Data* pop_min();
+  void update();
+};
+
+/*----------------------------------------------------*/
+/*   Приоритетная очередь на красно-черных деревьях   */
+/*----------------------------------------------------*/
+
+template <class T>
+class PriorityQueueRBtree {
+  RBTree<T> tree;
+
+ public:
+  int isEmpty();
+
+  void add(T _val);
+  void pop(T _val);
+  RBtreeNode<T>* find(T _val);
+  RBtreeNode<T>* min();
+};
+
+/*----------------------------------------------------*/
+/*   Приоритетная очередь на красно-черных деревьях   */
+/*----------------------------------------------------*/
+
+/* Поиск */
+template <class T>
+RBtreeNode<T>* PriorityQueueRBtree<T>::find(T _val) {
+  return tree.RB_find(_val);
+}
+
+/* Минимальный */
+template <class T>
+RBtreeNode<T>* PriorityQueueRBtree<T>::min() {
+  return tree.get_min();
+}
+
+/* Вставка */
+template <class T>
+void PriorityQueueRBtree<T>::add(T _val) {
+  tree.RB_insert(_val);
+}
+
+/* удаление */
+template <class T>
+void PriorityQueueRBtree<T>::pop(T _val) {
+  tree.RB_delete(_val);
+}
+
+template <class T>
+int PriorityQueueRBtree<T>::isEmpty() {
+  return (tree.get_root() == reinterpret_cast<RBtreeNode<T>*>(NullNode));
+}
+
+#endif  // INCLUDE_PRIORITY_QUEUE_H_
diff --git a/src/Dijkstra.cpp b/src/Dijkstra.cpp
new file mode 100644
index 0000000..dd24687
--- /dev/null
+++ b/src/Dijkstra.cpp
@@ -0,0 +1,111 @@
+#include "Dijkstra.h"
+#include <vector>
+#include <utility>
+
+/*    Алгортм Дейкстры    */
+/*        на д-куче       */
+/* с реализованным графом */
+
+int HeapDijkstra(Graph **_graph, int start) {
+  // проверка корректности входных данных
+  int verices = (*_graph)->get_ver();
+  if (!verices)
+    throw std::logic_error("Error: there in not verix in graph.\n");
+  if (start < 0 || start > verices)
+    throw std::logic_error("Input error: wrong start verix.\n");
+
+  // подготовка данных для работы алгоритма
+  int edge_ = (*_graph)->get_size();
+  Data** dist = new Data*[verices];
+  int* p = new int[verices];
+
+  for (int i = 0; i < verices; i++) {
+    p[i] = 0;
+    dist[i] = new Dijkstra_Data(i, INF);
+  }
+  dist[start]->priority = 0;
+  PriorityQueueHeap* q = new PriorityQueueHeap(dist, verices, 2);
+  Edges** edges = (*_graph)->get_edge_mas();
+
+  // алгоритм Дейкстры
+  while (!q->isEmpty()) {
+    int current = (reinterpret_cast<Dijkstra_Data*>(q->pop(0)))->num;
+    int d;
+    for (int i = 0; i < edge_; i++) {
+      if (current == edges[i]->x) {
+        d = dist[edges[i]->y]->priority;
+        if (d > dist[edges[i]->x]->priority + (*_graph)->get_weight(edges[i]->x, edges[i]->y)) {
+          dist[edges[i]->y]->priority = dist[edges[i]->x]->priority +
+            (*_graph)->get_weight(edges[i]->x, edges[i]->y);
+          p[edges[i]->y] = edges[i]->x;
+          q->update();
+        }
+      }
+      if (current == edges[i]->y) {
+        d = dist[edges[i]->x]->priority;
+        if (d > dist[edges[i]->y]->priority + (*_graph)->get_weight(edges[i]->x, edges[i]->y)) {
+          dist[edges[i]->x]->priority = dist[edges[i]->y]->priority +
+            (*_graph)->get_weight(edges[i]->x, edges[i]->y);
+          p[edges[i]->x] = edges[i]->y;
+          q->update();
+        }
+      }
+    }
+  }
+
+  // вывод и удаление (можно было реализовать воврат полученного dist)
+  int min;
+  for (int i = 0; i < verices; i++)
+    std::cout << p[i];
+  std::cout << std::endl;
+  std::cout << std::endl;
+  std::cout << " WAY: " << std::endl;
+  for (int i = 0; i < verices; i++) {
+    if (i == start) {
+      std::cout << "Start position: " << start << std::endl;
+      continue;
+    }
+    std::cout << p[i] << " -> " << i << "   " << dist[i]->priority << std::endl;
+    min = dist[i]->priority;
+    delete dist[i];
+  }
+  delete[]dist;
+  delete q;
+  return min;
+}
+
+/*           Алгортм Дейкстры           */
+/*        на красно-чёрных деревьях     */
+/*   со встроенными структурами данных  */
+/*           для описания графа         */
+/*     и реализацией ввода из файла     */
+
+std::vector<int> TreeDijkstra(std::vector < std::vector < std::pair<int, int> > > g, int start) {
+  // проверка корректности входных данных
+  if (g.empty() || (start < 1) || (start > static_cast<int>(g.size())))
+    throw std::logic_error("Input error: graph is empty or wrong start virtex.\n");
+
+  // подготовка данных для работы алгоритма
+  std::vector<int> d(g.size(), INF);
+  int v;
+  d[start - 1] = 0;
+  PriorityQueueRBtree < std::pair<int, int> > pq;
+  pq.add(std::pair<int, int>(0, start));
+
+  // алгоритм Дейкстры
+  while (!pq.isEmpty()) {
+    std::pair<int, int> current = pq.min()->value;
+    pq.pop(current);
+    v = current.second - 1;
+    for (int i = 0; i < static_cast<int>(g[v].size()); ++i) {
+      if (d[v] + g[v][i].second < d[g[v][i].first - 1]) {
+        if (d[g[v][i].first - 1] != INF)
+          pq.pop(std::pair<int, int>(d[g[v][i].first - 1],
+            g[v][i].first));
+        d[g[v][i].first - 1] = d[v] + g[v][i].second;
+        pq.add(std::pair<int, int>(d[g[v][i].first - 1], g[v][i].first));
+      }
+    }
+  }
+  return d;
+}
diff --git a/src/RB_tree.cpp b/src/RB_tree.cpp
new file mode 100644
index 0000000..c6d3e76
--- /dev/null
+++ b/src/RB_tree.cpp
@@ -0,0 +1,3 @@
+#include "RBtreeNode.h"
+
+RBtreeNode<int> EmptyNode = { 0, 0, 0, 0, 0 };
diff --git a/src/add.cpp b/src/add.cpp
deleted file mode 100644
index 35bf82f..0000000
--- a/src/add.cpp
+++ /dev/null
@@ -1,3 +0,0 @@
-int add(int x, int y) {
-  return x + y;
-}
diff --git a/src/d_heap.cpp b/src/d_heap.cpp
new file mode 100644
index 0000000..0676a32
--- /dev/null
+++ b/src/d_heap.cpp
@@ -0,0 +1,147 @@
+#include "d_heap.h"
+
+/* Конструкторы */
+D_Heap::D_Heap(int d) {
+  if (d <= 0)
+    throw std::logic_error("Input error: invalid d.\n");
+  this->d = d;
+  size = -1;
+  key = new Data*[MAXsize];
+}
+
+D_Heap::D_Heap(const D_Heap &heap) {
+  this->d = heap.d;
+  key = new Data*[MAXsize];
+  for (int i = 0; i <= heap.size; i++)
+    key[i] = heap.key[i];
+  this->size = heap.size;
+}
+
+/* Деструктор */
+D_Heap::~D_Heap() {
+  delete[] key;
+}
+
+/* Формулы вычисления потомка и родителя */
+int D_Heap::Child(int i) {
+  return d * i + 1;
+}
+int D_Heap::Parent(int i) {
+  return (i - 1) / d;
+}
+
+int D_Heap::isFull() {
+  return size >= MAXsize - 1;
+}
+
+int D_Heap::isEmpty() {
+  return size == -1;
+}
+
+/* Вставка элемента в кучу */
+void D_Heap::insert(Data **i) {
+  if (isFull())
+    throw std::logic_error("Heap is FULL.\n");
+  size++;
+  key[size] = *i;
+  surfacing(size);
+}
+
+/* Вставка группы элементов в кучу */
+void D_Heap::insert_group(Data **keys, int num) {
+  if (size + num >= MAXsize)
+    throw std::logic_error("Input error: too large set.\n");
+  for (int i = 0; i < num; i++)
+    key[i + size + 1] = keys[i];
+  size += num;
+  hilling();
+}
+
+/* Стирание */
+Data* D_Heap::erase() {
+  if (isEmpty())
+    throw std::logic_error("Heap is empty.\n");
+  Data* keys = key[size];
+  size--;
+  return keys;
+}
+
+Data* D_Heap::erase(int i) {
+  if (isEmpty())
+    throw std::logic_error("Heap is empty.\n");
+  if ((i < 0) || (i > size))
+    throw std::logic_error("Input error: invalid index.\n");
+  Data* keys = key[i];
+  if (i == size) {
+    size--;
+    return keys;
+  }
+  transposition(i, size);
+  size--;
+  immersion(i);
+  return keys;
+}
+
+/* Обмен переданных значений */
+void D_Heap::transposition(int i, int j) {
+  if ((i < 0) || (j < 0) || (i > size) || (j > size))
+    throw std::logic_error("Input error: invalid indexes.\n");
+  Data* tmp = key[i];
+  key[i] = key[j];
+  key[j] = tmp;
+}
+
+/* Всплытие */
+void D_Heap::surfacing(int i) {
+  if ((i < 0) || (i > size))
+    throw std::logic_error("Input error: invalid index.\n");
+  int p = Parent(i);
+  while (i > 0) {
+    if (key[p]->priority < key[i]->priority)
+      break;
+    transposition(p, i);
+    i = p;
+    p = Parent(i);
+  }
+}
+
+/* Погружение */
+void D_Heap::immersion(int i) {
+  if ((i < 0) || (i > size))
+    throw std::logic_error("Input error: invalid index.\n");
+  int c = min_Child(i);
+  while ((c != -1) && (key[c]->priority < key[i]->priority)) {
+    transposition(i, c);
+    i = c;
+    c = min_Child(i);
+  }
+}
+
+/* Окучивание */
+void D_Heap::hilling() {
+  for (int i = size; i >= 0; i--)
+    immersion(i);
+}
+
+/* Поиск минимального потомка */
+int D_Heap::min_Child(int i) {
+  int ch = Child(i);
+  if (ch > size)
+    return -1;
+  int l;
+  if (i * d + d > size) {
+    l = size;
+  } else {
+    l = i * d + d;
+  }
+  int c;
+  Data* minKey = key[ch];
+  c = ch;
+  for (int k = ch + 1; k <= l; k++) {
+    if (minKey->priority > key[k]->priority) {
+      minKey = key[k];
+      c = k;
+    }
+  }
+  return c;
+}
diff --git a/src/graph.cpp b/src/graph.cpp
new file mode 100644
index 0000000..c270e90
--- /dev/null
+++ b/src/graph.cpp
@@ -0,0 +1,153 @@
+#include "graph.h"
+#include <iostream>
+#include <fstream>
+#include <vector>
+#include <utility>
+
+/* Конструкторы */
+Graph::Graph(int _ver) {
+  if (_ver < 0 || _ver > MAXver)
+    throw std::logic_error("Input error: wrong vertices number.\n");
+  this->verices = _ver;
+  this->edge = _ver*(_ver - 1) / 2;
+  size = 0;
+  ver_mas = new int[_ver];
+  edge_mas = new Edges*[edge];
+}
+
+Graph::Graph(int _ver, int _edge) {
+  if (_ver < 0 || _ver > MAXver)
+    throw std::logic_error("Input error: wrong vertices number.\n");
+  if (_edge < 0 || _edge > _ver * (_ver - 1) / 2)
+    throw std::logic_error("Input error: wrong edges number.\n");
+  this->verices = _ver;
+  this->edge = _edge;
+  size = 0;
+  ver_mas = new int[_ver];
+  edge_mas = new Edges*[_edge];
+}
+
+/* Деструктор */
+Graph::~Graph() {
+  for (int i = 0; i < size; i++)
+    delete edge_mas[i];
+  delete[]edge_mas;
+  delete[]ver_mas;
+}
+
+/* Функции возврата параметров графа*/
+
+/* Количество вершин */
+int Graph::get_ver() {
+  return verices;
+}
+
+/* Число рёбер графа */
+int Graph::get_edge_num() {
+  return edge;
+}
+
+/* Размер графа */
+int Graph::get_size() {
+  return size;
+}
+
+/* Расстояние между двумя вершинами */
+int Graph::get_weight(int _x, int _y) {
+  int i = find_edge_num(_x, _y);
+  return edge_mas[i]->weight;
+}
+
+/* Ребро */
+Edges* Graph::get_edge(int i) {
+  return edge_mas[i];
+}
+
+/* Массив рёбер */
+Edges** Graph::get_edge_mas() {
+  if (size == 0)
+    return nullptr;
+  return edge_mas;
+}
+
+int Graph::isFull() {
+  return edge == size;
+}
+
+int Graph::isEmpty() {
+  return size == 0;
+}
+
+/* Создание вершины */
+void Graph::create_ver(int *x, int *y) {
+  *x = rand() % verices;
+  *y = rand() % verices;
+  if (x == y || find_edge_num(*x, *y) != -1)
+    create_ver(x, y);
+}
+
+/* Создание графа */
+void Graph::create_graph(int min_w, int max_w) {
+  if (min_w > max_w)
+    throw std::logic_error("Input error: min must be < max.\n");
+  int x_, y_, w_;
+  for (int i = 0; i < edge; i++) {
+    time_t  timet;
+    time(&timet);
+    srand(static_cast<int>(timet));
+    create_ver(&x_, &y_);
+    w_ = rand() % static_cast<int>(max_w - min_w + 1) + min_w;
+    edge_mas[i] = new Edges(x_, y_, w_);
+    size++;
+  }
+}
+
+/* Добавление ребра */
+void Graph::insert_edge(int _x, int _y, int _w) {
+  if (isFull())
+    throw std::logic_error("Graph is FULL.\n");
+  if (find_edge_num(_x, _y) != -1)
+    throw std::logic_error("Edge already exist.\n");
+  if (_x == _y)
+    throw std::logic_error("Input error: x = y.\n");
+  edge_mas[size] = new Edges(_x, _y, _w);
+  size++;
+}
+
+/* Удаление ребра */
+void Graph::delete_edge(int _x, int _y) {
+  int i = find_edge_num(_x, _y);
+  if (i == -1)
+    throw std::logic_error("Edge doesn't exist.\n");
+  delete edge_mas[i];
+  edge_mas[i] = edge_mas[size - 1];
+  size--;
+}
+
+/* Номер ребра между вершинами в массиве рёбер */
+int Graph::find_edge_num(int _x, int _y) {
+  for (int i = 0; i < size; i++) {
+    if ((edge_mas[i]->x == _x && edge_mas[i]->y == _y) ||
+      (edge_mas[i]->x == _y && edge_mas[i]->y == _x))
+      return i;
+  }
+  return -1;
+}
+
+/* Чтение из файла для графа на встроенных структурах*/
+std::vector < std::vector < std::pair<int, int> > > make_graph(char filename[]) {
+  std::ifstream file(filename);
+  int N, n;
+  // считываем число вершин
+  file >> N;
+  std::vector < std::vector < std::pair<int, int> > > g(N);
+  // считываем рёбра
+  for (int i = 0; i < N; ++i) {
+    file >> n;
+    g[i] = std::vector< std::pair<int, int>>(n);
+    for (int j = 0; j < n; ++j) {
+      file >> g[i][j].first >> g[i][j].second;
+    }
+  }
+  return g;
+}
diff --git a/src/priority_queue.cpp b/src/priority_queue.cpp
new file mode 100644
index 0000000..3f7e0f0
--- /dev/null
+++ b/src/priority_queue.cpp
@@ -0,0 +1,49 @@
+#include "priority_queue.h"
+#include "RBtree.h"
+
+/*----------------------------------------------------*/
+/*           Приоритетная очередь на 2-куче           */
+/*----------------------------------------------------*/
+
+/* Конструкторы */
+PriorityQueueHeap::PriorityQueueHeap(int d) {
+  heap = new D_Heap(d = 2);
+}
+
+PriorityQueueHeap::PriorityQueueHeap(Data **keys, int num, int d) {
+  heap = new D_Heap(d = 2);
+  heap->insert_group(keys, num);
+}
+
+/* Деструктор */
+PriorityQueueHeap ::~PriorityQueueHeap() {
+  delete heap;
+}
+
+int PriorityQueueHeap::isFull() {
+  return heap->isFull();
+}
+
+int PriorityQueueHeap::isEmpty() {
+  return heap->isEmpty();
+}
+
+/* Добавление ключа в очередь */
+void PriorityQueueHeap::add(Data **key) {
+  heap->insert(key);
+}
+
+/* Удаление */
+Data* PriorityQueueHeap::pop(int i) {
+  return heap->erase(i);
+}
+
+/* Удаление минимального */
+Data* PriorityQueueHeap::pop_min() {
+  return heap->erase();
+}
+
+/* Обновление очереди */
+void PriorityQueueHeap::update() {
+  heap->hilling();
+}
diff --git a/test/test_Dijkstra.cpp b/test/test_Dijkstra.cpp
new file mode 100644
index 0000000..82b1875
--- /dev/null
+++ b/test/test_Dijkstra.cpp
@@ -0,0 +1,85 @@
+#include "gtest/gtest.h"
+#include "Dijkstra.h"
+#include <vector>
+
+/*TEST(DIJKSTRA, throw_when_try_work_without_vertices) {
+  Graph *graph = new Graph(0);
+  ASSERT_ANY_THROW(HeapDijkstra(&graph, 0));
+}*/
+
+TEST(DIJKSTRA, throw_when_try_work_with_wrong_start_vertex) {
+  Graph *graph = new Graph(4);
+  graph->insert_edge(0, 1, 2);
+  ASSERT_ANY_THROW(HeapDijkstra(&graph, 9));
+}
+
+TEST(DIJKSTRA, experiment_1) {
+  Graph *graph = new Graph(4);
+  graph->insert_edge(0, 1, 1);
+  graph->insert_edge(1, 2, 2);
+  graph->insert_edge(2, 3, 2);
+  graph->insert_edge(3, 0, 8);
+  EXPECT_EQ(2, HeapDijkstra(&graph, 2));
+  EXPECT_EQ(5, HeapDijkstra(&graph, 0));
+}
+
+TEST(DIJKSTRA, experiment_2) {
+  Graph *graph = new Graph(4, 6);
+  graph->insert_edge(0, 1, 1);
+  graph->insert_edge(0, 2, 1);
+  graph->insert_edge(0, 3, 8);
+  graph->insert_edge(1, 2, 4);
+  graph->insert_edge(1, 3, 6);
+  graph->insert_edge(2, 3, 5);
+  EXPECT_EQ(5, HeapDijkstra(&graph, 2));
+  EXPECT_EQ(6, HeapDijkstra(&graph, 0));
+}
+
+TEST(DIJKSTRA, experiment_3) {
+  Graph *graph = new Graph(8, 13);
+  graph->insert_edge(0, 1, 3);
+  graph->insert_edge(1, 2, 2);
+  graph->insert_edge(1, 3, 4);
+  graph->insert_edge(1, 4, 1);
+  graph->insert_edge(2, 4, 3);
+  graph->insert_edge(2, 5, 10);
+  graph->insert_edge(3, 4, 2);
+  graph->insert_edge(3, 6, 5);
+  graph->insert_edge(4, 5, 7);
+  graph->insert_edge(4, 6, 8);
+  graph->insert_edge(4, 7, 4);
+  graph->insert_edge(5, 7, 6);
+  graph->insert_edge(6, 7, 1);
+  EXPECT_EQ(8, HeapDijkstra(&graph, 0));
+}
+
+TEST(DIJKSTRA, experiment_4) {
+  Graph *graph = new Graph(8, 13);
+  graph->insert_edge(0, 1, 3);
+  graph->insert_edge(1, 2, 1);
+  graph->insert_edge(1, 3, 4);
+  graph->insert_edge(1, 4, 1);
+  graph->insert_edge(2, 4, 1);
+  graph->insert_edge(2, 5, 10);
+  graph->insert_edge(3, 4, 1);
+  graph->insert_edge(3, 6, 1);
+  graph->insert_edge(4, 5, 7);
+  graph->insert_edge(4, 6, 8);
+  graph->insert_edge(4, 7, 4);
+  graph->insert_edge(5, 7, 6);
+  graph->insert_edge(6, 7, 1);
+  EXPECT_EQ(7, HeapDijkstra(&graph, 0));
+}
+
+/*TEST(DIJKSTRA, throws_when_parametrs_are_uncorrect) {
+  std::vector < std::vector < std::pair<int, int> > > graph1;
+  EXPECT_ANY_THROW(std::vector <int> res = TreeDijkstra(graph1, 1));
+  std::vector < std::vector < std::pair<int, int> > > graph2(5);
+  EXPECT_ANY_THROW(std::vector <int> res = TreeDijkstra(graph2, 6));
+}*/
+
+TEST(DIJKSTRA, work_right_with_one_virtex) {
+  std::vector < std::vector < std::pair<int, int> > > graph(1);
+  std::vector <int> res = TreeDijkstra(graph, 1);
+  EXPECT_EQ(res[0], 0);
+}
diff --git a/test/test_RBtree.cpp b/test/test_RBtree.cpp
new file mode 100644
index 0000000..7c039c5
--- /dev/null
+++ b/test/test_RBtree.cpp
@@ -0,0 +1,88 @@
+#include <gtest/gtest.h>
+#include "RBtree.h"
+
+/*TEST(RBTree, can_create_empty_tree) {
+  ASSERT_NO_THROW(RBTree<int> a());
+  RBTree<int> b;
+  EXPECT_EQ(b.get_root(), NullNode);
+}*/
+
+/*TEST(RB_TREE, can_create_tree) {
+  ASSERT_NO_THROW(RBTree<int> tree(5));
+}*/
+
+TEST(RB_TREE, create_tree_correctly) {
+  RBTree<int> tree(5);
+  int res = tree.get_root()->value;
+  EXPECT_EQ(res , 5);
+}
+
+/*TEST(RB_TREE, can_insert) {
+  RBTree<int> tree(5);
+  ASSERT_NO_THROW(tree.RB_insert(3));
+}*/
+
+/*TEST(RB_TREE, can_insert_node_in_empty_tree) {
+  RBTree<int> tree;
+  ASSERT_NO_THROW(tree.RB_insert(1));
+}*/
+
+/*TEST(RB_TREE, throw_when_try_insert_exist_node) {
+  RBTree<int> tree(5);
+  ASSERT_ANY_THROW(tree.RB_insert(5));
+}*/
+
+TEST(RB_TREE, can_find_node) {
+  RBTree<int> tree(5);
+  tree.RB_insert(1);
+  ASSERT_NO_THROW(tree.RB_find(1));
+}
+
+TEST(RB_TREE, find_node_correctly) {
+  RBTree<int> tree(5);
+  tree.RB_insert(4);
+  RBtreeNode<int> *result = tree.RB_find(4);
+  EXPECT_EQ(result->value, 4);
+}
+
+TEST(RB_TREE, throw_when_try_find_dont_exist_node) {
+  RBTree<int> tree(5);
+  tree.RB_insert(1);
+  ASSERT_ANY_THROW(tree.RB_find(3));
+}
+
+TEST(RB_TREE, can_insert_2) {
+  RBTree<int> tree(8);
+  tree.RB_insert(7);
+  ASSERT_NO_THROW(tree.RB_insert(2));
+  ASSERT_NO_THROW(tree.RB_insert(5));
+  ASSERT_NO_THROW(tree.RB_insert(1));
+  ASSERT_NO_THROW(tree.RB_insert(3));
+  ASSERT_NO_THROW(tree.RB_insert(4));
+  ASSERT_NO_THROW(tree.RB_insert(9));
+  ASSERT_NO_THROW(tree.RB_find(4));
+}
+
+TEST(RB_TREE, throw_when_try_delete_dont_exist_node) {
+  RBTree<int> tree(5);
+  tree.RB_insert(2);
+  ASSERT_ANY_THROW(tree.RB_delete(3));
+}
+
+TEST(RB_TREE, can_delete_node_with_no_childs) {
+  RBTree<int> tree(5);
+  tree.RB_insert(2);
+  ASSERT_NO_THROW(tree.RB_delete(2));
+}
+
+TEST(RB_TREE, can_delete_node_with_child) {
+  RBTree<int> tree(6);
+  tree.RB_insert(3);
+  ASSERT_NO_THROW(tree.RB_insert(5));
+  ASSERT_NO_THROW(tree.RB_insert(1));
+  ASSERT_NO_THROW(tree.RB_insert(4));
+  ASSERT_NO_THROW(tree.RB_insert(2));
+  ASSERT_NO_THROW(tree.RB_find(5));
+  ASSERT_NO_THROW(tree.RB_delete(5));
+  ASSERT_ANY_THROW(tree.RB_find(5));
+}
diff --git a/test/test_add.cpp b/test/test_add.cpp
deleted file mode 100644
index 66c2df3..0000000
--- a/test/test_add.cpp
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <gtest/gtest.h>
-#include "add.h"
-
-TEST(Addition, CanAddTwoNumbers) {
-  EXPECT_EQ(add(2, 2), 4);
-  EXPECT_EQ(add(-2, 2), 0);
-}
diff --git a/test/test_d_heap.cpp b/test/test_d_heap.cpp
new file mode 100644
index 0000000..5bb15b0
--- /dev/null
+++ b/test/test_d_heap.cpp
@@ -0,0 +1,290 @@
+#include <gtest/gtest.h>
+#include "d_heap.h"
+
+/*TEST(D_HEAP, can_create_d_heap) {
+  ASSERT_NO_THROW(D_Heap *heap = new D_Heap(2));
+}*/
+
+TEST(D_HEAP, can_insert_new_key) {
+  D_Heap *heap = new D_Heap(2);
+  Data* key = new Data();
+  key->priority = 4;
+  ASSERT_NO_THROW(heap->insert(&key));
+}
+
+TEST(D_HEAP, can_insert_group_in_heap) {
+  Data **g_key = new Data*[4];
+  for (int i = 0; i < 4; i++) {
+    g_key[i] = new Data;
+    g_key[i]->priority = 4;
+  }
+  D_Heap *heap = new D_Heap(2);
+  ASSERT_NO_THROW(heap->insert_group(g_key, 4));
+}
+
+TEST(D_HEAP, can_erase_element) {
+  D_Heap *heap = new D_Heap(2);
+  Data* i = new Data();
+  Data* j = new Data();
+  i->priority = 1;
+  j->priority = 2;
+  heap->insert(&i);
+  heap->insert(&j);
+  ASSERT_NO_THROW(heap->erase());
+}
+
+TEST(D_HEAP, can_make_transposition_of_elements) {
+  D_Heap *heap = new D_Heap(2);
+  Data* i = new Data();
+  Data* j = new Data();
+  i->priority = 1;
+  j->priority = 2;
+  heap->insert(&i);
+  heap->insert(&j);
+  ASSERT_NO_THROW(heap->transposition(0, 1));
+}
+
+TEST(D_HEAP, can_surfacing) {
+  D_Heap *heap = new D_Heap(2);
+  Data* i = new Data();
+  Data* j = new Data();
+  i->priority = 1;
+  j->priority = 2;
+  heap->insert(&i);
+  heap->insert(&j);
+  ASSERT_NO_THROW(heap->surfacing(0));
+}
+
+TEST(D_HEAP, can_immersion) {
+  D_Heap *heap = new D_Heap(2);
+  Data* i = new Data();
+  Data* j = new Data();
+  Data* k = new Data();
+  i->priority = 1;
+  j->priority = 2;
+  j->priority = 3;
+  heap->insert(&i);
+  heap->insert(&j);
+  heap->insert(&k);
+  ASSERT_NO_THROW(heap->immersion(1));
+}
+
+TEST(D_HEAP, correct_work_of_erase) {
+  D_Heap *heap = new D_Heap(2);
+  Data* i = new Data();
+  Data* j = new Data();
+  j->priority = 1;
+  j->priority = 2;
+  heap->insert(&i);
+  heap->insert(&j);
+  Data *k = heap->erase(1);
+  EXPECT_EQ(2, k->priority);
+}
+
+TEST(D_HEAP, correct_work_of_transposition) {
+  D_Heap *heap = new D_Heap(2);
+  Data* i = new Data();
+  Data* j = new Data();
+  i->priority = 1;
+  j->priority = 2;
+  heap->insert(&i);
+  heap->insert(&j);
+  heap->transposition(0, 1);
+  Data* k = heap->erase(1);
+  Data* p = heap->erase(0);
+  EXPECT_EQ(k->priority, 1);
+  EXPECT_EQ(p->priority, 2);
+}
+
+TEST(D_HEAP, immersion_works_correctly) {
+  D_Heap *heap = new D_Heap(2);
+  Data* i = new Data();
+  Data* j = new Data();
+  Data* k = new Data();
+  i->priority = 1;
+  j->priority = 2;
+  j->priority = 3;
+  heap->insert(&i);
+  heap->insert(&j);
+  heap->insert(&k);
+  heap->immersion(1);
+  EXPECT_EQ(1, heap->erase(2)->priority);
+}
+
+TEST(D_HEAP, can_find_min_child_1) {
+  D_Heap *heap = new D_Heap(2);
+  Data* i = new Data();
+  Data* j = new Data();
+  Data* k = new Data();
+  i->priority = 1;
+  j->priority = 2;
+  j->priority = 3;
+  heap->insert(&i);
+  heap->insert(&j);
+  heap->insert(&k);
+  EXPECT_EQ(heap->min_Child(0), 2);
+}
+
+/*TEST(D_HEAP, throw_when_try_create_heap_with_negative_d) {
+  ASSERT_ANY_THROW(D_Heap *heap = new D_Heap(-5));
+}*/
+
+TEST(D_HEAP, throw_when_try_insert_key_into_full_heap) {
+  D_Heap *heap = new D_Heap(2);
+  for (int i = 0; i < MAXsize; i++) {
+    Data* key = new Data();
+    key->priority = 4;
+    heap->insert(&key);
+  }
+  Data *key = new Data();
+  key->priority = 4;
+  ASSERT_ANY_THROW(heap->insert(&key));
+}
+
+TEST(D_HEAP, throw_when_try_insert_group_in_full_heap) {
+  D_Heap *heap = new D_Heap(2);
+  for (int i = 0; i < MAXsize; i++) {
+    Data *key = new Data();
+    key->priority = 4;
+    heap->insert(&key);
+  }
+  Data **g_key = new Data*[4];
+  for (int i = 0; i < 4; i++) {
+    g_key[i] = new Data;
+    g_key[i]->priority = 4;
+  }
+  ASSERT_ANY_THROW(heap->insert_group(g_key, 4));
+}
+
+/*TEST(D_HEAP, throw_when_try_erase_element_from_empty_heap) {
+  D_Heap *heap = new D_Heap(2);
+  ASSERT_ANY_THROW(heap->erase());
+}*/
+
+TEST(D_HEAP, throw_when_try_erase_negative_missing_element) {
+  D_Heap *heap = new D_Heap(2);
+  Data* i = new Data();
+  Data* j = new Data();
+  i->priority = 1;
+  j->priority = 2;
+  heap->insert(&i);
+  heap->insert(&j);
+  ASSERT_ANY_THROW(heap->erase(-1));
+}
+
+TEST(D_HEAP, throw_when_try_erase_missing_element) {
+  D_Heap *heap = new D_Heap(2);
+  Data* i = new Data();
+  Data* j = new Data();
+  i->priority = 1;
+  j->priority = 2;
+  heap->insert(&i);
+  heap->insert(&j);
+  ASSERT_ANY_THROW(heap->erase(3));
+}
+
+TEST(D_HEAP, throw_when_try_make_transposition_elements_with_negative_index) {
+  D_Heap *heap = new D_Heap(2);
+  Data* i = new Data();
+  Data* j = new Data();
+  i->priority = 1;
+  j->priority = 2;
+  heap->insert(&i);
+  heap->insert(&j);
+  ASSERT_ANY_THROW(heap->transposition(-1, 0));
+}
+TEST(D_HEAP, throw_when_try_make_transposition_elements_with_missing_index) {
+  D_Heap *heap = new D_Heap(2);
+  Data* i = new Data();
+  Data* j = new Data();
+  i->priority = 1;
+  j->priority = 2;
+  heap->insert(&i);
+  heap->insert(&j);
+  ASSERT_ANY_THROW(heap->transposition(0, 3));
+}
+
+TEST(D_HEAP, throw_when_try_surfacing_with_negative_index) {
+  D_Heap *heap = new D_Heap(2);
+  Data* i = new Data();
+  Data* j = new Data();
+  i->priority = 1;
+  j->priority = 2;
+  heap->insert(&i);
+  heap->insert(&j);
+  ASSERT_ANY_THROW(heap->surfacing(-1));
+}
+
+TEST(D_HEAP, throw_when_try_surfacing_with_missing_index) {
+  D_Heap *heap = new D_Heap(2);
+  Data* i = new Data();
+  Data* j = new Data();
+  i->priority = 1;
+  j->priority = 2;
+  heap->insert(&i);
+  heap->insert(&j);
+  ASSERT_ANY_THROW(heap->surfacing(3));
+}
+
+TEST(D_HEAP, throw_when_try_immersion_with_missing_index) {
+  D_Heap *heap = new D_Heap(2);
+  Data* i = new Data();
+  Data* j = new Data();
+  Data* k = new Data();
+  i->priority = 1;
+  j->priority = 2;
+  j->priority = 3;
+  heap->insert(&i);
+  heap->insert(&j);
+  heap->insert(&k);
+  ASSERT_ANY_THROW(heap->immersion(3));
+}
+
+TEST(D_HEAP, throw_when_try_immersion_with_negative_index) {
+  D_Heap *heap = new D_Heap(2);
+  Data* i = new Data();
+  Data* j = new Data();
+  Data* k = new Data();
+  i->priority = 1;
+  j->priority = 2;
+  j->priority = 3;
+  heap->insert(&i);
+  heap->insert(&j);
+  heap->insert(&k);
+  ASSERT_ANY_THROW(heap->immersion(-1));
+}
+
+TEST(D_HEAP, isFull_work_correctly) {
+  D_Heap *heap = new D_Heap(2);
+  for (int i = 0; i < MAXsize; i++) {
+    Data* j = new Data();
+    j->priority = 1;
+    heap->insert(&j);
+  }
+  ASSERT_TRUE(heap->isFull());
+}
+
+TEST(D_HEAP, isFull_works_correctly_when_heap_not_full) {
+  D_Heap *heap = new D_Heap(2);
+  Data* j = new Data();
+  j->priority = 1;
+  heap->insert(&j);
+  ASSERT_FALSE(heap->isFull());
+}
+
+TEST(D_HEAP, isEmpty_work_correctly) {
+  D_Heap *heap = new D_Heap(2);
+  Data* j = new Data();
+  j->priority = 1;
+  heap->insert(&j);
+  heap->erase(0);
+  ASSERT_TRUE(heap->isEmpty());
+}
+
+TEST(D_HEAP, isEmpty_works_correctly_when_heap_not_empty) {
+  D_Heap *heap = new D_Heap(2);
+  Data* j = new Data();
+  j->priority = 1;
+  heap->insert(&j);
+  ASSERT_FALSE(heap->isEmpty());
+}
diff --git a/test/test_graph.cpp b/test/test_graph.cpp
new file mode 100644
index 0000000..ff6708a
--- /dev/null
+++ b/test/test_graph.cpp
@@ -0,0 +1,109 @@
+#include <gtest/gtest.h>
+#include "graph.h"
+
+/*TEST(GRAPH, can_create_graph_1) {
+  Graph *graph;
+  ASSERT_NO_THROW(graph = new Graph(2));
+}*/
+
+/*TEST(GRAPH, can_create_graph_2) {
+  Graph *graph;
+  ASSERT_NO_THROW(graph = new Graph(2, 1));
+}*/
+
+/*TEST(GRAPH, can_create_graph) {
+  Graph *graph = new Graph(2);
+  ASSERT_NO_THROW(graph->create_graph(3, 7));
+}*/
+
+/*TEST(GRAPH, can_insert_edge) {
+  Graph *graph = new Graph(2);
+  ASSERT_NO_THROW(graph->insert_edge(0, 1, 2));
+}*/
+
+TEST(GRAPH, can_delete_edge) {
+  Graph *graph = new Graph(2);
+  graph->insert_edge(0, 1, 2);
+  ASSERT_NO_THROW(graph->delete_edge(0, 1));
+}
+
+TEST(GRAPH, can_find_edge_num) {
+  Graph *graph = new Graph(3);
+  graph->insert_edge(0, 1, 2);
+  graph->insert_edge(1, 2, 3);
+  graph->insert_edge(2, 0, 4);
+  ASSERT_NO_THROW(graph->find_edge_num(1, 2));
+}
+
+
+TEST(GRAPH, find_edge_num_work_correctly) {
+  Graph *graph = new Graph(3);
+  graph->insert_edge(0, 1, 2);
+  graph->insert_edge(1, 2, 3);
+  graph->insert_edge(2, 0, 4);
+  EXPECT_EQ(1, graph->find_edge_num(1, 2));
+}
+
+/*TEST(GRAPH, get_ver_work_correctly) {
+  Graph *graph = new Graph(2);
+  EXPECT_EQ(2, graph->get_ver());
+}*/
+
+/*TEST(GRAPH, get_edge_num_work_correctly) {
+  Graph *graph = new Graph(2);
+  EXPECT_EQ(1, graph->get_edge_num());
+}*/
+
+TEST(GRAPH, get_size_work_correctly) {
+  Graph *graph = new Graph(2);
+  graph->insert_edge(0, 1, 2);
+  EXPECT_EQ(1, graph->get_size());
+}
+
+TEST(GRAPH, get_weight_work_correctly) {
+  Graph *graph = new Graph(2);
+  graph->insert_edge(0, 1, 4);
+  EXPECT_EQ(4, graph->get_weight(0, 1));
+}
+
+/*TEST(GRAPH, throw_when_try_create_graph_with_negative_verix) {
+  Graph *graph;
+  ASSERT_ANY_THROW(graph = new Graph(-2));
+}*/
+
+/*TEST(GRAPH, throw_when_try_create_graph_with_too_large_verix) {
+  Graph *graph;
+  ASSERT_ANY_THROW(graph = new Graph(MAXver + 1));
+}*/
+
+/*TEST(GRAPH, throw_when_try_create_graph_with_negative_edge) {
+  Graph *graph;
+  ASSERT_ANY_THROW(graph = new Graph(2, -1));
+}*/
+
+/*TEST(GRAPH, throw_when_try_create_graph_with_too_large_edge) {
+  Graph *graph;
+  ASSERT_ANY_THROW(graph = new Graph(2, 2));
+}*/
+
+/*TEST(GRAPH, throw_when_try_create_graph_with_wrong_weight_limitations) {
+  Graph *graph = new Graph(2);
+  ASSERT_ANY_THROW(graph->create_graph(5, 0));
+}*/
+
+
+/*TEST(GRAPH, throw_when_try_insert_edge_between_one_verix) {
+  Graph *graph = new Graph(2);
+  ASSERT_ANY_THROW(graph->insert_edge(1, 1, 2));
+}*/
+
+TEST(GRAPH, throw_when_try_insert_exist_edge) {
+  Graph *graph = new Graph(2);
+  graph->insert_edge(0, 1, 2);
+  ASSERT_ANY_THROW(graph->insert_edge(0, 1, 2));
+}
+
+/*TEST(GRAPH, throw_when_try_delete_doesnt_exist_edge) {
+  Graph *graph = new Graph(3);
+  ASSERT_ANY_THROW(graph->delete_edge(0, 1));
+}*/
diff --git a/test/test_priority_queue.cpp b/test/test_priority_queue.cpp
new file mode 100644
index 0000000..33f3c0e
--- /dev/null
+++ b/test/test_priority_queue.cpp
@@ -0,0 +1,126 @@
+#include "gtest/gtest.h"
+#include "priority_queue.h"
+
+/*TEST(PRIORITY_QUEUE_ON_HEAP, can_create_priority_queue_1) {
+  ASSERT_NO_THROW(PriorityQueueHeap *q = new PriorityQueueHeap(2));
+}*/
+
+/*TEST(PRIORITY_QUEUE_ON_HEAP, can_create_priority_queue_2) {
+  Data **data = new Data*[3];
+  for (int i = 0; i < 3; i++) {
+    data[i] = new Data;
+    data[i]->priority = 1;
+  }
+  ASSERT_NO_THROW(PriorityQueueHeap *q = new PriorityQueueHeap(data, 3, 2));
+}*/
+
+TEST(PRIORITY_QUEUE_ON_HEAP, can_add_element_in_queue) {
+  PriorityQueueHeap *q = new PriorityQueueHeap(2);
+  Data *tmp = new Data;
+  tmp->priority = 1;
+  ASSERT_NO_THROW(q->add(&tmp));
+}
+TEST(PRIORITY_QUEUE_ON_HEAP, add_in_queue_works_correctly) {
+  PriorityQueueHeap *q = new PriorityQueueHeap(2);
+  Data *tmp = new Data;
+  tmp->priority = 4;
+  q->add(&tmp);
+  EXPECT_EQ(4, q->pop(0)->priority);
+}
+
+/*TEST(PRIORITY_QUEUE_ON_HEAP, throw_when_try_add_element_into_full_queue) {
+  Data **data = new Data*[MAXsize];
+  for (int i = 0; i < MAXsize; i++) {
+    data[i] = new Data;
+    data[i]->priority = i;
+  }
+  PriorityQueueHeap *q = new PriorityQueueHeap(data, MAXsize, 2);
+  Data* tmp = new Data();
+  tmp->priority = 1;
+  ASSERT_ANY_THROW(q->add(&tmp));
+}*/
+
+TEST(PRIORITY_QUEUE_ON_HEAP, can_pop_element) {
+  PriorityQueueHeap*q = new PriorityQueueHeap(2);
+  Data* i = new Data();
+  Data* j = new Data();
+  i->priority = 1;
+  j->priority = 2;
+  q->add(&i);
+  q->add(&j);
+  ASSERT_NO_THROW(q->pop(1));
+}
+
+TEST(PRIORITY_QUEUE_ON_HEAP, pop_works_correctly) {
+  PriorityQueueHeap*q = new PriorityQueueHeap(2);
+  Data* i = new Data();
+  Data* j = new Data();
+  i->priority = 1;
+  j->priority = 2;
+  q->add(&i);
+  q->add(&j);
+  EXPECT_EQ(1, q->pop(0)->priority);
+}
+
+/*TEST(PRIORITY_QUEUE_ON_HEAP, throw_when_try_pop_from_empty_queue) {
+  PriorityQueueHeap *q = new PriorityQueueHeap(2);
+  ASSERT_ANY_THROW(q->pop(0));
+}*/
+
+TEST(PRIORITY_QUEUE_ON_HEAP, can_pop_min_element) {
+  PriorityQueueHeap*q = new PriorityQueueHeap(2);
+  Data* i = new Data();
+  Data* j = new Data();
+  i->priority = 1;
+  j->priority = 2;
+  q->add(&i);
+  q->add(&j);
+  ASSERT_NO_THROW(q->pop_min());
+}
+TEST(PRIORITY_QUEUE_ON_HEAP, pop_min_works_correctly) {
+  PriorityQueueHeap*q = new PriorityQueueHeap(2);
+  Data* i = new Data();
+  Data* j = new Data();
+  i->priority = 1;
+  j->priority = 2;
+  q->add(&i);
+  q->add(&j);
+  EXPECT_EQ(2, q->pop_min()->priority);
+}
+
+/*TEST(PRIORITY_QUEUE_ON_HEAP, throw_when_try_pop_min_from_empty_queue) {
+  PriorityQueueHeap *q = new PriorityQueueHeap(2);
+  ASSERT_ANY_THROW(q->pop_min());
+}*/
+
+/*TEST(PRIORITY_QUEUE_ON_HEAP, isFull_work_correctly) {
+  Data **data = new Data*[MAXsize];
+  for (int i = 0; i < MAXsize; i++) {
+    data[i] = new Data;
+    data[i]->priority = i;
+  }
+  PriorityQueueHeap *q = new PriorityQueueHeap(data, MAXsize, 2);
+  ASSERT_TRUE(q->isFull());
+}*/
+
+/*TEST(PRIORITY_QUEUE_ON_HEAP, isFull_work_correctly_when_queue_is_not_full) {
+  PriorityQueueHeap *q = new PriorityQueueHeap(2);
+  ASSERT_FALSE(q->isFull());
+}*/
+
+TEST(PRIORITY_QUEUE_ON_HEAP, isEmpty_work_correctly) {
+  PriorityQueueHeap *q = new PriorityQueueHeap(2);
+  Data* i = new Data();
+  i->priority = 1;
+  q->add(&i);
+  q->pop(0);
+  ASSERT_TRUE(q->isEmpty());
+}
+
+TEST(PRIORITY_QUEUE_ON_HEAP, isEmpty_work_correctly_when_queue_is_not_empty) {
+  PriorityQueueHeap *q = new PriorityQueueHeap(2);
+  Data* i = new Data();
+  i->priority = 1;
+  q->add(&i);
+  ASSERT_FALSE(q->isEmpty());
+}

From 37f9a9adfb4ddd02518297184f9f815fe596317f Mon Sep 17 00:00:00 2001
From: Usova Marina A <oppabang@mail.ru>
Date: Thu, 27 Apr 2017 19:21:57 +0300
Subject: [PATCH 2/6] Add report

---
 otchet/Otchet_lab_4.doc | Bin 0 -> 281600 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 otchet/Otchet_lab_4.doc

diff --git a/otchet/Otchet_lab_4.doc b/otchet/Otchet_lab_4.doc
new file mode 100644
index 0000000000000000000000000000000000000000..90ee1fd5d50a82ddd3c9870417e9e57e3c5530c6
GIT binary patch
literal 281600
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
W_El?~Z!muE_3n7}(^}oeG4NjzkkESo

literal 0
HcmV?d00001


From 7837553742bb1ac310db5c9679660bb6a318c0b6 Mon Sep 17 00:00:00 2001
From: Usova Marina A <oppabang@mail.ru>
Date: Tue, 23 May 2017 16:25:28 +0300
Subject: [PATCH 3/6] Some corrections

---
 app/main.cpp           | 49 +++++++++++++++++++++++++++++++++++-----
 include/Dijkstra.h     |  2 +-
 include/graph.h        |  1 +
 src/Dijkstra.cpp       | 51 ++++++++++++++++++++++++++----------------
 src/graph.cpp          | 26 +++++++++++++++++++++
 test/test_Dijkstra.cpp | 11 ++-------
 6 files changed, 105 insertions(+), 35 deletions(-)

diff --git a/app/main.cpp b/app/main.cpp
index 8e90d7c..ef8599d 100644
--- a/app/main.cpp
+++ b/app/main.cpp
@@ -2,21 +2,58 @@
 #include "graph.h"
 
 int main() {
-  Graph *graph = new Graph(8, 13);
+  Graph *graph = new Graph(8, 12);
+
   graph->insert_edge(0, 1, 3);
   graph->insert_edge(1, 2, 1);
   graph->insert_edge(1, 3, 4);
-  graph->insert_edge(1, 4, 1);
-  graph->insert_edge(2, 4, 1);
+  graph->insert_edge(1, 4, 4);
   graph->insert_edge(2, 5, 10);
   graph->insert_edge(3, 4, 1);
   graph->insert_edge(3, 6, 1);
-  graph->insert_edge(4, 5, 7);
+  graph->insert_edge(4, 5, 1);
   graph->insert_edge(4, 6, 8);
   graph->insert_edge(4, 7, 4);
   graph->insert_edge(5, 7, 6);
   graph->insert_edge(6, 7, 1);
-  int min = HeapDijkstra(&graph, 0);
-  std::cout << " Min way from start position - " << min << std::endl;
+
+  int min_1 = HeapDijkstra(&graph, 0);
+  std::cout << " Min way from start position to end - " << min_1 << std::endl;
+  
+  std::vector < std::vector < std::pair<int, int> > > g(8);
+  g[0] = std::vector< std::pair<int, int>>(1);
+  g[0][0].first = 1;
+  g[0][0].second = 3;
+  g[1] = std::vector< std::pair<int, int>>(3);
+  g[1][0].first = 2;
+  g[1][0].second = 1;
+  g[1][1].first = 3;
+  g[1][1].second = 4;
+  g[1][2].first = 4;
+  g[1][2].second = 4;
+  g[2] = std::vector< std::pair<int, int>>(1);
+  g[2][0].first = 5;
+  g[2][0].second = 10;
+  g[3] = std::vector< std::pair<int, int>>(2);
+  g[3][0].first = 4;
+  g[3][0].second = 1;
+  g[3][1].first = 6;
+  g[3][1].second = 1;
+  g[4] = std::vector< std::pair<int, int>>(3);
+  g[4][0].first = 5;
+  g[4][0].second = 1;
+  g[4][1].first = 6;
+  g[4][1].second = 8;
+  g[4][2].first = 7;
+  g[4][2].second = 4;
+  g[5] = std::vector< std::pair<int, int>>(1);
+  g[5][0].first = 7;
+  g[5][0].second = 6;
+  g[6] = std::vector< std::pair<int, int>>(1);
+  g[6][0].first = 7;
+  g[6][0].second = 1;
+
+  int min_2 = TreeDijkstra(g, 0);
+  std::cout << " Min way from start position to end - " << min_2 << std::endl;
   return 0;
 }
diff --git a/include/Dijkstra.h b/include/Dijkstra.h
index 3974241..f7c5cd3 100644
--- a/include/Dijkstra.h
+++ b/include/Dijkstra.h
@@ -18,6 +18,6 @@ class Dijkstra_Data: public Data {
 };
 
 int HeapDijkstra(Graph ** _graph, int start);
-std::vector<int> TreeDijkstra(std::vector < std::vector < std::pair<int, int> > > g, int start);
+int TreeDijkstra(std::vector < std::vector < std::pair<int, int> > > g, int start);
 
 #endif  // INCLUDE_DIJKSTRA_H_
diff --git a/include/graph.h b/include/graph.h
index f5a454c..782535a 100644
--- a/include/graph.h
+++ b/include/graph.h
@@ -49,5 +49,6 @@ class Graph {
 };
 
 std::vector < std::vector < std::pair<int, int> > > make_graph(char filename[]);
+Graph create_graph(char *q);
 
 #endif  // INCLUDE_GRAPH_H_
diff --git a/src/Dijkstra.cpp b/src/Dijkstra.cpp
index dd24687..2ec2c26 100644
--- a/src/Dijkstra.cpp
+++ b/src/Dijkstra.cpp
@@ -4,9 +4,9 @@
 
 /*    Алгортм Дейкстры    */
 /*        на д-куче       */
-/* с реализованным графом */
 
 int HeapDijkstra(Graph **_graph, int start) {
+  std::cout << "DIJKSTRA ALGORITHM ON HEAP" << std::endl;
   // проверка корректности входных данных
   int verices = (*_graph)->get_ver();
   if (!verices)
@@ -55,17 +55,19 @@ int HeapDijkstra(Graph **_graph, int start) {
 
   // вывод и удаление (можно было реализовать воврат полученного dist)
   int min;
-  for (int i = 0; i < verices; i++)
-    std::cout << p[i];
   std::cout << std::endl;
+  std::cout << "Process of search shortest way: " << std::endl;
+  for (int i = 1; i < verices; i++) {
+      std::cout << " -> " << p[i];
+  }
+  std::cout << " -> " << verices - 1;
   std::cout << std::endl;
-  std::cout << " WAY: " << std::endl;
   for (int i = 0; i < verices; i++) {
     if (i == start) {
       std::cout << "Start position: " << start << std::endl;
       continue;
     }
-    std::cout << p[i] << " -> " << i << "   " << dist[i]->priority << std::endl;
+    std::cout << start << " -> " << i << "   " << dist[i]->priority << std::endl;
     min = dist[i]->priority;
     delete dist[i];
   }
@@ -76,19 +78,18 @@ int HeapDijkstra(Graph **_graph, int start) {
 
 /*           Алгортм Дейкстры           */
 /*        на красно-чёрных деревьях     */
-/*   со встроенными структурами данных  */
-/*           для описания графа         */
-/*     и реализацией ввода из файла     */
 
-std::vector<int> TreeDijkstra(std::vector < std::vector < std::pair<int, int> > > g, int start) {
+int TreeDijkstra(std::vector < std::vector < std::pair<int, int> > > g, int start) {
+  std::cout << std::endl;
+  std::cout << "DIJKSTRA ALGORITHM ON RB TREE" << std::endl;
   // проверка корректности входных данных
-  if (g.empty() || (start < 1) || (start > static_cast<int>(g.size())))
+  if (g.empty() || (start < 0) || (start > static_cast<int>(g.size())))
     throw std::logic_error("Input error: graph is empty or wrong start virtex.\n");
 
   // подготовка данных для работы алгоритма
-  std::vector<int> d(g.size(), INF);
+  std::vector<int> dist(g.size(), INF);
   int v;
-  d[start - 1] = 0;
+  dist[start] = 0;
   PriorityQueueRBtree < std::pair<int, int> > pq;
   pq.add(std::pair<int, int>(0, start));
 
@@ -96,16 +97,28 @@ std::vector<int> TreeDijkstra(std::vector < std::vector < std::pair<int, int> >
   while (!pq.isEmpty()) {
     std::pair<int, int> current = pq.min()->value;
     pq.pop(current);
-    v = current.second - 1;
+    v = current.second;
     for (int i = 0; i < static_cast<int>(g[v].size()); ++i) {
-      if (d[v] + g[v][i].second < d[g[v][i].first - 1]) {
-        if (d[g[v][i].first - 1] != INF)
-          pq.pop(std::pair<int, int>(d[g[v][i].first - 1],
+      if (dist[v] + g[v][i].second < dist[g[v][i].first]) {
+        if (dist[g[v][i].first] != INF)
+          pq.pop(std::pair<int, int>(dist[g[v][i].first],
             g[v][i].first));
-        d[g[v][i].first - 1] = d[v] + g[v][i].second;
-        pq.add(std::pair<int, int>(d[g[v][i].first - 1], g[v][i].first));
+        dist[g[v][i].first] = dist[v] + g[v][i].second;
+        pq.add(std::pair<int, int>(dist[g[v][i].first], g[v][i].first));
       }
     }
   }
-  return d;
+
+  // вывод (можно было реализовать воврат полученного d)
+  std::cout << std::endl;
+  for (int i = 0; i < dist.size(); i++) {
+    if (i == start) {
+      std::cout << "Start position: " << start << std::endl;
+      continue;
+    }
+    std::cout << start << " -> " << i << "   " << dist[i] << std::endl;
+  }
+  int min = dist[dist.size() - 1];
+  return min;
 }
+
diff --git a/src/graph.cpp b/src/graph.cpp
index c270e90..ad595e2 100644
--- a/src/graph.cpp
+++ b/src/graph.cpp
@@ -3,6 +3,7 @@
 #include <fstream>
 #include <vector>
 #include <utility>
+#include <stdexcept>
 
 /* Конструкторы */
 Graph::Graph(int _ver) {
@@ -151,3 +152,28 @@ std::vector < std::vector < std::pair<int, int> > > make_graph(char filename[])
   }
   return g;
 }
+
+/* Чтение из файла для реализованного графа*/
+Graph create_graph(char *q) {
+  FILE *F;
+  int N = 0, edge_N = 0;
+  F = fopen(q, "r");
+  if (F == NULL) {
+    throw std::logic_error("Input error. Can't open this file.\n");
+  }
+  // считывание количества вершин графа
+  fscanf(F, "%d", &N);
+  Graph g(N);  // граф
+
+  int tmp, num, w;
+  for (int i = 0; i < N; i++) {
+    fscanf(F, "%d", &num);
+    for (int j = 0; j < num; j++) {
+      fscanf(F, "%d", &tmp);
+      fscanf(F, "%d", &w);
+      g.insert_edge(i, tmp, w);
+    }
+  }
+  fclose(F);
+  return g;
+}
diff --git a/test/test_Dijkstra.cpp b/test/test_Dijkstra.cpp
index 82b1875..e06ebfe 100644
--- a/test/test_Dijkstra.cpp
+++ b/test/test_Dijkstra.cpp
@@ -71,15 +71,8 @@ TEST(DIJKSTRA, experiment_4) {
   EXPECT_EQ(7, HeapDijkstra(&graph, 0));
 }
 
-/*TEST(DIJKSTRA, throws_when_parametrs_are_uncorrect) {
-  std::vector < std::vector < std::pair<int, int> > > graph1;
-  EXPECT_ANY_THROW(std::vector <int> res = TreeDijkstra(graph1, 1));
-  std::vector < std::vector < std::pair<int, int> > > graph2(5);
-  EXPECT_ANY_THROW(std::vector <int> res = TreeDijkstra(graph2, 6));
-}*/
-
 TEST(DIJKSTRA, work_right_with_one_virtex) {
   std::vector < std::vector < std::pair<int, int> > > graph(1);
-  std::vector <int> res = TreeDijkstra(graph, 1);
-  EXPECT_EQ(res[0], 0);
+  int res = TreeDijkstra(graph, 0);
+  EXPECT_EQ(res, 0);
 }

From a641559c6c18ec5e1bd91c770b1ae034b7af4835 Mon Sep 17 00:00:00 2001
From: Usova Marina A <oppabang@mail.ru>
Date: Tue, 23 May 2017 16:29:37 +0300
Subject: [PATCH 4/6] Fix cpplint

---
 app/main.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/app/main.cpp b/app/main.cpp
index ef8599d..229c233 100644
--- a/app/main.cpp
+++ b/app/main.cpp
@@ -19,7 +19,7 @@ int main() {
 
   int min_1 = HeapDijkstra(&graph, 0);
   std::cout << " Min way from start position to end - " << min_1 << std::endl;
-  
+
   std::vector < std::vector < std::pair<int, int> > > g(8);
   g[0] = std::vector< std::pair<int, int>>(1);
   g[0][0].first = 1;

From 766892ea540558e281a465180cd48d9516cb8dc5 Mon Sep 17 00:00:00 2001
From: Usova Marina A <oppabang@mail.ru>
Date: Tue, 23 May 2017 16:35:33 +0300
Subject: [PATCH 5/6] Fix cpplint 2

---
 src/Dijkstra.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/Dijkstra.cpp b/src/Dijkstra.cpp
index 2ec2c26..fdaec49 100644
--- a/src/Dijkstra.cpp
+++ b/src/Dijkstra.cpp
@@ -111,14 +111,15 @@ int TreeDijkstra(std::vector < std::vector < std::pair<int, int> > > g, int star
 
   // вывод (можно было реализовать воврат полученного d)
   std::cout << std::endl;
-  for (int i = 0; i < dist.size(); i++) {
+  int size = dist.size();
+  for (int i = 0; i < size; i++) {
     if (i == start) {
       std::cout << "Start position: " << start << std::endl;
       continue;
     }
     std::cout << start << " -> " << i << "   " << dist[i] << std::endl;
   }
-  int min = dist[dist.size() - 1];
+  int min = dist[size - 1];
   return min;
 }
 

From 355984f01f9bc1da4a13d3cb9ebc9d160a7b22bd Mon Sep 17 00:00:00 2001
From: Usova Marina A <oppabang@mail.ru>
Date: Tue, 23 May 2017 16:40:17 +0300
Subject: [PATCH 6/6] Fix cpplint 3

---
 src/graph.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/graph.cpp b/src/graph.cpp
index ad595e2..6baaad4 100644
--- a/src/graph.cpp
+++ b/src/graph.cpp
@@ -156,7 +156,7 @@ std::vector < std::vector < std::pair<int, int> > > make_graph(char filename[])
 /* Чтение из файла для реализованного графа*/
 Graph create_graph(char *q) {
   FILE *F;
-  int N = 0, edge_N = 0;
+  int N = 0;
   F = fopen(q, "r");
   if (F == NULL) {
     throw std::logic_error("Input error. Can't open this file.\n");