mirrors/TheAlgorithms-C
1
0
Fork 0
mirror of https://github.com/TheAlgorithms/C synced 2024-11-22 05:21:49 +03:00
Code Issues Packages Projects Releases Wiki Activity

formatting source-code for b1d92cbdda

Browse Source
This commit is contained in:
github-actions 2020-06-20 11:28:26 +00:00
parent b1d92cbdda
commit 5347e6f87d
3 changed files with 231 additions and 174 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
conversions/c_atoi_str_to_integer.c
View File

@ -4,8 +4,8 @@
* \author [Mohammed YMIK](https://github.com/medymik)W * \author [Mohammed YMIK](https://github.com/medymik)W
* The function convert a string passed to an integer * The function convert a string passed to an integer
*/ */
#include <stdio.h>
#include <assert.h> #include <assert.h>
#include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
@ -15,10 +15,10 @@
*/ */
int c_atoi(const char *str) int c_atoi(const char *str)
{ {
int i; int i;
int sign; int sign;
long value; long value;
long prev; long prev;
i = 0; i = 0;
sign = 1; sign = 1;
@ -63,12 +63,11 @@ int test_c_atoi()
printf("<<<< TEST DONE >>>>\n"); printf("<<<< TEST DONE >>>>\n");
} }
/** /**
* the main function take one argument of type char* * the main function take one argument of type char*
* example : ./program 123 * example : ./program 123
*/ */
int main(int argc, char **argv) int main(int argc, char **argv)
{ {
if (argc == 2) if (argc == 2)
{ {

376
data_structures/binary_trees/threaded_binary_trees.c
View File

@ -23,10 +23,11 @@
/** /**
* Node, the basic data structure of the tree * Node, the basic data structure of the tree
**/ **/
typedef struct Node { typedef struct Node
int data; /**< stores the number */ {
struct Node *llink; /**< link to left child */ int data; /**< stores the number */
struct Node *rlink; /**< link to right child */ struct Node *llink; /**< link to left child */
struct Node *rlink; /**< link to right child */
} node; } node;
/** /**
@ -34,11 +35,12 @@ typedef struct Node {
* param[in] data value to be inserted * param[in] data value to be inserted
* \returns a pointer to the new node * \returns a pointer to the new node
**/ **/
node *create_node(int data) { node *create_node(int data)
node *ptr = (node *)malloc(sizeof(node)); {
ptr->rlink = ptr->llink = NULL; node *ptr = (node *)malloc(sizeof(node));
ptr->data = data; ptr->rlink = ptr->llink = NULL;
return ptr; ptr->data = data;
return ptr;
} }
/** /**
@ -46,33 +48,46 @@ node *create_node(int data) {
* param[in,out] root pointer to node pointer to the topmost node of the tree * param[in,out] root pointer to node pointer to the topmost node of the tree
* param[in] data value to be inserted into the tree * param[in] data value to be inserted into the tree
*/ */
void insert_bt(node **root, int data) { void insert_bt(node **root, int data)
node *new_node = create_node(data); {
node *temp; // to be deleted node *new_node = create_node(data);
node *prev; // keeps track of the parent of the element deleted node *temp; // to be deleted
if (*root == NULL) { node *prev; // keeps track of the parent of the element deleted
*root = new_node; if (*root == NULL)
} else { {
temp = *root; *root = new_node;
prev = NULL;
while (temp != NULL) {
if (new_node->data > temp->data) {
prev = temp;
temp = temp->rlink;
} else if (new_node->data < temp->data) {
prev = temp;
temp = temp->llink;
} else {
return;
}
} }
else
{
temp = *root;
prev = NULL;
while (temp != NULL)
{
if (new_node->data > temp->data)
{
prev = temp;
temp = temp->rlink;
}
else if (new_node->data < temp->data)
{
prev = temp;
temp = temp->llink;
}
else
{
return;
}
}
if (new_node->data > prev->data) { if (new_node->data > prev->data)
prev->rlink = new_node; {
} else { prev->rlink = new_node;
prev->llink = new_node; }
else
{
prev->llink = new_node;
}
} }
}
} }
/** /**
@ -80,58 +95,73 @@ void insert_bt(node **root, int data) {
* \param[in] root node pointer to the topmost node of the tree * \param[in] root node pointer to the topmost node of the tree
* \param[in] ele value searched for * \param[in] ele value searched for
*/ */
void search(node *root, int ele) { void search(node *root, int ele)
node *temp = root; {
while (temp != NULL) { node *temp = root;
if (temp->data == ele) { while (temp != NULL)
break; {
} else if (ele > temp->data) { if (temp->data == ele)
temp = temp->rlink; {
} else { break;
temp = temp->llink; }
else if (ele > temp->data)
{
temp = temp->rlink;
}
else
{
temp = temp->llink;
}
} }
}
if (temp == NULL) { if (temp == NULL)
printf("%s\n", "Element not found."); {
} else printf("%s\n", "Element not found.");
printf("%s\n", "Element found."); }
else
printf("%s\n", "Element found.");
} }
/** /**
* performs inorder traversal * performs inorder traversal
* param[in] curr node pointer to the topmost node of the tree * param[in] curr node pointer to the topmost node of the tree
*/ */
void inorder_display(node *curr) { void inorder_display(node *curr)
if (curr != NULL) { {
inorder_display(curr->llink); if (curr != NULL)
printf("%d\t", curr->data); {
inorder_display(curr->rlink); inorder_display(curr->llink);
} printf("%d\t", curr->data);
inorder_display(curr->rlink);
}
} }
/** /**
* performs postorder traversal * performs postorder traversal
* param[in] curr node pointer to the topmost node of the tree * param[in] curr node pointer to the topmost node of the tree
*/ */
void postorder_display(node *curr) { void postorder_display(node *curr)
if (curr != NULL) { {
postorder_display(curr->llink); if (curr != NULL)
postorder_display(curr->rlink); {
printf("%d\t", curr->data); postorder_display(curr->llink);
} postorder_display(curr->rlink);
printf("%d\t", curr->data);
}
} }
/** /**
* performs preorder traversal * performs preorder traversal
* param[in] curr node pointer to the topmost node of the tree * param[in] curr node pointer to the topmost node of the tree
*/ */
void preorder_display(node *curr) { void preorder_display(node *curr)
if (curr != NULL) { {
printf("%d\t", curr->data); if (curr != NULL)
preorder_display(curr->llink); {
preorder_display(curr->rlink); printf("%d\t", curr->data);
} preorder_display(curr->llink);
preorder_display(curr->rlink);
}
} }
/** /**
@ -140,108 +170,134 @@ void preorder_display(node *curr) {
* param[in,out] root pointer to node pointer to the topmost node of the tree * param[in,out] root pointer to node pointer to the topmost node of the tree
* param[in] ele value to be deleted from the tree * param[in] ele value to be deleted from the tree
*/ */
void delete_bt(node **root, int ele) { void delete_bt(node **root, int ele)
node *temp; {
node *prev; node *temp;
if (*root == NULL) node *prev;
return; if (*root == NULL)
else { return;
temp = *root; else
prev = NULL; {
// search temp = *root;
while (temp != NULL) { prev = NULL;
if (temp->data == ele) { // search
break; while (temp != NULL)
} else if (ele > temp->data) { {
prev = temp; if (temp->data == ele)
temp = temp->rlink; {
} else { break;
prev = temp; }
temp = temp->llink; else if (ele > temp->data)
} {
} prev = temp;
} temp = temp->rlink;
}
if (temp == NULL) else
return; {
else { prev = temp;
node *replacement; // deleted node's replacement temp = temp->llink;
node *t; }
if (temp->llink == NULL && temp->rlink == NULL) { }
replacement = NULL;
} else if (temp->llink == NULL && temp->rlink != NULL) {
replacement = temp->rlink;
} else if (temp->llink != NULL && temp->rlink == NULL) {
replacement = temp->llink;
} else {
replacement = temp->rlink; // replaced with inorder successor
t = replacement;
while (t->llink != NULL) {
t = t->llink;
}
t->llink = temp->llink; // leftmost node of the replacement is linked to
// the left child of the deleted node
} }
if (temp == *root) { if (temp == NULL)
free(*root); return;
*root = replacement; else
} else if (prev->llink == temp) { {
free(prev->llink); node *replacement; // deleted node's replacement
prev->llink = replacement; node *t;
} else if (prev->rlink == temp) { if (temp->llink == NULL && temp->rlink == NULL)
free(prev->rlink); {
prev->rlink = replacement; replacement = NULL;
}
else if (temp->llink == NULL && temp->rlink != NULL)
{
replacement = temp->rlink;
}
else if (temp->llink != NULL && temp->rlink == NULL)
{
replacement = temp->llink;
}
else
{
replacement = temp->rlink; // replaced with inorder successor
t = replacement;
while (t->llink != NULL)
{
t = t->llink;
}
t->llink =
temp->llink; // leftmost node of the replacement is linked to
// the left child of the deleted node
}
if (temp == *root)
{
free(*root);
*root = replacement;
}
else if (prev->llink == temp)
{
free(prev->llink);
prev->llink = replacement;
}
else if (prev->rlink == temp)
{
free(prev->rlink);
prev->rlink = replacement;
}
} }
}
} }
/** /**
* main function * main function
*/ */
int main() { int main()
printf("BINARY THREADED TREE: \n"); {
node *root = NULL; printf("BINARY THREADED TREE: \n");
int choice, n; node *root = NULL;
do { int choice, n;
printf("%s\n", "1. Insert into BT"); do
printf("%s\n", "2. Print BT - inorder"); {
printf("%s\n", "3. Print BT - preorder"); printf("%s\n", "1. Insert into BT");
printf("%s\n", "4. print BT - postorder"); printf("%s\n", "2. Print BT - inorder");
printf("%s\n", "5. delete from BT"); printf("%s\n", "3. Print BT - preorder");
printf("%s\n", "6. search in BT"); printf("%s\n", "4. print BT - postorder");
printf("%s\n", "Type 0 to exit"); printf("%s\n", "5. delete from BT");
scanf("%d", &choice); printf("%s\n", "6. search in BT");
printf("%s\n", "Type 0 to exit");
scanf("%d", &choice);
switch (choice) { switch (choice)
case 1: {
printf("%s\n", "Enter a no:"); case 1:
scanf("%d", &n); printf("%s\n", "Enter a no:");
insert_bt(&root, n); scanf("%d", &n);
break; insert_bt(&root, n);
case 2: break;
inorder_display(root); case 2:
printf("\n"); inorder_display(root);
break; printf("\n");
case 3: break;
preorder_display(root); case 3:
printf("\n"); preorder_display(root);
break; printf("\n");
case 4: break;
postorder_display(root); case 4:
printf("\n"); postorder_display(root);
break; printf("\n");
case 5: break;
printf("%s\n", "Enter a no:"); case 5:
scanf("%d", &n); printf("%s\n", "Enter a no:");
delete_bt(&root, n); scanf("%d", &n);
break; delete_bt(&root, n);
case 6: break;
printf("%s\n", "Enter a no:"); case 6:
scanf("%d", &n); printf("%s\n", "Enter a no:");
search(root, n); scanf("%d", &n);
break; search(root, n);
} break;
} while (choice != 0); }
return 0; } while (choice != 0);
return 0;
} }

10
machine_learning/kohonen_som_trace.c
View File

@ -21,12 +21,14 @@
#endif #endif
#ifndef max #ifndef max
#define max(a, b) (((a) > (b)) ? (a) : (b)) /**< shorthand for maximum value \ #define max(a, b) \
*/ (((a) > (b)) ? (a) : (b)) /**< shorthand for maximum value \
*/
#endif #endif
#ifndef min #ifndef min
#define min(a, b) (((a) < (b)) ? (a) : (b)) /**< shorthand for minimum value \ #define min(a, b) \
*/ (((a) < (b)) ? (a) : (b)) /**< shorthand for minimum value \
*/
#endif #endif
/** /**