nya

graphs/graph.c

@@ -0,0 +1,31 @@
+typedef enum color_t {
+	WHITE, GREY, BLACK
+} color;
+
+// unweighted graph
+
+typedef struct graph_t {
+	char *neibs; // [N*N]
+	size_t N;
+	int unordered;
+} graph;
+
+graph *graph_new(size_t nodesm int is_ordered) {
+	graph *t = (graph *) malloc(sizeof(graph));
+	t->N = nodes;
+	t->unoreded = !is_ordered;
+	t->neibs = (char *) calloc(sizeof(char), nodes * nodes);
+	return t;	
+}
+
+void graph_delete(graph *g) {
+	free(g->neibs);
+	free(g);
+}
+
+void graph_add_edge(graph *t, int from, int to) {
+	t->neibs[from * t->N + to] = 1;
+	if (t->unordered) {
+		t->neibs[to * t->N + from] = 1;
+	}
+}

graphs/main.c

@@ -0,0 +1,6 @@
+#include "queue.c"
+#include "graph.c"
+
+int main() {
+	queue *q = queue_new(5);
+}

graphs/queue.c

@@ -0,0 +1,36 @@
+#include <stdio.h>
+#include <assert.h>
+#include <stdlib.h>
+
+typedef int T;
+typedef struct queue_s {
+	T *body, *begin, *end, *body_end;
+} queue;
+
+queue* queue_new(size_t size) {
+	queue *t = (queue *)malloc(sizeof(queue));
+	assert(t != NULL);
+	t->body = (int *)malloc(sizeof(T)*size);
+	t->begin = t->end = t->body;
+	t->body_end = t->body + size;
+	return t;
+}
+
+void queue_delete(queue *t) {
+	free(t->body);
+	free(t);
+}
+
+void queue_enqueue(queue *t, T el) {
+	assert(t->end < t->body_end);
+	*t->end++ = el;
+}
+
+int queue_empty(queue const *t) {
+	return t->begin == t->end;
+}
+
+T queue_dequeue(queue *t) {
+	return *t->begin++;
+}
+

list_and_trees/double_linked_list.c

@@ -1,208 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-typedef int Data;
-struct Node {
-	struct Node * next;
-	struct Node * prev;
-	Data data;
-};
-
-
-void list_init(struct Node * list);
-void list_insert(struct Node * list, struct Node * t);
-void list_insert_before(struct Node * list, struct Node * t);
-void list_remove(struct Node * t);
-struct Node * list_push_front(struct Node * list, Data d);
-struct Node * list_push_back(struct Node * list, Data d);
-Data list_pop_front(struct Node * list);
-Data list_pop_back(struct Node * list);
-Data list_delete(struct Node * t);
-void list_print (struct Node * list);
-Data list_sum (struct Node * list);
-int list_is_empty(struct Node * list);
-int list_clear(struct Node * list);
-void list_for_each(struct Node * list, void (*func)(Data d, void * param), void * param);
-void print_it(Data d, void * parameter);
-void sum(Data a, void * s);
-
-void list_init(struct Node * list) {
-	list->next = list;
-	list->prev = list;
-	list->data = -1;
-}
-
-void list_print (struct Node * list) {
-	struct Node *ptr = list->next;
-	if (ptr == list) {
-		printf("Empty list\n");
-	}
-	else {
-		while (ptr->next != list) {
-			printf("%d ", ptr->data);
-			//printf("%d [%p](prev is %p, next is %p)\n", ptr->data, ptr, ptr->prev, ptr->next);
-			ptr = ptr->next;
-		}
-		printf("%d\n", ptr->data);
-		//printf("%d [%p](prev is %p, next is %p)\n", ptr->data, ptr, ptr->prev, ptr->next);
-	}
-} 
-
-void list_insert(struct Node * list, struct Node * t) {
-	t->next = list->next;
-	t->prev = list;
-	if (t->next != list) {
-		t->next->prev = t;
-	}
-	else {
-		t->next = list;
-		list->prev = t;
-	}
-	list->next = t;
-}
-
-void list_insert_before(struct Node * list, struct Node * t) {
-	t->next = list;
-	t->prev = list->prev;
-	if (t->prev != list) {
-		t->prev->next = t;
-	}
-	else {
-		t->prev = list;
-		list->next = t;
-	}
-	list->prev = t;
-}
-
-void list_remove(struct Node * t) {
-	t->prev->next = t->next;
-	t->next->prev = t->prev;
-}
-
-struct Node * list_push_front(struct Node * list, Data d) {
-	struct Node *ptr = list->next;
-	struct Node *oth = malloc(sizeof(struct Node));
-	oth->data = d;
-	oth->next = ptr;
-	oth->prev = list;
-	list->next = oth;
-	ptr->prev = oth;
-	return list;
-}
-
-struct Node * list_push_back(struct Node * list, Data d) {
-	struct Node *ptr = list->prev;
-	struct Node *oth = malloc(sizeof(struct Node));
-	oth->data = d;
-	oth->next = list;
-	oth->prev = ptr;
-	list->prev = oth;
-	ptr->next = oth;
-	return list;
-}
-
-int list_is_empty(struct Node * list) {
-	if (list == list->next) {
-		return 1;
-	}
-	return 0;
-}
-
-int list_clear(struct Node * list) {
-	struct Node *ptr = list->next;
-	
-	struct Node *n;
-	while (ptr->next != list) {
-		n = ptr->next;
-		free(ptr);
-		ptr = n;
-	}
-	list->next = list;
-	list->prev = list;
-	return 0;
-}
-
-Data list_pop_front(struct Node * list) {
-	struct Node *ptr = list->next;
-	Data val = ptr->data;
-	list->next = ptr->next;
-	ptr->next->prev = list;
-	free(ptr);
-
-	return val;
-}
-
-Data list_pop_back(struct Node * list) {
-	struct Node *ptr = list->prev;
-	Data val = ptr->data;
-	list->prev = ptr->prev;
-	ptr->prev->next = list;
-	free(ptr);
-
-	return val;
-}
-
-Data list_delete(struct Node * t) {
-	if (t == t->next) {
-		return -1;
-	}
-	t->prev->next = t->next;
-	t->next->prev = t->prev;
-	Data val = t->data;
-	free(t);
-	return val;
-}
-
-void list_for_each(struct Node * list, void (*func)(Data d, void * param), void * param) {
-	struct Node *ptr = list->next;
-	while (ptr->next != list) {
-		func(ptr->data, param);
-		ptr = ptr->next;
-	}
-}
-
-void sum(Data a, void * s) {
-	*(Data *)s += a;
-}
-
-void print_it(Data d, void * param) {
-	FILE * fd = param;
-	fprintf(fd, "%d ", d);
-}
-
-Data list_sum (struct Node * list) {
-	int s = 0;
-	list_for_each(list, sum, &s);
-	return s;
-}
-
-int list_size(struct Node *list) {
-	struct Node *ptr = list->next;
-	if (ptr == list) {
-		return 0;
-	}
-	int len = 1;
-
-	while (ptr->next != list) {
-		ptr = ptr->next;
-		++len;
-	}
-	return len;
-}
-int main() {
-struct Node x[10];
-	struct Node * a = malloc(sizeof(struct Node));
-
-	int i;
-	list_init(a);
-
-	
-	for(i=0; i<10; i++) {
-		x[i].data = i;
-		list_insert(a, &x[i]);
-	}
-	list_print(a);
-	//while(list_delete(a->next));
-	list_clear(a);
-	free(a);
-}

list_and_trees/ejudge/list3.c

@@ -1,54 +0,0 @@
-#include "../double_linked_list.c"
-#define MAX 1000000
-
-int main() {
-	int i, k, l;
-	struct Node * a = malloc(sizeof(struct Node));
-	struct Node * b = malloc(sizeof(struct Node));	
-	list_init(a);
-	list_init(b);
-	int A[5], B[5];
-
-	for (i = 0; i < 5; ++i) {
-		scanf("%d", &A[i]);
-		list_push_back(a, A[i]);
-	}
-	
-	for (i = 0; i < 5; ++i) {
-		scanf("%d", &B[i]);
-		list_push_back(b, B[i]);
-	}
-
-	for (i = 0;; ++i) {
-		if (i == MAX) {
-			printf("botva\n");
-			return 0;
-		}
-		if (list_size(a) == 0) {
-			printf("second %d\n", i);
-			return 0;
-		}
-		if (list_size(b) == 0) {
-			printf("first %d\n", i);
-			return 0;
-		}
-		k = list_pop_front(a);
-		l = list_pop_front(b);
-		if (k == 10 || l == 0) {
-			list_push_back(b, k);
-			list_push_back(b, l);		
-		}
-		else if (k == 0 || l == 10) {
-			list_push_back(a, k);
-			list_push_back(a, l);
-		}
-		else if (k > l) {
-			list_push_back(a, l);
-			list_push_back(a, k);
-		}
-		else {
-			list_push_back(b, k);
-			list_push_back(b, l);	
-		}
-	}
-}

list_and_trees/ejudge/list3_full.c

@@ -1,253 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-typedef int Data;
-struct Node {
-	struct Node * next;
-	struct Node * prev;
-	Data data;
-};
-
-
-void list_init(struct Node * list);
-void list_insert(struct Node * list, struct Node * t);
-void list_insert_before(struct Node * list, struct Node * t);
-void list_remove(struct Node * t);
-struct Node * list_push_front(struct Node * list, Data d);
-struct Node * list_push_back(struct Node * list, Data d);
-Data list_pop_front(struct Node * list);
-Data list_pop_back(struct Node * list);
-Data list_delete(struct Node * t);
-void list_print (struct Node * list);
-Data list_sum (struct Node * list);
-int list_is_empty(struct Node * list);
-int list_clear(struct Node * list);
-void list_for_each(struct Node * list, void (*func)(Data d, void * param), void * param);
-void print_it(Data d, void * parameter);
-void sum(Data a, void * s);
-
-void list_init(struct Node * list) {
-	list->next = list;
-	list->prev = list;
-	list->data = -1;
-}
-
-void list_print (struct Node * list) {
-	struct Node *ptr = list->next;
-	if (ptr == list) {
-		printf("Empty list\n");
-	}
-	else {
-		while (ptr->next != list) {
-			printf("%d ", ptr->data);
-			//printf("%d [%p](prev is %p, next is %p)\n", ptr->data, ptr, ptr->prev, ptr->next);
-			ptr = ptr->next;
-		}
-		printf("%d\n", ptr->data);
-		//printf("%d [%p](prev is %p, next is %p)\n", ptr->data, ptr, ptr->prev, ptr->next);
-	}
-} 
-
-void list_insert(struct Node * list, struct Node * t) {
-	t->next = list->next;
-	t->prev = list;
-	if (t->next != list) {
-		t->next->prev = t;
-	}
-	else {
-		t->next = list;
-		list->prev = t;
-	}
-	list->next = t;
-}
-
-void list_insert_before(struct Node * list, struct Node * t) {
-	t->next = list;
-	t->prev = list->prev;
-	if (t->prev != list) {
-		t->prev->next = t;
-	}
-	else {
-		t->prev = list;
-		list->next = t;
-	}
-	list->prev = t;
-}
-
-void list_remove(struct Node * t) {
-	t->prev->next = t->next;
-	t->next->prev = t->prev;
-}
-
-struct Node * list_push_front(struct Node * list, Data d) {
-	struct Node *ptr = list->next;
-	struct Node *oth = malloc(sizeof(struct Node));
-	oth->data = d;
-	oth->next = ptr;
-	oth->prev = list;
-	list->next = oth;
-	ptr->prev = oth;
-	return list;
-}
-
-struct Node * list_push_back(struct Node * list, Data d) {
-	struct Node *ptr = list->prev;
-	struct Node *oth = malloc(sizeof(struct Node));
-	oth->data = d;
-	oth->next = list;
-	oth->prev = ptr;
-	list->prev = oth;
-	ptr->next = oth;
-	return list;
-}
-
-int list_is_empty(struct Node * list) {
-	if (list == list->next) {
-		return 1;
-	}
-	return 0;
-}
-
-int list_clear(struct Node * list) {
-	struct Node *ptr = list->next;
-	
-	struct Node *n;
-	while (ptr->next != list) {
-		n = ptr->next;
-		free(ptr);
-		ptr = n;
-	}	
-	list->next = list;
-	list->prev = list;
-	return 0;
-}
-
-Data list_pop_front(struct Node * list) {
-	struct Node *ptr = list->next;
-	Data val = ptr->data;
-	list->next = ptr->next;
-	ptr->next->prev = list;
-	free(ptr);
-
-	return val;
-}
-
-Data list_pop_back(struct Node * list) {
-	struct Node *ptr = list->prev;
-	Data val = ptr->data;
-	list->prev = ptr->prev;
-	ptr->prev->next = list;
-	free(ptr);
-
-	return val;
-}
-
-Data list_delete(struct Node * t) {
-	if (t->next == t) {
-		return -1;
-	}
-	t->prev->next = t->next;
-	t->next->prev = t->prev;
-	Data val = t->data;
-	free(t);
-	return val;
-}
-
-void list_for_each(struct Node * list, void (*func)(Data d, void * param), void * param) {
-	struct Node *ptr = list->next;
-	while (ptr->next != list) {
-		func(ptr->data, param);
-		ptr = ptr->next;
-	}
-}
-
-void sum(Data a, void * s) {
-	*(Data *)s += a;
-}
-
-void print_it(Data d, void * param) {
-	FILE * fd = param;
-	fprintf(fd, "%d ", d);
-}
-
-Data list_sum (struct Node * list) {
-	int s = 0;
-	list_for_each(list, sum, &s);
-	return s;
-}
-
-int list_size(struct Node *list) {
-	struct Node *ptr = list->next;
-	if (ptr == list) {
-		return 0;
-	}
-	int len = 1;
-
-	while (ptr->next != list) {
-		ptr = ptr->next;
-		++len;
-	}
-	return len;
-}
-
-#define MAX 1000000
-
-int main() {
-	int i, k, l;
-	struct Node * a = malloc(sizeof(struct Node));
-	struct Node * b = malloc(sizeof(struct Node));	
-	list_init(a);
-	list_init(b);
-	int A[5], B[5];
-
-	for (i = 0; i < 5; ++i) {
-		scanf("%d", &A[i]);
-		list_push_back(a, A[i]);
-	}
-	
-	for (i = 0; i < 5; ++i) {
-		scanf("%d", &B[i]);
-		list_push_back(b, B[i]);
-	}
-	
-	for (i = 0;; ++i) {
-		if (i == MAX) {
-			printf("botva\n");
-			while(list_delete(a->next) != -1);
-			while(list_delete(b->next) != -1);
-			free(a); free(b);
-			return 0;
-		}
-		if (list_size(a) == 0) {
-			printf("second %d\n", i);
-			while(list_delete(b->next) != -1);
-			free(a); free(b);
-			return 0;
-		}
-		if (list_size(b) == 0) {
-			printf("first %d\n", i);
-			while(list_delete(a->next) != -1);
-			free(a); free(b);
-			return 0;
-		}
-		k = list_pop_front(a);
-		l = list_pop_front(b);
-		
-		if ((k == 9) && (l == 0)) {
-			list_push_back(b, k);
-			list_push_back(b, l);		
-		}
-		else if ((k == 0) && (l == 9)) {
-			list_push_back(a, k);
-			list_push_back(a, l);
-		}
-		else if (k > l) {
-			list_push_back(a, k);
-			list_push_back(a, l);
-		}
-		else {
-			list_push_back(b, k);
-			list_push_back(b, l);	
-		}
-	}
-}

list_and_trees/list.c

@@ -1,185 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-typedef int Data;
-struct Node {
-	Data val;
-	struct Node * next;
-};
-struct List {
-		struct Node * head;
-};
-
-
-struct List * list_create ();
-void list_add_first (struct List * list, Data x);
-void list_add_last (struct List * list, Data x);
-Data list_remove_first (struct List * list); 
-Data list_remove_last (struct List * list);
-Data list_get_first (struct List * list);
-Data list_get_last (struct List * list);
-void list_print (struct List * list);
-int list_size(struct List * list);
-void list_clear(struct List * list);
-void list_destroy (struct List * list);
-
-struct List * list_create () {
-	struct List *list = malloc(sizeof(struct List));
-	list->head = NULL;
-	return list;
-}
-
-void list_add_last (struct List * list, Data x) {
-	struct Node *ptr = list->head;
-	if (ptr == NULL) {
-		struct Node *oth = malloc(sizeof(struct Node));
-		oth->val = x;
-		oth->next = NULL;
-		list->head = oth;
-	}
-	else {
-		while (ptr->next != NULL) {
-			ptr = ptr->next; 
-		}
-		struct Node *oth = malloc(sizeof(struct Node));
-		oth->val = x;
-		oth->next = NULL;
-		ptr->next = oth;	
-	}
-}
-
-void list_add_first (struct List * list, Data x) {
-	struct Node *ptr = list->head;
-	if (ptr == NULL) {
-		struct Node *oth = malloc(sizeof(struct Node));
-		oth->val = x;
-		oth->next = NULL;
-		list->head = oth;
-	}
-	else {
-		struct Node *oth = malloc(sizeof(struct Node));
-		oth->val = x;
-		oth->next = ptr;
-		list->head = oth;	
-	}
-}
-
-void list_print(struct List * list) {
-	struct Node *ptr = list->head;
-	if (ptr == NULL) {
-		printf("Empty list\n");
-	}
-	else {
-		while (ptr->next != NULL) {
-			printf("%d ", ptr->val);
-			ptr = ptr->next;
-		}
-		printf("%d\n", ptr->val);
-	}
-}
-
-Data list_remove_first (struct List * list) {
-	struct Node *ptr = list->head;
-	Data val = ptr->val;
-	if (ptr->next == NULL) {
-		list->head = NULL;
-	}
-	else {
-		list->head = list->head->next;
-	}
-	free(ptr);
-	return val;
-} 
-
-Data list_remove_last (struct List * list) {
-	struct Node *ptr = list->head;
-	Data val;
-	if (ptr->next == NULL) {
-		list->head = NULL;
-		val = ptr->val;
-		free(ptr);
-	}
-	else {
-		while (ptr->next->next != NULL) {
-			ptr = ptr->next;
-		}	
-
-		struct Node* lastNode = ptr->next;
-		val = lastNode->val;
-		ptr->next = NULL;
-		free(lastNode);
-	}
-	
-	return val;
-}
-
-Data list_get_first (struct List * list) {
-	return list->head->val;
-}
-
-Data list_get_last (struct List * list) {
-	struct Node *ptr = list->head;	
-	while (ptr->next != NULL) {
-		ptr = ptr->next;
-	}
-	return ptr->val;
-}
-int list_size(struct List * list) {
-	struct Node *ptr = list->head;
-	if (ptr == NULL) {
-		return 0;
-	}
-	int len = 1;
-	while (ptr->next != NULL) {
-		ptr = ptr->next;
-		++len;
-	}
-	return len;
-}
-
-void list_clear(struct List * list) {	
-	struct Node *ptr = list->head;
-	
-	if (ptr == NULL) {
-		free(ptr);
-	}
-	else {
-		struct Node *next;
-		while (ptr->next != NULL) {
-			next = ptr->next;
-			free(ptr);
-			ptr = next;
-		}
-	}
-	list->head = NULL;
-}
-
-void list_destroy (struct List * list) {
-	list_clear(list);
-	free(list);
-}
-int main() {
-	struct List * list = list_create();
-	//printf("%d\n", list_size(list));
-	list_add_last(list, 5);
-	list_add_last(list, 6);
-	list_add_first(list, 3);
-	list_add_last(list, 8);
-	list_add_last(list, 9);
-	list_print(list);
-	printf("Removed - %d\n", list_remove_first(list));
-	list_print(list);
-	printf("Removed - %d\n", list_remove_last(list));
-	list_print(list);
-	printf("%d\n", list_get_first(list));
-	printf("%d\n", list_get_last(list));
-	printf("%d\n", list_size(list));
-	//list_clear(list);
-	list_print(list);
-	list_destroy(list);
-	list_print(list);
-	/*list = list_create();
-	list_add_first(list, 5);
-	list_print(list);
-	list_destroy(list);*/
-}

list_and_trees/trees/tree1.c

@@ -63,8 +63,16 @@ void tree_destroy (struct Node * tree) {
 	}
 	free(tree);
 }
-
+unsigned int tree_height(struct Node * tree){
-/*int main() {
+	unsigned int l, r;
+	if (tree != NULL) {
+		l = (tree->left  != NULL) ? tree_height(tree->left) : 0;
+		r = (tree->right != NULL) ? tree_height(tree->right): 0;
+		return ((l > r) ? l : r) + 1;
+	}
+	return 0;
+}
+int main() {
 	struct Node * tree = NULL;
 	tree = tree_add(tree, 7);
 	//printf("Tree - [%p]\n", tree);
@@ -79,5 +87,6 @@ void tree_destroy (struct Node * tree) {
 	tree = tree_add(tree, 8);
 	//printf("Tree - [%p]\n", tree);
 	tree_print(tree);
+	printf("Tree height - %d\n", tree_height(tree));
 	tree_destroy(tree);
-} */
+} 

list_and_trees/trees/tree3.c

@@ -0,0 +1,87 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef int Data;
+
+struct Node {
+	Data val;            // данные в узле
+	struct Node * left;  // левый ребенок
+	struct Node * right; // правый ребенок
+};
+
+struct Node * tree_add (struct Node * tree, Data x) {	
+	if (tree == NULL) {
+		struct Node * data = malloc(sizeof(struct Node));
+		data->left = NULL; data->right = NULL;
+		data->val = x;
+		//printf("Init tree - %d[%p]\n", data->val, data);
+		return data;
+	}
+
+	if (x < tree->val) {
+		if (tree->left == NULL) {
+			struct Node * data = malloc(sizeof(struct Node));
+			data->left = NULL; data->right = NULL;
+			data->val = x;
+			tree->left = data;
+			//printf("Added - %d [%p] to node %d[%p] left[%p], right[%p]\n", x, data, tree->val, tree, tree->left, tree->right );
+		}
+		else {
+			tree_add(tree->left, x);
+		}
+	}
+	if (x > tree->val) {
+		if (tree->right == NULL) {
+			struct Node * data = malloc(sizeof(struct Node));
+			data->left = NULL; data->right = NULL;
+			data->val = x;
+			tree->right = data;
+			//printf("Added - %d [%p] to node %d[%p] left[%p], right[%p]\n", x, data, tree->val ,tree, tree->left, tree->right );
+		}
+		else {
+			tree_add(tree->right, x);
+		}
+	}
+	return tree;
+	
+}
+
+void tree_print (struct Node * tree) {
+	if (tree != NULL) {
+		tree_print(tree->left);
+		printf("%d ", tree->val);
+		tree_print(tree->right);
+	}
+}
+
+void tree_destroy (struct Node * tree) {
+	if (tree->left != NULL) {
+		tree_destroy(tree->left);
+	}
+	if(tree->right != NULL) {
+		tree_destroy(tree->right);
+	}
+	free(tree);
+}
+unsigned int tree_height(struct Node * tree){
+	unsigned int l, r;
+	if (tree != NULL) {
+		l = (tree->left  != NULL) ? tree_height(tree->left) : 0;
+		r = (tree->right != NULL) ? tree_height(tree->right): 0;
+		return ((l > r) ? l : r) + 1;
+	}
+	return 0;
+}
+int main() {
+	int i;
+
+	struct Node * tree = NULL;
+	scanf("%d", &i);
+	while (i) {
+		tree = tree_add(tree, i);
+		scanf("%d", &i);	
+	}
+
+	printf("%d\n", tree_height(tree));
+	tree_destroy(tree);
+} 

sort/main.c

@@ -0,0 +1,30 @@
+#include <stdio.h>
+#include <stdbool.h>
+#include <time.h>
+#include <stdlib.h>
+#include "sorts.c"
+#define ALEN 1000
+#define DISPLEN 25
+#define THRESHOLD 25
+
+int main() {
+	srand(time(NULL));
+	int a[ALEN];
+	for (int i = 0; i < ALEN; a[i++] = rand() % (2 * ALEN));
+
+	printf("Before:\n");
+	for (int i = 0; i < DISPLEN; ++i) {
+		printf("%d ", a[i]);
+	}
+	putchar('\n');
+
+	//bubblesort(a, ALEN);
+	insertion(a, ALEN);
+	printf("After:\n");
+	for (int i = 0; i < DISPLEN; ++i) {
+		printf("%d ", a[i]);
+	}
+	putchar('\n');
+
+	return 0;
+}

sort/sorts.c

@@ -0,0 +1,63 @@
+void bubblesort(int *a, int n);
+
+void insertion(int *a, int n);
+
+/* Сортировка пузырьком, сложность - O(n^2), устойчива */
+void bubblesort(int *a, int n) {
+	bool sorted = false;
+	while (!sorted) {
+		sorted = true;
+		for (int i = 0; i < n-1; i++) {
+			if (a[i] > a[i+1]) {
+				int t = a[i];
+				a[i] = a[i+1];
+				a[i+1] = t;
+				sorted = false;
+			}
+		}
+		n--;
+	}
+}
+
+/* Сортировка вставками, для упорядоченного массива - O(n), в худшем случае - O(n^2), устойчива */
+void insertion(int *a, int n) {
+	for (int i = n-1; i > 0; i--) {
+		if (a[i-1] > a[i]) {
+			int t = a[i-1]; a[i-1] = a[i]; a[i] = t;
+		}
+	}
+	for (int i = 2; i < n; i++) {
+		int j = i;
+		int tmp = a[i];
+		while (tmp < a[j-1]) {
+			a[j] = a[j-1]; j--;
+		}
+		a[j] = tmp;
+	}
+}
+
+/* Функция слияния двух массивов, сложность - O(n) */
+void merge(int *a, int low, int mid, int high, int *aux) {
+   int i,j;
+   for (i = mid+1; i > low; i--) aux[i-1] = a[i-1];
+   for (j = mid; j < high; j++) aux[high+mid-j]=a[j+1];
+   for (int k = low; k <= high; k++) {
+      if (aux[j] < aux[i])
+         a[k] = aux[j--];
+      else
+         a[k] = aux[i++];
+   }
+}
+
+void mergeSort(int *a, int low, int high) {
+	if (high - low < THRESHOLD) {
+		insertion(a, high-low);
+	}
+	else {
+		int mid = (low + high)/2;
+		mergeSort(a, low, mid);
+		mergeSort(a, mid+1, high);
+		merge(a, low, mid, high);
+
+	}
+}