added bst,traversal with preorder,postorder,inorder in trees folder,g…

Data Structures/Trees/Binary Trees/BST__.C

@@ -0,0 +1,155 @@
+#include<stdio.h>
+#include<conio.h>
+#include<stdlib.h>
+
+typedef struct Node
+{
+	int data;
+	struct Node *left;
+	struct Node *right;
+}node;
+
+node *getnode(int);
+node *bst_insert(node *,int);
+node *bst_del(node *,int);
+void postorder(node *);
+void inorder(node *);
+void preorder(node *);
+node *inorder_succ(node *);
+
+void main()
+{
+	node *root=NULL,*nn;
+	int ch,data;
+	do
+	{
+		clrscr();
+		printf("\n\t ****MENU****");
+		printf("\n (1)Insert in BST");
+		printf("\n (2)Delete from BST");
+		printf("\n (3)Preorder traversal of BST");
+		printf("\n (4)Inorder traversal of BST");
+		printf("\n (5)Postorder traversal of BST");
+		printf("\n (6)Exit");
+		printf("\n Enter your choice(1..6) : ");
+		scanf("%d",&ch);
+		switch(ch)
+		{
+			case 1://insertion
+				printf("\n Enter the data to be inserted : ");
+				scanf("%d",&data);
+				root=bst_insert(root,data);
+				break;
+			case 2://deletion
+				printf("\n Enter the data to be deleted : ");
+				scanf("%d",&data);
+				root=bst_del(root,data);
+				break;
+			case 3://preorder
+				preorder(root);
+				getch();
+				break;
+			case 4://inorder
+				inorder(root);
+				getch();
+				break;
+			case 5://post order
+				postorder(root);
+				getch();
+				break;
+			case 6://exit
+				exit(0);
+		}
+	}while(1);
+}
+
+node *getnode(int data)
+{
+	node *nn;
+	nn=(node *)malloc(sizeof(node));
+	nn->data=data;
+	nn->left=NULL;
+	nn->right=NULL;
+	return nn;
+}
+
+node *bst_insert(node *root,int data)
+{
+	if(root==NULL)
+	{
+		root=getnode(data);
+		return root;
+	}
+	if(root->data > data)
+		root->left=bst_insert(root->left,data);
+	else if(root->data < data)
+		root->right=bst_insert(root->right,data);
+	else
+		printf("\n DUPLICATE DATA NOT ALLOWED!!");
+	return root;
+}
+
+void preorder(node *root)
+{
+	if(root==NULL)
+		return;
+	printf("%d ",root->data);
+	preorder(root->left);
+	preorder(root->right);
+}
+
+void inorder(node *root)
+{
+	if(root==NULL)
+		return;
+	inorder(root->left);
+	printf("%d ",root->data);
+	inorder(root->right);
+}
+
+void postorder(node *root)
+{
+	if(root==NULL)
+		return;
+	postorder(root->left);
+	postorder(root->right);
+	printf("%d ",root->data);
+}
+
+node *bst_del(node *root,int data)
+{
+	node *temp;
+	if(root==NULL)
+		return root;
+	if(data<root->data)
+		root->left=bst_del(root->left,data);
+	else if(data>root->data)
+		root->right=bst_del(root->right,data);
+	else
+	{
+		if(root->left==NULL)
+		{
+			temp=root->right;
+			free(root);
+			return temp;
+		}
+		else if(root->right==NULL)
+		{
+			temp=root->left;
+			free(root);
+			return temp;
+		}
+		temp=inorder_succ(root->right) ;
+		root->data=temp->data;
+		root->right=bst_del(root->right,temp->data);
+	}
+	return root;
+}
+
+node *inorder_succ(node *root)
+{
+	while(root->left!=NULL)
+		root=root->left;
+	return root;
+}
+

Data Structures/Trees/Binary Trees/traversal.cpp

@@ -0,0 +1,103 @@
+#include<iostream>
+using namespace std;
+//binary tree node declaration 
+struct bintree_node{
+    bintree_node *left;
+    bintree_node *right;
+    char data;
+} ;
+class bintree_class{
+    bintree_node *root;
+    public:
+    bintree_class(){
+        root=NULL;
+    }
+    int isempty() {
+        return(root==NULL);
+    }
+    void insert_node(int item);
+    void inorder_seq();
+    void inorder(bintree_node *);
+    void postorder_seq();
+    void postorder(bintree_node *);
+    void preorder_seq();
+    void preorder(bintree_node *);
+};
+void bintree_class::insert_node(int item){
+    bintree_node *p=new bintree_node;
+    bintree_node *parent;
+    p->data=item;
+    p->left=NULL;
+    p->right=NULL;
+    parent=NULL;
+    if(isempty())
+        root=p;
+    else{
+        bintree_node *ptr;
+        ptr=root;
+        while(ptr!=NULL)        {
+            parent=ptr;
+            if(item>ptr->data)        
+                ptr=ptr->right;
+            else
+                ptr=ptr->left;
+        }   
+        if(item<parent->data)
+            parent->left=p;
+        else
+            parent->right=p;
+    }
+}
+void bintree_class::inorder_seq()
+{
+    inorder(root);
+}
+void bintree_class::inorder(bintree_node *ptr)
+{
+    if(ptr!=NULL){
+        inorder(ptr->left);
+        cout<<"  "<<ptr->data<<"     ";
+        inorder(ptr->right);
+    }
+}
+void bintree_class::postorder_seq()
+{
+    postorder(root);
+}
+void bintree_class::postorder(bintree_node *ptr)
+{
+    if(ptr!=NULL){
+        postorder(ptr->left);
+        postorder(ptr->right);
+        cout<<"  "<<ptr->data<<"     ";
+    }
+}
+void bintree_class::preorder_seq()
+{
+    preorder(root);
+}
+void bintree_class::preorder(bintree_node *ptr)
+{
+    if(ptr!=NULL){
+        cout<<"  "<<ptr->data<<"     ";
+        preorder(ptr->left);
+        preorder(ptr->right);
+    }
+}
+int main()
+{
+    bintree_class bintree;
+    bintree.insert_node('A');
+    bintree.insert_node('B');
+    bintree.insert_node('C');
+    bintree.insert_node('D');
+    bintree.insert_node('E');
+    bintree.insert_node('F');
+    bintree.insert_node('G'); 
+    cout<<"Inorder traversal:"<<endl;
+    bintree.inorder_seq();
+    cout<<endl<<"Postorder traversal:"<<endl;
+    bintree.postorder_seq();
+    cout<<endl<<"Preorder traversal:"<<endl;
+    bintree.preorder_seq();
+}

Data Structures/Trees/Generic Trees/GENERIC.C

@@ -0,0 +1,92 @@
+#include<stdio.h>
+#include<conio.h>
+typedef struct node
+{
+	int type;
+	void *data;
+	struct node *next;
+}node;
+node *getnode(void *p,int type)
+{
+	node *nn;
+	nn=(node *)malloc(sizeof (node));
+	nn->data=p;
+	nn->next=NULL;
+	return nn;
+}
+void insert_beg(node**s)
+{
+	node *nn;
+	void *p;
+	int x,c;
+	float y;
+	char z;
+	printf("\n1 integer \n2 float\n3 characterf");
+	printf("\n what type of data you want to enter");
+	scanf("%d",&c);
+	printf("enter data");
+	if(c==1)
+	{
+		scanf(" %d ",&x);
+		p=&x;
+	}
+	else if(c==2)
+	{
+		scanf(" %f ",&y);
+		p=&y;
+	}
+	else if(c==3)
+	{
+		scanf(" %c ",&z);
+		p=&z;
+	}
+	nn=getnode(p,c);
+	if(*s==NULL)
+	{
+		*s=nn;
+	}
+	else
+	{
+		nn->next=*s;
+		*s=nn;
+	}
+}
+void display(node *start)
+{
+	node *p=start;
+	while(p!=NULL)
+	{
+		if(p->type==1)
+		printf(" %d ",*((int*)p->data));
+		else if(p->type==2)
+		printf(" %f ",*((float*)p->data));
+		else if(p->type==3)
+		printf(" %c ",*((char*)p->data));
+		p=p->next;
+	}
+}
+void main()
+{
+	int ch;
+	node *start=NULL;
+	clrscr();
+	do
+	{
+		printf("\n enter menu ");
+		printf("\n1 insertion \n2 display\n3 exit");
+		printf("\n enter the choice");
+		scanf("%d",&ch);
+		switch(ch)
+		{
+			case 1: insert_beg(&start);
+				break;
+			case 2: display(start);
+				break;
+			case 3: exit(0);
+
+		}
+	}while(1);
+	getch();
+}
+
+