mirror of
https://github.com/TheAlgorithms/C
synced 2024-11-22 05:21:49 +03:00
Merge pull request #269 from ketan-lambat/master
avltree, cantorSet added
This commit is contained in:
Ashwek Swamy
GitHub
commit
aeaf03378b
431
data_structures/binary_trees/avl.c
Normal file
431
data_structures/binary_trees/avl.c
Normal file
@ -0,0 +1,431 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
struct AVLnode
|
||||
{
|
||||
int key;
|
||||
struct AVLnode *left;
|
||||
struct AVLnode *right;
|
||||
int height;
|
||||
};
|
||||
typedef struct AVLnode avlNode;
|
||||
|
||||
int max(int a, int b)
|
||||
{
|
||||
return (a > b)? a : b;
|
||||
}
|
||||
|
||||
avlNode *newNode(int key)
|
||||
{
|
||||
avlNode *node = (avlNode*)malloc(sizeof(avlNode));
|
||||
|
||||
if(node == NULL)
|
||||
printf("!! Out of Space !!\n");
|
||||
else
|
||||
{
|
||||
node->key = key;
|
||||
node->left = NULL;
|
||||
node->right = NULL;
|
||||
node->height = 0;
|
||||
}
|
||||
|
||||
return node;
|
||||
}
|
||||
|
||||
int nodeHeight(avlNode *node)
|
||||
{
|
||||
if(node == NULL)
|
||||
return -1;
|
||||
else
|
||||
return(node->height);
|
||||
}
|
||||
|
||||
int heightDiff(avlNode *node)
|
||||
{
|
||||
if(node == NULL)
|
||||
return 0;
|
||||
else
|
||||
return(nodeHeight(node->left) - nodeHeight(node->right));
|
||||
}
|
||||
|
||||
/* Returns the node with min key in the left subtree*/
|
||||
avlNode *minNode(avlNode *node)
|
||||
{
|
||||
avlNode *temp = node;
|
||||
|
||||
while(temp->left != NULL)
|
||||
temp = temp->left;
|
||||
|
||||
return temp;
|
||||
}
|
||||
|
||||
void printAVL(avlNode *node, int level)
|
||||
{
|
||||
int i;
|
||||
if(node!=NULL)
|
||||
{
|
||||
printAVL(node->right, level+1);
|
||||
printf("\n\n");
|
||||
|
||||
for(i=0; i<level; i++)
|
||||
printf("\t");
|
||||
|
||||
printf("%d", node->key);
|
||||
|
||||
printAVL(node->left, level+1);
|
||||
}
|
||||
}
|
||||
|
||||
avlNode *rightRotate(avlNode *z)
|
||||
{
|
||||
avlNode *y = z->left;
|
||||
avlNode *T3 = y->right;
|
||||
|
||||
y->right = z;
|
||||
z->left = T3;
|
||||
|
||||
z->height = (max(nodeHeight(z->left), nodeHeight(z->right)) + 1);
|
||||
y->height = (max(nodeHeight(y->left), nodeHeight(y->right)) + 1);
|
||||
|
||||
return y;
|
||||
}
|
||||
|
||||
avlNode *leftRotate(avlNode *z)
|
||||
{
|
||||
avlNode *y = z->right;
|
||||
avlNode *T3 = y->left;
|
||||
|
||||
y->left = z;
|
||||
z->right = T3;
|
||||
|
||||
z->height = (max(nodeHeight(z->left), nodeHeight(z->right)) + 1);
|
||||
y->height = (max(nodeHeight(y->left), nodeHeight(y->right)) + 1);
|
||||
|
||||
return y;
|
||||
}
|
||||
|
||||
avlNode *LeftRightRotate(avlNode *z)
|
||||
{
|
||||
z->left = leftRotate(z->left);
|
||||
|
||||
return (rightRotate(z));
|
||||
}
|
||||
|
||||
avlNode *RightLeftRotate(avlNode *z)
|
||||
{
|
||||
z->right = rightRotate(z->right);
|
||||
|
||||
return (leftRotate(z));
|
||||
}
|
||||
|
||||
avlNode *insert(avlNode *node, int key)
|
||||
{
|
||||
|
||||
if(node == NULL)
|
||||
return (newNode(key));
|
||||
|
||||
/*Binary Search Tree insertion*/
|
||||
|
||||
if(key < node->key)
|
||||
node->left = insert(node->left, key); /*Recursive insertion in L subtree*/
|
||||
else if(key > node->key)
|
||||
node->right = insert(node->right, key); /*Recursive insertion in R subtree*/
|
||||
|
||||
/* Node Height as per the AVL formula*/
|
||||
node->height = (max(nodeHeight(node->left), nodeHeight(node->right)) + 1);
|
||||
|
||||
|
||||
/*Checking for the balance condition*/
|
||||
int balance = heightDiff(node);
|
||||
|
||||
/*Left Left */
|
||||
if(balance>1 && key < (node->left->key))
|
||||
return rightRotate(node);
|
||||
|
||||
/*Right Right */
|
||||
if(balance<-1 && key > (node->right->key))
|
||||
return leftRotate(node);
|
||||
|
||||
/*Left Right */
|
||||
if (balance>1 && key > (node->left->key))
|
||||
{
|
||||
node = LeftRightRotate(node);
|
||||
}
|
||||
|
||||
/*Right Left */
|
||||
if (balance<-1 && key < (node->right->key))
|
||||
{
|
||||
node = RightLeftRotate(node);
|
||||
}
|
||||
|
||||
return node;
|
||||
|
||||
}
|
||||
|
||||
avlNode *delete(avlNode *node, int queryNum)
|
||||
{
|
||||
if(node == NULL)
|
||||
return node;
|
||||
|
||||
if(queryNum < node->key)
|
||||
node->left = delete(node->left, queryNum); /*Recursive deletion in L subtree*/
|
||||
else if(queryNum > node->key)
|
||||
node->right = delete(node->right, queryNum); /*Recursive deletion in R subtree*/
|
||||
else
|
||||
{
|
||||
/*Single or No Child*/
|
||||
if((node->left == NULL) || (node->right==NULL))
|
||||
{
|
||||
avlNode *temp = node->left ?
|
||||
node->left :
|
||||
node->right;
|
||||
|
||||
/* No Child*/
|
||||
if(temp == NULL)
|
||||
{
|
||||
temp = node;
|
||||
node = NULL;
|
||||
}
|
||||
else /*Single Child : copy data to the parent*/
|
||||
*node = *temp;
|
||||
|
||||
free(temp);
|
||||
}
|
||||
else
|
||||
{
|
||||
/*Two Child*/
|
||||
|
||||
/*Get the smallest key in the R subtree*/
|
||||
avlNode *temp = minNode(node->right);
|
||||
node->key = temp->key; /*Copy that to the root*/
|
||||
node->right = delete(node->right, temp->key); /*Delete the smallest in the R subtree.*/
|
||||
}
|
||||
}
|
||||
|
||||
/*single node in tree*/
|
||||
if(node == NULL)
|
||||
return node;
|
||||
|
||||
|
||||
/*Update height*/
|
||||
node->height = (max(nodeHeight(node->left), nodeHeight(node->right)) + 1);
|
||||
|
||||
int balance = heightDiff(node);
|
||||
|
||||
/*Left Left */
|
||||
if((balance>1) && (heightDiff(node->left) >= 0))
|
||||
return rightRotate(node);
|
||||
|
||||
/*Left Right */
|
||||
if ((balance>1) && (heightDiff(node->left) < 0))
|
||||
{
|
||||
node = LeftRightRotate(node);
|
||||
}
|
||||
|
||||
/*Right Right */
|
||||
if((balance<-1) && (heightDiff(node->right) >= 0))
|
||||
return leftRotate(node);
|
||||
|
||||
/*Right Left */
|
||||
if ((balance<-1) && (heightDiff(node->right) < 0))
|
||||
{
|
||||
node = RightLeftRotate(node);
|
||||
}
|
||||
|
||||
return node;
|
||||
|
||||
}
|
||||
|
||||
avlNode *findNode(avlNode *node, int queryNum)
|
||||
{
|
||||
if(node!=NULL)
|
||||
{
|
||||
if(queryNum < node->key)
|
||||
node = findNode(node->left, queryNum);
|
||||
else if(queryNum > node->key)
|
||||
node = findNode(node->right, queryNum);
|
||||
}
|
||||
|
||||
return node;
|
||||
}
|
||||
|
||||
void printPreOrder(avlNode *node)
|
||||
{
|
||||
if(node == NULL)
|
||||
return;
|
||||
|
||||
printf(" %d ", (node->key));
|
||||
printPreOrder(node->left);
|
||||
printPreOrder(node->right);
|
||||
}
|
||||
|
||||
void printInOrder(avlNode *node)
|
||||
{
|
||||
if(node == NULL)
|
||||
return;
|
||||
printInOrder(node->left);
|
||||
printf(" %d ", (node->key));
|
||||
printInOrder(node->right);
|
||||
}
|
||||
|
||||
void printPostOrder(avlNode *node)
|
||||
{
|
||||
if(node == NULL)
|
||||
return;
|
||||
printPostOrder(node->left);
|
||||
printPostOrder(node->right);
|
||||
printf(" %d ", (node->key));
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
int choice;
|
||||
int flag=1;
|
||||
int insertNum;
|
||||
int queryNum;
|
||||
|
||||
avlNode *root = NULL;
|
||||
avlNode *tempNode;
|
||||
|
||||
while(flag == 1)
|
||||
{
|
||||
printf("\n\nEnter the Step to Run : \n");
|
||||
|
||||
printf("\t1: Insert a node into AVL tree\n");
|
||||
printf("\t2: Delete a node in AVL tree\n");
|
||||
printf("\t3: Search a node into AVL tree\n");
|
||||
printf("\t4: printPreOrder (Ro L R) Tree\n");
|
||||
printf("\t5: printInOrder (L Ro R) Tree\n");
|
||||
printf("\t6: printPostOrder (L R Ro) Tree\n");
|
||||
printf("\t7: printAVL Tree\n");
|
||||
|
||||
printf("\t0: EXIT\n");
|
||||
scanf("%d", &choice);
|
||||
|
||||
switch(choice)
|
||||
{
|
||||
case 0:
|
||||
{
|
||||
flag=0;
|
||||
printf("\n\t\tExiting, Thank You !!\n");
|
||||
break;
|
||||
}
|
||||
|
||||
case 1:
|
||||
{
|
||||
|
||||
printf("\n\tEnter the Number to insert: ");
|
||||
scanf("%d", &insertNum);
|
||||
|
||||
tempNode = findNode(root, insertNum);
|
||||
|
||||
if(tempNode!=NULL)
|
||||
printf("\n\t %d Already exists in the tree\n", insertNum);
|
||||
else
|
||||
{
|
||||
printf("\n\tPrinting AVL Tree\n");
|
||||
printAVL(root, 1);
|
||||
printf("\n");
|
||||
|
||||
root = insert(root, insertNum);
|
||||
printf("\n\tPrinting AVL Tree\n");
|
||||
printAVL(root, 1);
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
case 2:
|
||||
{
|
||||
printf("\n\tEnter the Number to Delete: ");
|
||||
scanf("%d", &queryNum);
|
||||
|
||||
tempNode = findNode(root, queryNum);
|
||||
|
||||
if(tempNode==NULL)
|
||||
printf("\n\t %d Does not exist in the tree\n", queryNum);
|
||||
else
|
||||
{
|
||||
printf("\n\tPrinting AVL Tree\n");
|
||||
printAVL(root, 1);
|
||||
printf("\n");
|
||||
root = delete(root, queryNum);
|
||||
|
||||
printf("\n\tPrinting AVL Tree\n");
|
||||
printAVL(root, 1);
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
case 3:
|
||||
{
|
||||
printf("\n\tEnter the Number to Search: ");
|
||||
scanf("%d", &queryNum);
|
||||
|
||||
tempNode = findNode(root, queryNum);
|
||||
|
||||
|
||||
if(tempNode == NULL)
|
||||
printf("\n\t %d : Not Found\n", queryNum);
|
||||
else
|
||||
{
|
||||
printf("\n\t %d : Found at height %d \n", queryNum, tempNode->height);
|
||||
|
||||
printf("\n\tPrinting AVL Tree\n");
|
||||
printAVL(root, 1);
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
case 4:
|
||||
{
|
||||
printf("\nPrinting Tree preOrder\n");
|
||||
printPreOrder(root);
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
case 5:
|
||||
{
|
||||
printf("\nPrinting Tree inOrder\n");
|
||||
printInOrder(root);
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
case 6:
|
||||
{
|
||||
printf("\nPrinting Tree PostOrder\n");
|
||||
printPostOrder(root);
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
case 7:
|
||||
{
|
||||
printf("\nPrinting AVL Tree\n");
|
||||
printAVL(root, 1);
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
default:
|
||||
{
|
||||
flag=0;
|
||||
printf("\n\t\tExiting, Thank You !!\n");
|
||||
break;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
return 0;
|
||||
}
|
||||
96
misc/cantor_set.c
Normal file
96
misc/cantor_set.c
Normal file
@ -0,0 +1,96 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
struct contour
|
||||
{
|
||||
double start;
|
||||
double end;
|
||||
struct contour* next;
|
||||
};
|
||||
typedef struct contour Contour;
|
||||
Contour *head;
|
||||
|
||||
void startList(double start_num, double end_num)
|
||||
{
|
||||
if(head==NULL)
|
||||
{
|
||||
head = (Contour*)malloc(sizeof(Contour));
|
||||
head -> start = start_num;
|
||||
head -> end = end_num;
|
||||
head -> next = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
void propagate(Contour *head)
|
||||
{
|
||||
Contour *temp = head;
|
||||
|
||||
if(temp!=NULL)
|
||||
{
|
||||
Contour *newNode = (Contour*)malloc(sizeof(Contour));
|
||||
double diff = ( ((temp->end)-(temp->start)) / 3);
|
||||
|
||||
newNode->end = temp->end;
|
||||
temp->end = ((temp->start)+diff);
|
||||
newNode->start = (newNode->end)-diff;
|
||||
|
||||
newNode->next = temp->next;
|
||||
|
||||
temp->next=newNode;
|
||||
|
||||
propagate(temp->next->next);
|
||||
}
|
||||
else
|
||||
return;
|
||||
}
|
||||
|
||||
void print(Contour *head)
|
||||
{
|
||||
|
||||
Contour *temp = head;
|
||||
while(temp!=NULL)
|
||||
{
|
||||
printf("\t");
|
||||
printf("[%lf] -- ", temp->start);
|
||||
printf("[%lf]", temp->end);
|
||||
temp=temp->next;
|
||||
}
|
||||
|
||||
printf("\n");
|
||||
|
||||
}
|
||||
|
||||
int main(int argc, char const *argv[])
|
||||
{
|
||||
|
||||
head=NULL;
|
||||
|
||||
int start_num, end_num, levels;
|
||||
|
||||
if (argc < 2)
|
||||
{
|
||||
printf("Enter 3 arguments: start_num \t end_num \t levels\n");
|
||||
scanf("%d %d %d", &start_num, &end_num, &levels);
|
||||
}
|
||||
else
|
||||
{
|
||||
start_num = atoi(argv[1]);
|
||||
end_num = atoi(argv[2]);
|
||||
levels = atoi(argv[3]);
|
||||
}
|
||||
|
||||
startList(start_num, end_num);
|
||||
|
||||
for (int i = 0; i < levels; i++)
|
||||
{
|
||||
printf("Level %d\t", i);
|
||||
print(head);
|
||||
propagate(head);
|
||||
printf("\n");
|
||||
}
|
||||
printf("Level %d\t", levels);
|
||||
print(head);
|
||||
|
||||
return 0;
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user