diff --git a/lab1/include/Funcs.cpp b/lab1/include/Funcs.cpp
new file mode 100644
index 000000000..2e58b6785
--- /dev/null
+++ b/lab1/include/Funcs.cpp
@@ -0,0 +1,171 @@
+#include"Stack.h"
+#include <string>
+#include"Funcs.h"
+
+using namespace std;
+
+int funcs::checkpriority(char x)
+{
+	int res = 0;
+	if (x == '!') return 0;
+	if (((x >= 'A') && (x <= 'Z')) || ((x >= 'a') && (x <= 'z')))return 5;
+	if ((x == '/') || (x == '*')) return 3;
+	if ((x == '+') || (x == '-')) return 2;
+	if (x == '(')return 0;
+	if (x == ')')return 4;
+	throw"error";
+}
+
+void funcs::calculate(string string)
+{
+	float op, op1, op2;
+	Stack<float> Tstack;
+	map<char, float> valuemap = readvalue(string);
+	for (const char& k : string)
+	{
+		if (((k >= 'A') && (k <= 'Z')) || ((k >= 'a') && (k <= 'z')))
+		{
+			op = valuemap[k];
+			Tstack.Push(op);
+		}
+
+		switch (k)
+		{
+		case'-':
+		{
+			op1 = Tstack.Pop();
+			op2 = Tstack.Pop();
+			Tstack.Push(op2 - op1);
+			break;
+		}
+		case'+':
+		{
+			op1 = Tstack.Pop();
+			op2 = Tstack.Pop();
+			Tstack.Push(op2 + op1);
+			break;
+		}
+		case'*':
+		{
+			op1 = Tstack.Pop();
+			op2 = Tstack.Pop();
+			Tstack.Push(op2*op1);
+			break;
+		}
+		case'/':
+		{
+			op1 = Tstack.Pop();
+			op2 = Tstack.Pop();
+			Tstack.Push(op2 / op1);
+			break;
+		}
+		}
+	}
+	cout << "Результат: " << Tstack.Pop() << endl;
+
+
+}
+
+
+string funcs::postfixform(string string)
+{
+	Stack<char> first;
+	Stack<char> second;
+	int priority, oppriority;
+	for (char el : string)
+	{
+		priority = checkpriority(el);
+		if (priority == 0)//пришла левая скобка
+		{
+			second.Push(el);
+		}
+
+		if (priority == 5)//пришел операнд-кладем в 1й стек
+		{
+			first.Push(el);
+		}
+		if (priority == 2)//пришла операция "+" или "-"
+		{
+			oppriority = checkpriority(second.checktop());
+			if (oppriority <= 2)//если приоритет операции на вершине стека меньше либо равен приоритету операции-кладем операцию во 2й стек
+			{
+				second.Push(el);
+
+			}
+			else//вытаскиваем все операции из ст.2 у которых приоритет выше либо равен приоритеу операции и перекладываем в ст.1
+			{
+				while (checkpriority(second.checktop()) >= 2)
+				{
+					first.Push(second.Pop());
+				}
+				second.Push(el);
+			}
+		}
+		if (priority == 3)//т.к. максимальный приоритет-3,то просто кладем в стек 3;
+		{
+			second.Push(el);
+		}
+		if (priority == 4)
+		{
+			while (checkpriority(second.checktop()) != 0)//перекладываем операции из ст.2 в ст.1 до "("
+			{
+				first.Push(second.Pop());
+			}
+			second.Pop();//изымаем "(" из ст.2
+		}
+	}
+	while (!second.IsEmpty())
+	{
+		first.Push(second.Pop());
+	}
+
+	std::string tmpstring;
+	int j = first.Size();
+	for (int i = 0; i <j; i++)//перекладываем из ст.1 символы из стека в строку
+	{
+		tmpstring = tmpstring + first.Pop();
+	}
+	string.clear();
+	j = tmpstring.size();
+	for (int i = 1; i <= j; i++)
+	{
+		char x = tmpstring[j - i];
+		string = string + x;
+	}
+	return string;
+};
+
+bool funcs::checkcorrectness(string a)
+{
+	int	count = 0;
+	char prev;
+	bool flag = false;
+	for (char k : a)
+	{
+		if (k == '(')
+			count++;
+
+		if (k == ')')
+			count--;
+	}
+	return (count == 0);
+
+};
+
+map<char, float>funcs::readvalue(string str)
+{
+	map<char, float > res;
+	float value;
+	for (const char& c : str)
+	{
+		if (((c >= 'A') && (c <= 'Z')) || ((c >= 'a') && (c <= 'z'))) {
+			if (res.count(c) == 0)
+			{
+				cout << "Введите: " << c << endl;
+				cin >> value;
+				res.insert(pair<char, float>(c, value));
+			}
+		}
+	}
+	return res;
+}
\ No newline at end of file
diff --git a/lab1/include/List.h b/lab1/include/List.h
new file mode 100644
index 000000000..254a3ecf2
--- /dev/null
+++ b/lab1/include/List.h
@@ -0,0 +1,137 @@
+#pragma once
+#include <iostream>
+#include "Node.h"
+using namespace std;
+
+
+template<typename Tkey>
+class List {
+private:
+	Node<Tkey>*root;//указатель на первый элемент списка
+public:
+	List();//конструктор по умолчанию
+	List(const List&);//конструктор копирования
+	~List();//деструктор
+	void insertend(Tkey key);//вставка в конец списка
+	void insertbegin(Tkey key);//вставка в начало списка
+	void remove(Tkey key);//удаление элемента
+	Node<Tkey>* search(Tkey key);//поиск элемента
+	int Size()const;//кол-во элементов списка
+	Node<Tkey>* GetRoot();//получить ссылку на первый элемент списка
+};
+template <typename Tkey>
+List<Tkey>::List()
+{
+	root = nullptr;
+};
+
+template <typename Tkey>
+List<Tkey>::~List()
+{
+	delete root;
+};
+
+template <typename Tkey>
+void List<Tkey>::insertbegin(Tkey key)
+{
+	Node<Tkey>*nNode = new Node<Tkey>;
+	nNode->Key = key;
+	nNode->pNext = root;
+	root = nNode;
+};
+template <typename Tkey>
+void List<Tkey>::insertend(Tkey key)
+{
+	if (root == nullptr)
+	{
+		insertbegin(key);
+		return;
+	}
+	Node*tmp = root;
+	while (tmp->pNext != nullptr)
+	{
+		tmp = tmp->pNext;
+	}
+	tmp->pNext = new Node<Tkey>;
+	tmp->pNext->key = key;
+	tmp->pNext->pNext = nullptr;
+};
+
+template <typename Tkey>
+void List<Tkey>::remove(Tkey key)
+{
+	if (root == nullptr) return;
+	Node<Tkey>*node = root;
+	if (root->Key == key)
+	{
+		root = root->pNext;
+		delete node;
+		return;
+	}
+	while ((node->pNext != nullptr) && (node->pNext->Key != key))
+	{
+		node = node->pNext;
+	}
+
+	if (node->pNext == nullptr)
+	{
+		throw "Element not found";
+	}
+	Node<Tkey>*node1 = node->pNext;
+	node->pNext = node1->pNext;
+	delete node1;
+
+};
+template <typename Tkey>
+Node<Tkey>* List<Tkey>::search(Tkey key)
+{
+	if (root == nullptr) return;
+	Node<Tkey>*node = root;
+	while ((node->pNext != nullptr) && (node->pNext->key != key))
+	{
+		node = node->pNext;
+	}
+	if (node->pNext == nullptr)
+	{
+		throw "Element not found";
+	}
+
+	return node->pNext;
+};
+
+template <typename Tkey>
+Node<Tkey>* List<Tkey>::GetRoot()
+{
+	return root;
+};
+
+template <typename Tkey>
+int List<Tkey>::Size()const
+{
+	Node<Tkey>*node = root;
+	int count = 0;
+	while (node != nullptr)
+	{
+		node = node->pNext;
+		count++;
+	}
+	return count;
+};
+
+template <typename Tkey>
+List<Tkey>::List(const List& a)
+{
+	root = new Node<Tkey>;
+	Node<Tkey>*copy = root;//указатель для элементов нового списка
+	Node<Tkey>*node = a->GetRoot();//указатель для элементов старого списка
+	while (node->pNext != nullptr)
+	{
+		copy->Key = node->Key;
+		copy->pNext = new Node<Tkey>;
+		copy = copy->pNext;
+		node = node->pNext;
+	}
+	copy->Key = node->Key;
+	copy->pNext = new Node<Tkey>;
+	copy->pNext = nullptr;
+};
diff --git a/lab1/include/Node.h b/lab1/include/Node.h
new file mode 100644
index 000000000..13f12cc30
--- /dev/null
+++ b/lab1/include/Node.h
@@ -0,0 +1,8 @@
+#pragma once
+template <typename Tkey>
+class Node
+{
+public:
+	Tkey Key;
+	Node*pNext;
+};
\ No newline at end of file
diff --git a/lab1/include/Stack.h b/lab1/include/Stack.h
new file mode 100644
index 000000000..a768376f1
--- /dev/null
+++ b/lab1/include/Stack.h
@@ -0,0 +1,109 @@
+#pragma once
+#include <iostream>
+#include "List.h"
+
+
+using namespace std;
+
+template <typename Tkey>
+class Stack
+{
+private:
+	List<Tkey>*elems;
+public:
+	Stack();//конструктор по умолчанию
+	Stack(const Stack&);//конструктор копирования
+	~Stack();//деструктор
+	void Push(Tkey a);//добавление элемента в стек
+	Tkey Pop();//изъятие элемента из стека
+	bool IsFull()const;//проверка стека на полноту
+	bool IsEmpty()const;//проверка стека на пустоту
+	int Size()const;//количество элементов в стеке
+	Tkey checktop();//возвращает значение верхнего элемента
+	List<Tkey>* GetList();//доступ к elems 
+};
+
+
+
+template <typename Tkey>
+List<Tkey>* Stack<Tkey>::GetList()
+{
+	return elems;
+}
+
+template <typename Tkey>
+int Stack<Tkey>::Size()const
+{
+	return elems->Size();
+};
+
+template <typename Tkey>
+Tkey Stack<Tkey>::checktop()
+{
+
+	if (IsEmpty())
+		return '!';
+	Tkey res = elems->GetRoot()->Key;
+	return res;
+};
+
+template <typename Tkey>
+Stack<Tkey>::Stack()
+{
+	elems = new List<Tkey>;
+};
+
+template <typename Tkey>
+Stack<Tkey>::~Stack()
+{
+	elems->~List();
+};
+template <typename Tkey>
+bool Stack<Tkey>::IsEmpty()const
+{
+	return (elems->Size() == 0);
+}
+
+
+template <typename Tkey>
+bool Stack<Tkey>::IsFull()const
+{
+	Tkey Key = 1;
+	try
+	{
+		elems->insertbegin(Key);
+		elems->remove(Key);
+	}
+	catch (...)
+	{
+		return true;
+	}
+	return false;
+
+};
+
+template <typename Tkey>
+void Stack<Tkey>::Push(Tkey a)
+{
+	if (IsFull()) {
+		throw "Stack is full";
+	}
+	elems->insertbegin(a);
+}
+
+template <typename Tkey>
+Tkey Stack<Tkey>::Pop()
+{
+	if (IsEmpty())
+		throw "Stack is empty";
+	Tkey Key = elems->GetRoot()->Key;
+	elems->remove(Key);
+	return Key;
+};
+
+template <typename Tkey>
+Stack<Tkey>::Stack(const Stack& a)
+{
+	elems = new List<Tkey>;
+	elems(a->GetList());
+};
\ No newline at end of file
diff --git a/lab1/include/funcs.h b/lab1/include/funcs.h
new file mode 100644
index 000000000..8cd7de434
--- /dev/null
+++ b/lab1/include/funcs.h
@@ -0,0 +1,14 @@
+#pragma once
+#include <map>
+#include"Stack.h"
+#include <string>
+using namespace std;
+class funcs {
+private:
+	static int checkpriority(char);//проверка приоритета у символа
+	static map<char, float> readvalue(string);//формирование контейнера типа map,где ключ-символ операнда,a значение-значение операнда
+public:
+	static void calculate(string);//подсчет арифметического выражения
+	static string postfixform(string);//перевод в постфиксную форму
+	static bool checkcorrectness(string);//проверка строки на корректность
+};
\ No newline at end of file
diff --git a/lab1/sample/main.cpp b/lab1/sample/main.cpp
new file mode 100644
index 000000000..5693a7f2a
--- /dev/null
+++ b/lab1/sample/main.cpp
@@ -0,0 +1,28 @@
+#include <Stack.h>
+#include <string>
+#include <locale>
+#include<iostream>
+#include<funcs.h>
+
+using namespace std;
+int main()
+{
+	setlocale(LC_ALL, "Russian");
+	string string;
+	try {
+		getline(cin, string);
+		while (!funcs::checkcorrectness(string))
+		{
+			cout << "Повторите ввод";
+			getline(cin, string);
+		}
+		string=funcs::postfixform(string);
+		cout << "Постфиксная форма:" << string << endl;
+		funcs::calculate(string);
+	}
+	catch (const char* ex)
+	{
+		cout << ex << endl;
+	}
+
+}
\ No newline at end of file
diff --git "a/lab1/\320\276\321\202\321\207\320\265\321\202.doc" "b/lab1/\320\276\321\202\321\207\320\265\321\202.doc"
new file mode 100644
index 000000000..ff45ee5fb
Binary files /dev/null and "b/lab1/\320\276\321\202\321\207\320\265\321\202.doc" differ
diff --git a/lab2/include/Algorithms.h b/lab2/include/Algorithms.h
new file mode 100644
index 000000000..966950282
--- /dev/null
+++ b/lab2/include/Algorithms.h
@@ -0,0 +1,149 @@
+#pragma once
+#include"Graph.h"
+#include"PQueue.h"
+#include"Dheap.h"
+#include"DisjointSet.h"
+#include"DQueue.h"
+
+struct Vertex
+{
+	int index = 0;
+	double dist = 0;
+	int up = -1;
+	double weight;
+	Vertex(){}
+	Vertex(int index, double dist, int up)
+	{
+		this->dist = dist;
+		this->up = up;
+		this->index = index;
+		weight = dist;
+	}
+
+	bool operator<(const Vertex& p) const
+	{
+		return dist < p.dist; 
+	}
+};
+
+
+template<typename T>
+class Algorithms {
+public:
+	static Graph* Kruskal(Graph&gr, PQueue<T>& queue);
+	static void Sort(T*arr, int n, int d);
+	static vector<Vertex> deikstra(Graph *graph, int s, PQueue<Vertex>* queue);
+};
+
+template<typename T>
+Graph* Algorithms<T>::Kruskal(Graph& gr, PQueue<T>& queue)
+{
+	int n = gr.getsize();
+	int m = gr.getrealsize();
+	Graph* tree=new Graph(n, m);
+	DisjointSet *set = new DisjointSet(n);
+	for (int i = 0; i<n; i++)
+		set->makesets(i);
+
+	for (int i = 0; i<m; i++)
+		queue.push(gr.getEdge(i));
+
+	
+	
+	T tmp;
+
+	while ((tree->getrealsize() < n - 1) && (!queue.IsEmpty()))
+	{
+		tmp = queue.checktop();
+		queue.pop();
+
+		int u = tmp.begin;
+		int v = tmp.end;
+		int weight = tmp.weight;
+
+		int An = set->findsets(u);
+		int Ak = set->findsets(v);
+		if (An != Ak)
+		{
+			set->unionsets(An, Ak);
+			tree->insert(u, v, weight);
+			
+		}
+		
+	}
+
+	return tree;
+}
+
+
+template<typename T>
+void Algorithms<T>::Sort(T*arr, int n, int d)
+{
+	PArr<T>* data=new PArr<T>[n];
+	for (int i = 0; i < n; i++)
+	{
+		data[i].weight = arr[i];
+	}
+	Dheap<PArr<T>> heap(data,n,d);
+	heap.hilling();
+		for (int i = 0; i < n; i++)
+		{
+			arr[i] = heap.checktop().weight;
+			heap.remove(0);
+		}
+}
+
+
+
+vector<Vertex> Algorithms<void>::deikstra(Graph *graph, int s, PQueue<Vertex>* queue)
+{
+	int m = graph->getrealsize();
+	int n = graph->getVerticesNum();
+	if ((s < 0) || (s >= n))
+		throw "Invalid start vertex!";
+	vector<int> vertex = graph->getVertices();
+	vector<double> dist = vector<double>(n, numeric_limits<double>::infinity());
+	vector<int> up = vector<int>(n, -1);
+
+	vector<vector<double>> matrix = vector<vector<double>>(n);
+	for (int i = 0; i < n; i++) {
+		matrix[i] = vector<double>(n, -1.0);
+	}
+	Edge*Edges = graph->getEdges();
+	for (int i = 0; i < m; i++)
+	{
+		matrix[Edges[i].begin][Edges[i].end] = Edges[i].weight;
+		matrix[Edges[i].end][Edges[i].begin] = Edges[i].weight;
+	}
+	dist[s] = 0;
+	queue->push(Vertex(s, dist[s], up[s]));
+
+	while (!queue->IsEmpty())
+	{
+		const Vertex p = queue->checktop();
+		queue->pop();
+		vector<double> weight = matrix[p.index];
+		for (int i = 0; i < weight.size(); i++)
+		{
+			if (weight[i] == -1)
+				continue;
+
+			const double newDist = dist[p.index] + weight[i];
+			if (newDist < dist[i])
+			{
+				dist[i] = newDist;
+				up[i] = p.index;
+				queue->push(Vertex(i, dist[i], up[i]));
+			}
+		}
+	}
+
+	vector<Vertex> result = vector<Vertex>();
+	result.reserve(n);
+	for (int i = 0; i < n; i++)
+	{
+		result.push_back(Vertex(i, dist[i], up[i]));
+	}
+	return result;
+	
+}
\ No newline at end of file
diff --git a/lab2/include/BQueue.h b/lab2/include/BQueue.h
new file mode 100644
index 000000000..9a7cdfc5a
--- /dev/null
+++ b/lab2/include/BQueue.h
@@ -0,0 +1,61 @@
+#pragma once
+#include"PQueue.h"
+#include"btree.h"
+
+template <typename T>
+class BQueue : public PQueue <T>
+{
+private:
+	btree<T> *tree;
+public:
+	BQueue();
+	virtual ~BQueue() { delete tree; };
+
+	virtual void push(const T& a);
+	virtual void pop();
+	virtual bool isEmpty();
+	virtual T top();
+	virtual int GetSize();
+	int operator==(const BQueue<T>&)const;
+};
+
+template <typename T>
+BQueue<T>::BQueue()
+{
+	tree = new btree<T>;
+}
+
+template<typename T>
+void BQueue<T>::push(const T& a)
+{
+	Node<T> *tmp = new Node<T>(a);
+	tree->insert(tree->root, tmp);
+}
+template<typename T>
+void BQueue<T>::pop()
+{
+	tree->remove(tree->root, tree->root->key);
+}
+template<typename T>
+bool BQueue<T>::isEmpty()
+{ 
+	return tree->getsize() == 0; 
+}
+
+template<typename T>
+inline T BQueue<T>::top()
+{
+	return tree->root->key;
+}
+
+template<typename T>
+inline int BQueue<T>::GetSize()
+{
+	 return tree->getsize();
+}
+
+template <typename T>
+int BQueue<T>::operator==(const BQueue<T>& a)const
+{
+	return *tree == *a.tree;
+}
\ No newline at end of file
diff --git a/lab2/include/DHqueue.h b/lab2/include/DHqueue.h
new file mode 100644
index 000000000..dc0cf36b6
--- /dev/null
+++ b/lab2/include/DHqueue.h
@@ -0,0 +1,32 @@
+#pragma once
+#include"PriorityQueue.h"
+#include"Dheap.h"
+template<typename T>
+class DHeapBasePriorityQueue {
+private:
+	Dheap<T>*Dheap;
+public:
+	DheapBasePriorityQueue();
+	virtual T get();
+	virtual void put(T);
+};
+
+template<typename T>
+DHeapBasePriorityQueue<T>::DheapBasePriorityQueue()
+{
+	Dheap = new Dheap<T>;
+}
+
+template<typename T>
+T DHeapBasePriorityQueue<T>::get()
+{
+	T res = Dheap->getlast();
+	Dheap->remove(Dheap->find(res));
+	return res;
+}
+
+template<typename T>
+void DHeapBasePriorityQueue<T>::put(T a)
+{
+	Dheap->insert(a);
+}
diff --git a/lab2/include/DQueue.h b/lab2/include/DQueue.h
new file mode 100644
index 000000000..56d2bac9a
--- /dev/null
+++ b/lab2/include/DQueue.h
@@ -0,0 +1,82 @@
+#pragma once
+#include"PQueue.h"
+#include"Dheap.h"
+
+using namespace std;
+
+template <typename T>
+class DQueue:public PQueue<T> {
+private:
+	Dheap<T>*heap;
+public:
+	DQueue(int);
+	DQueue(Dheap<T>&);
+	virtual ~DQueue() {};
+	void print();
+	
+	void push(T);
+	void pop();
+	T checktop();
+	bool IsFull();
+	bool IsEmpty();
+	void refresh();
+};
+
+template<typename T>
+ DQueue<T>::DQueue(int d)
+{
+	 heap = new Dheap<T>(d);
+
+}
+
+ template<typename T>
+DQueue<T>::DQueue(Dheap<T>& a)
+ {
+	heap = new Dheap<T>(a);
+ }
+
+template<typename T>
+ void DQueue<T>::print()
+{
+	 heap->psevdoprint();
+}
+
+template<typename T>
+void DQueue<T>::push(T elem)
+{
+	heap->insert(elem);
+}
+
+template<typename T>
+void DQueue<T>::pop()
+
+{
+	if (heap->IsEmpty())
+		throw"Pqueue is empty";
+	 heap->remove(0);
+}
+
+ template<typename T>
+ T DQueue<T>::checktop()
+ {
+	 return heap->checktop();
+ }
+
+ template<typename T>
+ bool DQueue<T>::IsFull() {
+	 if (heap->IsFull())
+		 throw "Pqueue is full";
+	 return heap->IsFull();
+
+ }
+ template<typename T>
+ bool DQueue<T>::IsEmpty() {
+
+	 return heap->IsEmpty();
+ }
+
+ template<typename T>
+void DQueue<T>::refresh()
+ {
+	heap->hilling();
+ }
diff --git a/lab2/include/Dheap.h b/lab2/include/Dheap.h
new file mode 100644
index 000000000..3abeb078d
--- /dev/null
+++ b/lab2/include/Dheap.h
@@ -0,0 +1,276 @@
+#pragma once
+#include"Graph.h"
+#include <cmath>
+#define MSIZE 1000;
+
+template<typename K>
+class PArr
+{public:
+	K weight;
+};
+
+template<typename T>
+class Dheap {
+private:
+	int d;//арность кучи
+	int m;//максимальное число элементов
+	T* keys;
+	int freepos;//индекс след элемента
+public:
+	Dheap(int);
+	Dheap(int,int);
+	Dheap(T*,int, int);
+	Dheap(const Dheap<T>&);
+	Dheap( Graph&,int);
+	~Dheap();
+
+	void transpose(int, int);
+	void dipping(int);
+	void surfacing(int);
+	void hilling();
+	int find(T);
+	void insert(T);
+	void remove(int);
+	int min_child(int);
+	bool IsFull();
+	bool IsEmpty();
+	int getparid(int);
+	T checktop();
+	void print();
+	void psevdoprint();
+};
+template <typename T>
+void Dheap<T>::print()
+{
+	int level = 0, tmp = 0;
+	while (tmp < freepos)
+	{
+		tmp += pow(d, level);
+		level++;
+	}
+	int k = 1, z = 0;
+	cout << "\t" << keys[0].weight << endl;
+	for (int i = 1; i < level; i++)
+	{
+		for (int j = k; (j<k + pow(d, i)) && (j < freepos); j++)
+			cout << keys[j].weight << "\t";
+		cout << endl;
+		if (k + pow(d, i) > freepos)
+			k = freepos;
+		else k += pow(d, i);
+	}
+}
+template<typename T>
+ void Dheap<T>::psevdoprint()
+{
+	 for (int i=0;i<freepos;i++)
+	 {
+		 cout << i << "  " << keys[i].weight << endl;
+	 }
+}
+ template<typename T>
+ Dheap<T>::Dheap(int d)
+ {
+	 if (d < 1)
+		 throw"wrong d";
+	  m = MSIZE;
+	  this->d = d;
+	  keys = new T[m];
+	  freepos = 0;
+ }
+ template<typename T>
+ Dheap<T>::Dheap(int _m,int _d)
+ {
+	 d = _d;
+	 m = _m;
+	 freepos = 0;
+	 keys = new T[_m];
+}
+
+ template<typename T>
+ Dheap<T>::Dheap(T *a, int m, int d)
+ {
+	 this->d = d;
+	 this->m = m;
+	 freepos = m;
+	 keys = new T[m];
+	 for (int i = 0; i < m; i++)
+	 {
+		 keys[i] = a[i];
+	 }
+ }
+
+ template<typename T>
+  Dheap<T>::Dheap(const Dheap<T>&a)
+ {
+	  d = a.d;
+	  m = a.m;
+	  keys = new T[m];
+	  freepos = a.freepos;
+	  for(int i=0;i<freepos;i++)
+	  {
+		  keys[i] = a.keys[i];
+	  }
+	 
+ }
+
+ 
+ template<typename T>
+ Dheap<T>::Dheap(Graph& Graph,int _d)
+ {	
+	 d = _d;
+	 m = Graph.getsize();
+	 keys = new T[m];
+	 Edge* a = Graph.getEdges();
+	 for (int i = 0; i < Graph.getsize(); i++)
+	 {
+		 keys[i] = a[i];
+	 }
+	 freepos = m;
+ }
+
+ template<typename T>
+ Dheap<T>::~Dheap()
+ {
+		delete[] keys;
+ }
+
+ template<typename T>
+void Dheap<T>::transpose(int i, int p)
+{
+	T tmp=keys[i];
+	keys[i] = keys[p];
+	keys[p] = tmp;
+}
+
+template<typename T>
+void Dheap<T>::dipping(int i)
+{
+	int s = min_child(i);
+	while ((s != 0) && (keys[i].weight > keys[s].weight))
+	{
+		transpose(i, s);
+		i = s;
+		s = min_child(i);
+	}
+}
+template<typename T>
+void Dheap<T>::surfacing(int i)
+{
+	int p = getparid(i);
+	while ((i != 0) && (keys[p].weight > keys[i].weight))
+	{
+		transpose(i, p);
+		i = p;
+		p = getparid(i);
+	}
+}
+
+ /*template<typename T>
+int Dheap<T>::min_child(int i)
+{
+	int s, min_key,last;
+	s = i*d + 1;
+	if (s>= count) return 0;
+	else {
+		
+		min_key = keys[s].weight;
+		last = (i + 1)*d;
+		if (last >= count) last = count- 1;
+		for (int j = s + 1; j <= last; j++)
+		{
+			if (min_key > keys[j].weight) min_key = keys[j].weight;
+			s = j;
+		}
+		return s;
+	}
+}*/
+template<typename T>
+int Dheap<T>::min_child(int a)
+{
+	int minCh = a*d + 1;
+	int maxCh;
+	if (minCh >= freepos) return 0;
+	if (a*d + d < freepos - 1)
+		maxCh = a*d + d;
+	else maxCh =freepos -1;
+
+	for (int i = minCh; i <= maxCh; i++)
+	{
+		if (keys[i].weight < keys[minCh].weight)
+		{
+			minCh = i;
+		}
+	}
+	return minCh;
+}
+
+
+template<typename T>
+void Dheap<T>::hilling()
+{
+	for (int i = freepos - 1; i >= 0; i--)
+	{
+		dipping(i);
+	}
+}
+
+template<typename T>
+ int Dheap<T>::find(T a)
+{
+	 for (int i = 0; i < m; i++)
+	 {
+		 if (keys[i] == a)return i;
+	 }
+	 throw"Element not found";
+}
+
+ template<typename T>
+void Dheap<T>::insert(T a)
+{
+	if (IsFull())
+		throw "Dheap is full";
+		keys[freepos] = a;
+	freepos++;
+}
+
+template <typename T>
+void Dheap<T>::remove(int i)
+{
+	if (IsEmpty())
+		throw"Dheap is empty";
+	T tmp = keys[freepos - 1];
+	keys[freepos - 1] = keys[i];
+	keys[i] = tmp;
+	freepos--;
+	if ((i != 0) && (keys[i].weight< keys[getparid(i)].weight))
+		surfacing(i);
+	else dipping(i);
+}
+
+
+
+template<typename T>
+bool Dheap<T>::IsFull()
+{
+	return (freepos == m );
+}
+
+template<typename T>
+inline bool Dheap<T>::IsEmpty()
+{
+	return (freepos == 0);
+}
+
+template<typename T>
+int Dheap<T>::getparid(int i)
+{
+	int res = i - 1 / d;
+	return res;
+}
+
+template<typename T>
+T Dheap<T>::checktop()
+{
+	return keys[0];
+}
diff --git a/lab2/include/DisjointSet.h b/lab2/include/DisjointSet.h
new file mode 100644
index 000000000..278111524
--- /dev/null
+++ b/lab2/include/DisjointSet.h
@@ -0,0 +1,84 @@
+#pragma once
+
+
+
+class DisjointSet
+{
+private:
+	int *marks;
+	int *sizes;
+	int n;
+public:
+	DisjointSet(int);
+	~DisjointSet();
+
+	void makesets(int);
+	int findsets(int);
+	void unionsets(int, int);
+
+};
+
+
+DisjointSet::DisjointSet(int i)
+{
+	if (i < 0) throw "the number must be positive";
+	marks = new int[i];
+	for (int j = 0; j < i; j++)
+	{
+		marks[j] = -1;
+	}
+	sizes = new int[i];
+	n = i;
+}
+
+
+DisjointSet::~DisjointSet()
+{
+	delete marks;
+	delete sizes;
+}
+
+void DisjointSet::makesets(int x)
+{
+	if ((x > n) || (x < 0))
+		throw ("out of range");
+
+	if (marks[x] != -1)
+		return;
+
+	marks[x] = x;
+	sizes[x] = 1;
+}
+
+int DisjointSet::findsets(int x)
+{
+	if ((x > n) || (x < 0))
+		throw ("out of range");
+	if (sizes[x] == -1)
+		return -1;
+
+	while (marks[x] != x)
+		x = marks[x];
+	return x;
+}
+
+void DisjointSet::unionsets(int x, int y)
+{
+	if ((x > n) || (x < 0) || (y > n) || (y < 0))
+		throw ("out of range");
+	if ((marks[x] == -1) || (marks[y] == -1))
+		throw ("Set is empty");
+
+	x = findsets(x);
+	y = findsets(y);
+	if (sizes[x] > sizes[y])
+		marks[y] = x;
+	else if (sizes[x] < sizes[y])
+		marks[x] = y;
+	else
+	{
+		marks[y] = x;
+		sizes[x]++;
+	}
+}
+
diff --git a/lab2/include/Edge.h b/lab2/include/Edge.h
new file mode 100644
index 000000000..5b6f35d64
--- /dev/null
+++ b/lab2/include/Edge.h
@@ -0,0 +1,42 @@
+#pragma once
+
+
+struct Edge {
+	int begin;
+	int end;
+	double weight;
+	Edge(int, int, double);
+	Edge();
+	
+	Edge& operator=(Edge&a)
+	{
+		begin = a.begin;
+		end = a.end;
+		weight = a.weight;
+		return *this;
+	}
+};
+
+Edge::Edge()
+{
+	
+}
+
+
+
+Edge::Edge(int a, int b, double c)
+{
+	begin = a;
+	end = b;
+	weight = c;
+}
+
+
+
+bool operator ==(Edge a, Edge b)
+{
+	if ((a.begin == b.begin) && (a.end == b.end) && (a.weight == b.weight))
+		return true;
+	else 
+		return false;
+}
diff --git a/lab2/include/Graph.h b/lab2/include/Graph.h
new file mode 100644
index 000000000..d0daae109
--- /dev/null
+++ b/lab2/include/Graph.h
@@ -0,0 +1,199 @@
+п»ї#pragma once
+#include "Edge.h"
+#include <ctime>
+#include <cstdlib>
+#include <iostream>
+#include<vector>
+#include <algorithm>
+
+
+using namespace std;
+
+
+class Graph {
+private:
+	int m;//число ребер
+	int n;// число вершин
+	Edge* Edges;
+	int current;
+public:
+	Graph(int, int);
+	Graph(Graph&);
+	~Graph();
+
+	void insert(int, int, int);
+	void remove(int, int);
+	int findEdge(int, int);
+	void generate (int, int);
+	int getsize();
+	int getrealsize();
+	Edge getEdge(int);
+	Edge* getEdges();
+	double getWeight(int, int);
+	void print();
+	int getVerticesNum();
+	vector<int> getVertices();
+};
+
+
+
+Graph::Graph(int _m, int _n)
+{
+	if (_n < 0)
+		throw "wrong ver num";
+	else
+		n = _n;
+	if ((_m < 0)|| (_m > _n*(_n - 1) / 2))
+		throw "wrong edge num";
+	m = _m;
+	Edges = new Edge[m];
+	current = 0;
+}
+
+
+Graph::Graph(Graph& a)
+{
+	n = a.n;
+	m = a.m;
+	Edges = new Edge[m];
+	Edge* z = a.getEdges();
+	for (int i = 0; i < m; i++)
+	{
+		Edges[i].begin =z[i].begin;
+		Edges[i].end = z[i].end;
+		Edges[i].weight = z[i].weight;
+	}
+}
+
+
+Graph::~Graph()
+{
+	
+	delete []Edges;
+}
+
+
+int Graph::getsize()
+{
+	return m;
+}
+
+int Graph::getrealsize()
+{
+	return current;
+}
+
+
+Edge Graph::getEdge(int i)
+{
+	return Edges[i];
+}
+
+
+int Graph::findEdge(int a, int b)
+{
+	for (int i = 0; i < current; i++)
+	{
+		if ((Edges[i].begin == a) && (Edges[i].end == b) || (Edges[i].end == a) && (Edges[i].begin == b))
+			return i;
+	}
+	return -1;
+}
+
+
+void Graph::insert(int a, int b, int c)
+{
+	Edge newEdge(a, b, c);
+	if (current == m+1)
+		throw "graph is full";
+	if (a == b)
+		throw "the graph must be simple";
+	if ((a > n) || (b > n))
+		throw ("there are no such vertices");
+
+	Edges[current] = newEdge;
+	current++;
+}
+
+
+void Graph::remove(int a, int b)
+{
+	int tmp = findEdge(a, b);
+	if (tmp == -1)
+		throw ("there is no such edge");
+	Edges[tmp].~Edge();
+	Edges[tmp] = Edges[current - 1];
+	current--;
+}
+
+
+Edge* Graph:: getEdges()
+{
+	return Edges;
+}
+
+double Graph::getWeight(int a, int b)
+{
+	return Edges[findEdge(a, b)].weight;
+}
+
+
+
+void Graph::generate(int a, int b)
+{
+
+	int u, v;
+	double weight;
+	srand(time(NULL));
+	for (int i = 0; i < m; i++)
+	{
+		do
+		{
+			u = rand() % n;
+			v = rand() % n;
+		} while ((u == v) || (findEdge(u, v) != -1));
+
+		weight = a +  (rand()) / ( (RAND_MAX / (b - a)));
+		Edge newEdge(u, v, weight);
+		Edges[i] = newEdge;
+		current++;
+	}
+}
+
+
+void Graph::print()
+{
+	cout << "Edges:" << endl;
+	for (int i = 0; i < n; i++)
+	{
+		for (int j = 0; j < current; j++)
+		{
+			if (Edges[j].begin == i)
+				cout << "(" << Edges[j].begin << ")---(" << Edges[j].end <<")  "<< " (" << Edges[j].weight << ")" << endl;
+		}
+	}
+}
+
+int Graph::getVerticesNum()
+{
+	return n;
+}
+
+vector<int> Graph::getVertices()
+{
+	vector<int> res;
+		for (int i = 0; i < m; i++)
+	{
+			if (find(res.begin(), res.end(), Edges[i].begin) == res.end()) 
+			{
+				res.push_back(Edges[i].begin);
+			}
+			if (find(res.begin(), res.end(), Edges[i].end) == res.end())
+			{
+				res.push_back(Edges[i].end);
+			}
+	}
+	
+
+	return res;
+}
diff --git a/lab2/include/Node.h b/lab2/include/Node.h
new file mode 100644
index 000000000..708fc2ffe
--- /dev/null
+++ b/lab2/include/Node.h
@@ -0,0 +1,12 @@
+#pragma once
+template <typename T>
+class Node
+{
+public:
+	T key;
+	Node<T> *pleft;
+	Node<T> *pright;
+	Node<T> *pparent;
+	Node() { left = nullptr; right = nullptr; parent = nullptr; };
+	Node(const T& k) { key = k; left = nullptr; right = nullptr; parent = nullptr; };
+};
\ No newline at end of file
diff --git a/lab2/include/PQueue.h b/lab2/include/PQueue.h
new file mode 100644
index 000000000..2e6f92ed8
--- /dev/null
+++ b/lab2/include/PQueue.h
@@ -0,0 +1,18 @@
+#pragma once
+#include"Edge.h"
+template<typename T>
+class PQueue
+{
+public:
+	PQueue() {};
+
+	virtual void pop()=0;
+	virtual void push(T)=0;
+	virtual T checktop() = 0;
+	virtual void refresh() = 0;
+
+	virtual bool IsFull()=0;
+	virtual bool IsEmpty()=0;
+	
+	
+};
\ No newline at end of file
diff --git a/lab2/include/btree.h b/lab2/include/btree.h
new file mode 100644
index 000000000..9b0f39252
--- /dev/null
+++ b/lab2/include/btree.h
@@ -0,0 +1,181 @@
+#pragma once
+#include "Node.h"
+using namespace std;
+
+
+
+template <typename T>
+class btree
+{
+public:
+	int size; 
+	Node<T> *root;
+	btree();
+	~btree();
+	btree(const btree<T> &);
+
+	Node<T>* CopyTree(Node<T> *);
+	void insert(Node<T>*, const Node<T> *); 
+	void remove(Node<T>*, const T &); 
+
+	Node<T>* Findkey(Node<T>*, const T &); 
+	Node<T>* FindMax(Node<T>*); 
+	Node<T>* FindMin(Node<T>*); 
+	int getsize();
+	
+};
+
+template <typename T>
+btree<T>::btree()
+{
+	root = nullptr;
+};
+
+template <typename T>
+btree<T>::btree(const btree<T> &a)
+{
+	root = CopyTree(a.root);
+};
+
+template <typename T>
+btree<T>::~btree()
+{
+	delete root;
+};
+
+template <typename T>
+Node<T>* btree<T>::CopyTree(Node<T>*croot)
+{
+	if (croot == nullptr)
+		return nullptr;
+
+	Node<T>* l = CopyTree(croot->left);
+	Node<T>* r = CopyTree(croot->right);
+	Node<T>* tree = new Node<T>;
+	tree->key = croot->key;
+	tree->left = l;
+	tree->right = r;
+	root = tree;
+	return tree;
+};
+
+template <typename T>
+int btree<T>::getSize()
+{
+	return size;
+}
+
+template <typename T>
+void btree<T>::insert(Node<T>* tree, const Node<T> *node)
+{
+	T a = node->key;
+	if (tree == nullptr)
+	{
+		tree = new Node<T>;
+		tree->key = a;
+		size++;
+		return;
+	}
+	Node<T>* tmp = tree;
+	Node<T>* prev = new Node<T>;
+	while (tmp != nullptr)
+	{
+		prev = tmp;
+		if (tmp->key <= a)
+			tmp = tmp->right;
+		else
+			tmp = tmp->left;
+	}
+	if (prev->key <= a)
+		prev->right = new Node<T>(a);
+	else prev->left = new Node<T>(a);
+	size++;
+};
+
+template <typename T>
+void btree<T>::remove(Node<T>* tree, const T &k)
+{
+	Node<T>* x = Findkey(tree, k);
+	if (x == nullptr)
+		return;
+
+	if ((x->left == nullptr) && (x->right == nullptr))
+	{
+		delete x;
+		return;
+	};
+	if ((x->left == nullptr) && (x->right != nullptr))
+	{
+		Node<T>* y = x->right;
+		y->parent = x->parent;
+		if (x->parent == nullptr)
+		{
+			tree = y;
+			return;
+		}
+		if (x->parent->right == x)
+			x->parent->right = y;
+		else
+			x->parent->left = y;
+		tree = y;
+		return;
+	}
+	if ((x->left != nullptr) && (x->right == nullptr))
+	{
+		Node<T>* y = x->left;
+		y->parent = x->parent;
+		if (x->parent->right == x)
+			x->parent->right = y;
+		else
+			x->parent->left = y;
+		delete x;
+		return;
+	}
+	Node<TType>* y = FindMin(x->right);
+	x->key = y->key;
+	y->parent->left = y->right;
+	if (y->right != nullptr)
+		y->right->parent = y->parent;
+	delete y;
+};
+
+template <typename T>
+Node<T>* btree<T>::Findkey(Node<T> *tree, const T &k)
+{
+	while ((tree != nullptr) && (tree->key != k))
+	{
+		if (k < tree->key)
+			tree = tree->left;
+		if (k > tree->key)
+			tree = tree->right;
+	}
+	if (tree == nullptr)
+		return nullptr;
+	return tree;
+};
+
+template <typename T>
+Node<T>*btree<T>::FindMin(Node<T> *tree)
+{
+	if (tree == nullptr)
+		throw "Tree is empty"
+	while (tree->left != nullptr)
+		tree = tree->left;
+	return tree;
+}
+template<typename T>
+int btree<T>::getsize()
+{
+	return size;
+}
+;
+
+template <typename T>
+Node<T>* btree<T>::FindMax(Node<T> *tree)
+{
+	if (tree == nullptr)
+		throw "Tree is empty";
+	while (tree->right != nullptr)
+		tree = tree->right;
+	return tree;
+};
diff --git a/lab2/samples/Deikstra.cpp b/lab2/samples/Deikstra.cpp
new file mode 100644
index 000000000..2d9ca23a6
--- /dev/null
+++ b/lab2/samples/Deikstra.cpp
@@ -0,0 +1,26 @@
+#include"Algorithms.h"
+#include<iostream>
+
+using namespace std;
+
+int main()
+{
+	int n, m,s,d;
+	vector<Vertex> result;
+	cout << "Vvedite kol-vo vershin grafa i kol-vo reber" << endl;
+	cin >> n >> m;
+	cout << "Vvedite arnost D-heap" << endl;
+	cin >> d;
+	DQueue<Vertex>* queue = new DQueue<Vertex>(d);
+	Graph* graph=new Graph(m, n);
+	graph->generate(1, 30);
+	graph->print();
+	cout << "Vvedite nomer startovoi vershini" << endl;
+	cin >> s;
+	result = Algorithms<void>::deikstra(graph, s, queue);
+	for (int i = 0; i < result.size(); i++)
+	{
+		cout << "Vertex:" << result[i].index << " Dist:" << result[i].dist << " Up:" << result[i].up << endl;
+	}
+
+}
\ No newline at end of file
diff --git a/lab2/samples/Kruskal.cpp b/lab2/samples/Kruskal.cpp
new file mode 100644
index 000000000..0e9e76b73
--- /dev/null
+++ b/lab2/samples/Kruskal.cpp
@@ -0,0 +1,24 @@
+#include"Algorithms.h"
+#include <iostream>
+using namespace std;
+int main()
+{
+	try {
+		int n, m, d;
+		cout << "Vvedite kol-vo vershin grafa i kol-vo reber" << endl;
+		cin >> n >> m;
+		Graph graph(m, n);
+		graph.generate(1, 30);
+		graph.print();
+		cout << "Vvedite arnost D-heap" << endl;
+		cin >> d;
+		DQueue<Edge> queue(d);
+		Graph* ResGraph = Algorithms<Edge>::Kruskal(graph, queue);
+		cout << "polucheniy graph" << endl;
+		ResGraph->print();
+	}
+	catch (const char*ex)
+	{
+		cout << endl<<ex;
+	}
+}
\ No newline at end of file
diff --git a/lab2/samples/sort.cpp b/lab2/samples/sort.cpp
new file mode 100644
index 000000000..a4c079251
--- /dev/null
+++ b/lab2/samples/sort.cpp
@@ -0,0 +1,18 @@
+#include"Algorithms.h"
+#include<iostream>
+using namespace std;
+
+int main() {
+	double* Array=new double[10];
+	cout << "Fill array" << endl;
+	for (int i = 0; i < 10; i++)
+	{
+		cin >> Array[i];
+	}
+	Algorithms<double>::Sort(Array, 10, 2);
+	cout<< "Sorted array:" << endl;
+	for (int i = 0; i < 10; i++)
+	{
+		cout<<"Array["<<i<<"]="<<Array[i]<<endl;
+	}
+}
\ No newline at end of file
diff --git "a/lab2/\320\276\321\202\321\207\320\265\321\202.doc" "b/lab2/\320\276\321\202\321\207\320\265\321\202.doc"
new file mode 100644
index 000000000..c3787b635
Binary files /dev/null and "b/lab2/\320\276\321\202\321\207\320\265\321\202.doc" differ