commit 18b53edf4a8b5a31fbc00f63775134a818de7fc6
Author: soikk <76824648+Soikk@users.noreply.github.com>
Date: Sat Oct 30 17:17:21 2021 +0200
A simple collection of tree algorithms made while in school (lol)
diff --git a/include/trees.h b/include/trees.h
new file mode 100644
index 0000000..d4abd40
--- /dev/null
+++ b/include/trees.h
@@ -0,0 +1,53 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct node{
+ int val;
+ struct node *left;
+ struct node *right;
+} node_t;
+
+typedef struct tree{
+ node_t *root;
+} tree_t;
+
+
+node_t* createNode(int val);
+
+tree_t* createTree();
+
+int addNode(node_t *node, int val, const char lr);
+
+int changeNode(node_t *node, int val);
+
+void printNode(node_t node);
+
+void printTree(tree_t);
+
+int nodeDepth(node_t *node);
+
+int treeDepth(tree_t tree);
+
+int nodeEndNodeCount(node_t *node);
+
+int endNodeCount(tree_t tree);
+
+int nodeContainsN(node_t *node, int n);
+
+int treeContainsN(tree_t tree, int n);
+
+int nodeNodeCount(node_t *node);
+
+int nodeCount(tree_t tree);
+
+void putNodeInArray(node_t *node, int *array, int *i);
+
+int putTreeInArray(tree_t tree, int *array);
+
+void sortArray(int *array, int len);
+
+void insertInNode(node_t *node, int *array, int *i);
+
+void insertInTree(tree_t *tree, int *array);
+
+void sortTree(tree_t *tree);
diff --git a/include/trees.h~ b/include/trees.h~
new file mode 100644
index 0000000..5b70530
--- /dev/null
+++ b/include/trees.h~
@@ -0,0 +1,47 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct node{
+ int val;
+ struct node *left;
+ struct node *right;
+} node_t;
+
+typedef struct tree{
+ node_t *root;
+} tree_t;
+
+
+node_t* createNode(int val);
+
+tree_t* createTree();
+
+int addNode(node_t *node, int val, const char lr);
+
+int changeNode(node_t *node, int val);
+
+void printNode(node_t node);
+
+void printTree(tree_t);
+
+int nodeDepth(node_t *node);
+
+int treeDepth(tree_t tree);
+
+int nodeEndNodeCount(node_t *node);
+
+int endNodeCount(tree_t tree);
+
+int nodeContainsN(node_t *node, int n);
+
+int treeContainsN(tree_t tree, int n);
+
+int nodeNodeCount(node_t *node);
+
+int nodeCount(tree_t tree);
+
+void putNodeInArray(node_t *node, int *array, int *i);
+
+int putTreeInArray(tree_t tree, int *array);
+
+void sortTree(tree_t *tree);
diff --git a/main.c b/main.c
new file mode 100644
index 0000000..5e16d8b
--- /dev/null
+++ b/main.c
@@ -0,0 +1,26 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "trees.h"
+
+int main(){
+ tree_t *t1 = createTree();
+ addNode(t1->root, 1, 'l');
+ addNode(t1->root, 2, 'r');
+ addNode(t1->root->left, 11, 'l');
+ addNode(t1->root->left->left, 111, 'l');
+ addNode(t1->root->right, 22, 'r');
+ addNode(t1->root->right, 21, 'l');
+ printTree(*t1);
+ printf("\nDepth: %d\n", treeDepth(*t1));
+ printf("End node count: %d\n", endNodeCount(*t1));
+ printf("Tree contains 2? %d\n", treeContainsN(*t1, 2));
+ printf("Tree contains 3? %d\n", treeContainsN(*t1, 3));
+ printf("Total number of nodes: %d\n", nodeCount(*t1));
+
+ sortTree(t1);
+ printf("Sorted tree:\n");
+ printTree(*t1);
+ printf("\n");
+ return 0;
+
+}
diff --git a/trees.c b/trees.c
new file mode 100644
index 0000000..590185c
--- /dev/null
+++ b/trees.c
@@ -0,0 +1,162 @@
+#include "trees.h"
+
+
+node_t* createNode(int val){
+ node_t *newNode = malloc(sizeof(node_t));
+ newNode->val = val;
+ newNode->left = NULL;
+ newNode->right = NULL;
+ return newNode;
+}
+tree_t* createTree(){
+ tree_t *newTree = malloc(sizeof(tree_t));
+
+ newTree->root = createNode(0);
+ return newTree;
+}
+
+int addNode(node_t *node, int val, const char lr){
+ if(lr == 'l'){
+ node->left = createNode(val);
+ }else if(lr == 'r'){
+ node->right = createNode(val);
+ }else{
+ return -1;
+ }
+ return 0;
+}
+
+int changeNode(node_t *node, int val){
+ if(node){
+ node->val = val;
+ return 0;
+ }
+ return -1;
+}
+
+void printNode(node_t node){
+ printf("( %d ", node.val);
+ if(node.left != NULL){
+ printf("L");
+ printNode(*node.left);
+ }
+ if(node.right != NULL){
+ printf("R");
+ printNode(*node.right);
+ }
+ printf(") ");
+}
+
+void printTree(tree_t tree){
+ printNode(*tree.root);
+}
+
+int nodeDepth(node_t *node){
+ int t = 0;
+ if(node){
+ int l = nodeDepth(node->left);
+ int r = nodeDepth(node->right);
+ t = 1 + ((l>r)?l:r);
+ }
+ return t;
+}
+int treeDepth(tree_t tree){
+ return nodeDepth(tree.root);
+}
+
+int nodeEndNodeCount(node_t *node){
+ int t = 0, l = 0, r = 0;
+ if(node){
+ if(!node->left && !node->right)
+ return 1;
+ else{
+ l = nodeEndNodeCount(node->left);
+ r = nodeEndNodeCount(node->right);
+ }
+ t = l + r;
+ }
+ return t;
+}
+
+int endNodeCount(tree_t tree){
+ return nodeEndNodeCount(tree.root);
+}
+
+int nodeContainsN(node_t *node, int n){
+ if(node){
+ if(node->val == n)
+ return 1;
+ else
+ return nodeContainsN(node->left, n) + nodeContainsN(node->right, n);
+ }
+ return 0;
+}
+
+int treeContainsN(tree_t tree, int n){
+ return nodeContainsN(tree.root, n);
+}
+
+int nodeNodeCount(node_t *node){
+ int t = 0;
+ if(node)
+ t = 1 + nodeNodeCount(node->left) + nodeNodeCount(node->right);
+ return t;
+}
+
+int nodeCount(tree_t tree){
+ return nodeNodeCount(tree.root);
+}
+
+void putNodeInArray(node_t *node, int *array, int *i){
+ if(node){
+ array = realloc(array, ((*i)+1)*sizeof(int));
+ array[*i] = node->val;
+ (*i)++;
+ putNodeInArray(node->left, array, i);
+ putNodeInArray(node->right, array, i);
+ }
+}
+int putTreeInArray(tree_t tree, int *array){
+ int i = 0;
+ putNodeInArray(tree.root, array, &i);
+ return i;
+}
+
+void sortArray(int *array, int len){
+ int sorted = 0;
+ while(!sorted){
+ int changes = 0;
+ for(int i = 0; i < len-1; i++){
+ if(array[i] > array[i+1]){
+ changes++;
+ array[i] += array[i+1];
+ array[i+1] = array[i] - array[i+1];
+ array[i] -= array[i+1];
+ }
+ }
+ if(!changes)
+ sorted = 1;
+ }
+}
+
+void insertInNode(node_t *node, int *array, int *i){
+ if(node->left)
+ insertInNode(node->left, array, i);
+ node->val = array[*i];
+ *i += 1;
+ if(node->right)
+ insertInNode(node->right, array, i);
+}
+
+void insertInTree(tree_t *tree, int *array){
+ int i = 0;
+ insertInNode(tree->root, array, &i);
+}
+
+void sortTree(tree_t *tree){
+ int *numbers = malloc(1*sizeof(int));
+ int t = putTreeInArray(*tree, numbers);
+ sortArray(numbers, t);
+ insertInTree(tree, numbers);
+
+}