├── Parent
    ├── README.md
    ├── STACK
    │   └── main.c
    ├── calloc basic
    │   └── source code
    ├── circularlinked list
    │   └── Main.java
    ├── deletion of a bst
    │   └── source code
    ├── depth of the tree
    │   └── Main.java
    ├── double ended queue
    │   └── Main.java
    ├── doubly
    │   └── Main.java
    ├── heterogeneous array list
    │   └── source code
    ├── malloc basic
    │   └── main.c
    ├── queue using array implementation
    │   └── source code
    ├── realloc
    │   └── main.c
    ├── relloc still user input
    │   └── main.c
    ├── reverse a singly list
    │   └── Main.java
    ├── simple array insertion
    │   └── Main.java
    ├── singly linked insertion and display
    │   └── main.c
    ├── singly linked list basic
    │   └── main.c
    ├── singly linked list in java using switch
    │   └── Main.java
    ├── singly linked list in java
    │   └── Main.java
    ├── stack
    │   └── Main.java
    ├── tree
    │   └── Main.java
    └── valid paranthesis
    │   └── Main.java
├── README.md
├── STACK
    └── main.c
├── calloc basic
    └── source code
├── circularlinked list
    └── Main.java
├── deletion of a bst
    └── source code
├── depth of the tree
    └── Main.java
├── double ended queue
    └── Main.java
├── doubly
    └── Main.java
├── heterogeneous array list
    └── source code
├── malloc basic
    └── main.c
├── queue using array implementation
    └── source code
├── realloc
    └── main.c
├── relloc still user input
    └── main.c
├── reverse a singly list
    └── Main.java
├── simple array insertion
    └── Main.java
├── singly linked insertion and display
    └── main.c
├── singly linked list basic
    └── main.c
├── singly linked list in java using switch
    └── Main.java
├── singly linked list in java
    └── Main.java
├── stack
    └── Main.java
├── tree
    └── Main.java
└── valid paranthesis
    └── Main.java


/Parent/README.md:
--------------------------------------------------------------------------------
1 | # DataStructure_Java
2 | # DataStructure_Java
3 | 


--------------------------------------------------------------------------------
/Parent/STACK/main.c:
--------------------------------------------------------------------------------
  1 | #include<stdio.h>
  2 | #include<stdlib.h>
  3 | #define s 5 
  4 | int top=-1,a[5];
  5 | void push();
  6 | void pop();
  7 | void max();
  8 | void print();
  9 | void min();
 10 | void odd();
 11 | void even();
 12 | int main()
 13 | {
 14 |     int ch;
 15 |     while(1)
 16 |     {
 17 |        
 18 |         printf("\n1.PUSH operation");
 19 |         printf("\n2.POP operation");
 20 |         printf("\n3.PRINT operation");
 21 |         printf("\n4.maximum ");
 22 |          printf("\n5.minimum ");
 23 |           printf("\n6.odd ");
 24 |            printf("\n7.even ");
 25 |            printf("\n");
 26 |            printf("enter your choice");
 27 |       scanf("%d",&ch);
 28 |         switch(ch)
 29 |         {
 30 |             case 1:
 31 |                 push();
 32 |                 break;
 33 |             case 2:
 34 |                 pop();
 35 |                 break;
 36 |             case 3:
 37 |                 print();
 38 |                 break;
 39 |             case 4:
 40 |                 max();
 41 |             case 8:
 42 |                 exit(1);
 43 |                 break;
 44 |             case 5:
 45 |                 min();
 46 |                 break;
 47 |             case 6:
 48 |                 odd();
 49 |                 break;
 50 |                 
 51 |             case 7:
 52 |                 even();
 53 |                 break;
 54 |                 
 55 |             default:
 56 |                 printf("\n Enter correct choice:");
 57 |                 break;
 58 |         }
 59 |     }
 60 | }
 61 | void push(){
 62 |     int x;
 63 |     if(top==s-1)
 64 |     {
 65 |         printf("stack overflow");
 66 |     }
 67 |     else
 68 |     {
 69 |         printf("enter the element to be inserted:");
 70 |         scanf("%d",&x);
 71 |         top=top+1;
 72 |         a[top]=x;
 73 |     }
 74 | }
 75 | void pop()
 76 | {
 77 |     if(top==-1)
 78 |     {
 79 |         printf("stack overflow");
 80 |     }
 81 |     else
 82 |     {
 83 |         printf("the deleted element is:");
 84 |         printf("%d",a[top]);
 85 |         top=top-1;
 86 |     }
 87 | }
 88 | void print()
 89 |     {
 90 |      if(top==-1)
 91 |     {
 92 |         printf("stack overflow");
 93 |     }
 94 |     else
 95 |     {
 96 |         for(int i=0;i>=0;--i)
 97 |         {
 98 |             printf("%d",a[i]);
 99 |         }
100 |     }
101 |     
102 | }
103 | void max()
104 | {
105 |     int max=0;
106 |     for(int i=0;i<=top;i++)
107 |         {
108 |            if(a[i]>=max)
109 |            {
110 |                max=a[i];
111 |            }
112 |         }
113 |         printf("%d",max);
114 |     
115 | }
116 | void min()
117 | {
118 |     int min=a[0];
119 |     for(int i=0;i<=top;i++)
120 |         {
121 |            if(a[i]<=min)
122 |            {
123 |                min=a[i];
124 |            }
125 |         }
126 |         printf("%d",min);
127 |     
128 | }
129 | void odd()
130 | {
131 |        for(int i=0;i<=top;i++)
132 |         {
133 |            if(a[i]%2!=0)
134 |            {
135 |              printf("%d",a[i]);
136 |            }
137 |         }
138 |         
139 | }
140 | void even()
141 | {
142 |        for(int i=0;i<=top;i++)
143 |         {
144 |            if(a[i]%2==0)
145 |            {
146 |              printf("%d",a[i]);
147 |            }
148 |         }
149 |         
150 | }


--------------------------------------------------------------------------------
/Parent/calloc basic/source code:
--------------------------------------------------------------------------------
 1 | 
 2 | #include <stdio.h>
 3 | #include<stdlib.h>
 4 | 
 5 | 
 6 | int main()
 7 | {
 8 |     int n,*p=NULL;
 9 |     scanf("%d",&n);
10 |     p=(int*)calloc(n,sizeof(int));
11 |     if(p==NULL)
12 |     {
13 |         
14 |         printf("no memory allocated");
15 |     }
16 |     else
17 |     {
18 |         for(int i=0;i<n;i++)
19 |         {
20 |             scanf("%d",p+i);
21 |         }
22 |         for(int i=0;i<n;i++)
23 |         {
24 |             printf("%d",p[i]);
25 |              printf("%d",*p+i);
26 |         }
27 |         free(p);
28 |         p=NULL;
29 |     }
30 | 
31 |     return 0;
32 | }


--------------------------------------------------------------------------------
/Parent/circularlinked list/Main.java:
--------------------------------------------------------------------------------
 1 | public class Main
 2 | {
 3 |     public static void main(String[] args) {
 4 |         System.out.println("Hello World");
 5 |         circular a=new circular();
 6 |         a.InsertBegin(6);
 7 |         a.InsertBegin(6);
 8 |         a.InsertEnd(8);
 9 |         a.InsertAtMiddle(1,2);
10 |         a.display();
11 |     }
12 | }
13 | class circular{
14 |     node head,tail;
15 |     class node{
16 |         int data;
17 |         node next;
18 |         node(int value){
19 |             data=value;
20 |             next=null;
21 |         }
22 |     }
23 |     void InsertBegin(int n)
24 |     {
25 |         node t=new node(n);
26 |         if(head==null){
27 |             head=t;
28 |             tail=t;
29 |         }
30 |         else{
31 |            tail.next=t;
32 |            t.next=head;
33 |            head=t;
34 |             
35 |         }
36 |     }
37 |     void InsertEnd(int m)
38 |     {
39 |       node t=new node(m);
40 |       if(head==null){
41 |         head=tail=t;
42 |         t.next=head;
43 |       }
44 |       else{
45 |         tail.next=t;
46 |         t.next=head;
47 |         head=t;
48 |       }
49 |     }
50 |     void InsertAtMiddle(int insertValue,int pos){
51 |     node t=new node(insertValue);
52 |     /*if(pos>len)
53 |     {
54 |         System.out.println("enter valid position");
55 |     }
56 |     else*/ if(pos==0)
57 |     {
58 |         node tem=head;
59 |         head=t;
60 |         t.next=tem;
61 |     }else{
62 |     int a=1;
63 |     node temp=head;
64 |     while(a!=pos)
65 |     {
66 |         temp=temp.next;
67 |         a++;
68 |     }
69 |     node te=temp.next;
70 |     temp.next=t;
71 |     t.next=te;
72 | }
73 | }
74 | void display()
75 | {
76 |     if(head==null)
77 |     {
78 |         System.out.print("list is empty");
79 |     }
80 |     else{
81 |         node temp=head;
82 |         do{
83 |             System.out.print(temp.data+" ");
84 |             temp=temp.next;
85 |             
86 |         }while(temp!=head);
87 |     }
88 | }
89 | }


--------------------------------------------------------------------------------
/Parent/deletion of a bst/source code:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | 
 3 | public class Main {
 4 |     public static void main(String[] args) {
 5 |      BST o=new BST();
 6 |      o.insert(5);
 7 |      o.insert(3);
 8 |      o.insert(1);
 9 |      o.insert(11);
10 |      o.insert(6);
11 |      o.insert(12);
12 |      o.insert(13);
13 |      o.delete(o.Root,3);
14 |      o.delete(o.Root,1);
15 |      o.delete(o.Root,11);
16 |      o.inorder(o.Root);
17 |   }
18 | }
19 | class node{
20 |   int data;
21 |   node left,right;
22 |   node(int value){
23 |     data=value;
24 |     left=right=null;
25 |   }
26 | }
27 | class BST{
28 |   void inorder(node temp){
29 |     if(temp!=null){
30 |       inorder(temp.left);
31 |       System.out.print(temp.data+"  ");
32 |       inorder(temp.right);
33 |     }
34 |   }
35 |   node Root;
36 |   void insert(int key){
37 |     Root=inserting(Root,key);
38 |   }
39 |   node inserting(node duplicateRoot,int key){
40 |     if(duplicateRoot==null)
41 |     {
42 |       duplicateRoot=new node(key);
43 |       return duplicateRoot;
44 |     }
45 |     if(key>duplicateRoot.data)
46 |     duplicateRoot.right=inserting(duplicateRoot.right,key);
47 |     else if(key<duplicateRoot.data)
48 |     duplicateRoot.left=inserting(duplicateRoot.left,key);
49 |    
50 |      return duplicateRoot;
51 |     
52 |   }
53 |   node delete(node temp,int target){
54 |     if(temp==null)
55 |     return temp;
56 |     if(target>temp.data)
57 |     temp.right=delete(temp.right,target);
58 |     else if(target<temp.data)
59 |     temp.left=delete(temp.left,target);
60 |     else{
61 |       if(temp.left==null)
62 |       return temp.right;
63 |       else if(temp.right==null)
64 |       return temp.left;
65 |       temp.data=min(temp.right);
66 |       temp.right=delete(temp.right,temp.data);
67 |      
68 |     } return temp;
69 |   }
70 |   int min(node temp){
71 |     if(temp==null){
72 |     System.out.println("Empty tree");return -1;}
73 |     else {
74 |       int minValue=temp.data;
75 |       while(temp!=null){
76 |         minValue=temp.data;
77 |         temp=temp.left;
78 |       }
79 |       return minValue;
80 |     }
81 |   }
82 |   
83 | 
84 |   
85 | }
86 | 


--------------------------------------------------------------------------------
/Parent/depth of the tree/Main.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | 
 3 | public class Main {
 4 |     public static void main(String[] args) {
 5 |         Scanner sc=new Scanner(System.in);
 6 |       BST o=new BST();
 7 |       System.out.println("enter how many node to be created");
 8 |       int a=sc.nextInt();
 9 |       for(int i=0;i<a;i++)
10 |       o.insert(sc.nextInt());
11 |       System.out.println(o.depth(o.Realroot));
12 |     }
13 | }
14 | 
15 | 
16 | class node{
17 |   int data;
18 |   node left,right;
19 |   node(int key){
20 |     data=key;
21 |     left=right=null;
22 |   }
23 | }
24 | 
25 | class BST{
26 |       node Realroot;
27 |     void insert(int key){
28 |         Realroot=insertRecursively(Realroot,key);
29 |     }
30 |     node insertRecursively(node dupRoot,int key){
31 |  
32 |         if(dupRoot==null){
33 |           dupRoot=new node(key);
34 |             return dupRoot;
35 |         }
36 |         if(key>dupRoot.data){
37 |             dupRoot.right=insertRecursively(dupRoot.right,key);
38 |         }  
39 |        else if(key<dupRoot.data){
40 |               dupRoot.left=insertRecursively(dupRoot.left,key);
41 |         }
42 |         return dupRoot;
43 |     }
44 | 
45 | int depth(node root)
46 | {
47 |     if(root==null)
48 |     {
49 |         return 0;
50 |     }
51 |     if(root.left==null)
52 |     {
53 |         return depth(root.right)+1;
54 |     }
55 |      if(root.right==null)
56 |     {
57 |         return depth(root.left)+1;
58 |     }
59 |     return Math.max(depth(root.left),depth(root.right));
60 | }
61 | }


--------------------------------------------------------------------------------
/Parent/double ended queue/Main.java:
--------------------------------------------------------------------------------
 1 | public class Main{
 2 |   public static void main (String[] args) {
 3 |     DoubleEndedQueue o=new DoubleEndedQueue();
 4 |     
 5 |     o.enqRear(4);
 6 |     o.enqRear(5);
 7 |     o.enqRear(6);
 8 |     o.enqRear(7);
 9 |    o.enqFront(123);
10 |    o.dequeueFront();
11 |   }
12 | }
13 | class DoubleEndedQueue{
14 |   final int size;
15 |   int a[];
16 |   int front,rear;
17 |   DoubleEndedQueue(){
18 |     size=5;
19 |     a=new int[size];
20 |     rear=-1;front=-1;
21 |   }
22 |   DoubleEndedQueue(int userSize){
23 |     size=userSize;
24 |     a=new int[size];
25 |     rear=-1;front=-1;
26 |   }
27 |   boolean isFull(){
28 |     if((front==0&&rear==size-1)||( front==rear+1))
29 |     return true;
30 |     return false;
31 |   }
32 |   void enqFront(int value){
33 |     if(isFull()){
34 |     System.out.println("QUEUE OVERFLOW");
35 |     return ;
36 |     }
37 |     else if(front==-1&&rear==-1){
38 |       front=0;
39 |       a[front]=value;
40 |        front=size;
41 |     }
42 |   else if(front==0){
43 |       front=size;
44 |     }
45 |     a[--front]=value;
46 |      }
47 |   void enqRear(int value){
48 |    if(isFull())
49 |    System.out.println("QUEUE OVERFLOW");
50 |    else if(front==-1&&rear==-1)
51 |    front=rear=0;
52 |    else if(rear==-1 && front!=-1)
53 |    rear=1;
54 |    else rear++;
55 |    a[rear]=value;
56 |      }
57 |   void dequeueFront(){
58 |     if(front==-1&&rear==-1)
59 |     System.out.println("QUEUE UNDERFLOW");
60 |     else if(front==rear)
61 |     front=rear=-1;
62 |     else if(front==size-1)
63 |     front=0;
64 |     else front--;
65 |   }
66 | }


--------------------------------------------------------------------------------
/Parent/doubly/Main.java:
--------------------------------------------------------------------------------
  1 | 
  2 | public class Main
  3 | {
  4 | 	public static void main(String[] args) {
  5 | 		System.out.println("Hello World");
  6 | 		Doubly o=new Doubly();
  7 | 		    o.InsertAtBegin(9);
  8 | 			o.InsertAtBegin(9);
  9 | 			o.InsertAtBegin(9);
 10 | 			o.InsertAtBegin(9);
 11 | 			o.InsertAtBegin(9);
 12 | 			o.InsertAtEnd(4);
 13 | 			o.InsertAtMiddle(54,1);
 14 | 			o.Display();
 15 | 			
 16 | 		    o.length();
 17 | 		   
 18 | 				}
 19 | }
 20 | class Doubly{
 21 |     node head,tail;
 22 |     class node{
 23 |         int data;
 24 |         node prev,next;
 25 |         node(int value){
 26 |             data=value;
 27 |             prev=next=null;
 28 |         }
 29 |     }
 30 |     int l=0;
 31 |     void InsertAtEnd(int d){
 32 |         node t=new node(d);
 33 |         if(head==null)
 34 |         {
 35 |             head=tail=t;
 36 |             t.next=head;
 37 |             head.prev=t;
 38 |         }
 39 |         else{
 40 |             tail.next=t;
 41 |              t.prev=tail;
 42 |             t.next=head;
 43 |             head.prev=t;
 44 |             tail=t;
 45 |         }
 46 |         
 47 |     }
 48 |    void Display(){
 49 |         if(head==null){
 50 |           System.out.print("no element to display");
 51 |             
 52 |         }else{
 53 |           node t=head;
 54 |          do{
 55 |             System.out.print(t.data+" ");
 56 |             t=t.next;
 57 |           } while(t!=tail.next);
 58 |           System.out.println("");
 59 |         }
 60 |     }
 61 |     void InsertAtBegin(int d){
 62 |       node t=new node(d);
 63 |       if(head==null){
 64 |         head=tail=t;
 65 |        head.prev=tail;
 66 |       }else{
 67 |         node te=head;
 68 |         head=t;
 69 |         head.prev=tail;
 70 |         head.next=te;
 71 |         te.prev=head;
 72 |         tail.next=head;
 73 |  
 74 |       }
 75 |       
 76 |     }
 77 |     void InsertAtMiddle(int d,int pos){
 78 |      length();
 79 |       node t=new node(d);
 80 |       if(pos==0){
 81 |       InsertAtBegin(d);
 82 |       }
 83 |        else if(pos>=l|| pos<0){
 84 |               System.out.println("enter valid position");
 85 |                             }
 86 |           else{
 87 |                 int i=0;
 88 |                 node temp=head;
 89 |                 node temp1=head;
 90 |                 while(i!=pos){
 91 |                 temp1=temp;
 92 |                 temp=temp.next;
 93 |                  i++;
 94 |       }
 95 |     
 96 |       temp1.next=t;
 97 |       t.prev=temp1;
 98 |       t.next=temp;
 99 |       temp.prev=t;
100 |           }
101 |           
102 |     }
103 |     void length()
104 |     {
105 |         l=0;
106 |         node temp=head;
107 |     do        {
108 |             temp =temp.next;
109 |             l++;
110 |        
111 |         }   while(temp!=tail);
112 |         //System.out.println(l+1);
113 |     }
114 |     
115 | }


--------------------------------------------------------------------------------
/Parent/heterogeneous array list/source code:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | public class Main {
 3 |     public static void main(String[] args) {
 4 |   arrayList1<Integer> a=new arrayList1<Integer>();
 5 |  a.insert(1);
 6 |  a.insert(2);
 7 |  a.insert(3);
 8 |  a.insert(4);
 9 |  a.insert(5);
10 |  a.display();
11 |  arrayList1<String> b=new arrayList1<String>();
12 |   b.insert("a");
13 |  b.insert("b");
14 |  b.insert("c");
15 |  b.insert("d");
16 |  b.insert("e");
17 |  b.display();
18 |       }
19 | }
20 | class arrayList1<anytype>{
21 |  final static int initialSize=4;
22 | private anytype a[]=(anytype[])new Object[initialSize];
23 |  int index=0,capacity=initialSize;
24 |  
25 |  void insert(anytype value){
26 |   if(index==capacity)
27 |   grow();
28 |    a[index++]=value;
29 |  }
30 |  
31 |  void grow(){
32 |    capacity=capacity*2;
33 |    a=Arrays.copyOf(a,capacity);
34 |     }
35 |     
36 |  void display(){
37 |    if(index==0)
38 |    System.out.println("List Is Empty");
39 |    else{
40 |      for(int i=0;i<index;i++)
41 |    System.out.print(a[i]+" ");
42 |    System.out.println();
43 |  }
44 | }
45 | }


--------------------------------------------------------------------------------
/Parent/malloc basic/main.c:
--------------------------------------------------------------------------------
 1 | 
 2 | #include <stdio.h>
 3 | #include<stdlib.h>
 4 | 
 5 | 
 6 | int main()
 7 | {
 8 |     int n,*p=NULL;
 9 |     scanf("%d",&n);
10 |     p=(int*)malloc(n*sizeof(int));
11 |     if(p==NULL)
12 |     {
13 |         
14 |         printf("no memory allocated");
15 |     }
16 |     else
17 |     {
18 |         for(int i=0;i<n;i++)
19 |         {
20 |             scanf("%d",p+i);
21 |         }
22 |         for(int i=0;i<n;i++)
23 |         {
24 |             printf("%d",p[i]);
25 |              printf("%d",*p+i);
26 |         }
27 |         free(p);
28 |         p=NULL;
29 |     }
30 | 
31 |     return 0;
32 | }
33 | 


--------------------------------------------------------------------------------
/Parent/queue using array implementation/source code:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | 
 3 | public class Main {
 4 |     public static void main(String[] args) {
 5 |       Queue a=new Queue(6);
 6 |       a.enqueue(12);
 7 |       System.out.println(a.dequeue());
 8 |       System.out.println(a.dequeue());
 9 |     
10 |   }
11 | }
12 | class Queue{
13 |   final int size;
14 |   int a[];
15 |   int front,rear;
16 |   Queue(){
17 |     size=5;
18 |     a=new int[size];
19 |     front=rear=-1;
20 |   }
21 |   Queue(int userSize){
22 |     size=userSize;
23 |     a=new int[size];
24 |     front=rear=-1;
25 |   }
26 |   void enqueue(int data){
27 |     if(front==-1 && rear==-1){
28 |       front=0;
29 |       a[++rear]=data;
30 |     }
31 |     else if(rear==size-1)
32 |     System.out.println("QUEUE OVERFLOW");
33 |     else{
34 |        a[++rear]=data;
35 |     }
36 |   }
37 |   int dequeue(){
38 |      if(front==-1 && rear==-1){
39 |        System.out.println("QUEUE UNDERFLOW");  
40 |        return -1;
41 |      }
42 |      else if(front==rear){
43 |        int copy=a[front];
44 |      front=rear=-1;
45 |      return copy;
46 |   }
47 |   return a[front++];
48 | }
49 | }


--------------------------------------------------------------------------------
/Parent/realloc/main.c:
--------------------------------------------------------------------------------
 1 | 
 2 | #include <stdio.h>
 3 | #include<stdlib.h>
 4 | 
 5 | 
 6 | int main()
 7 | {
 8 |     int n,*p=NULL;
 9 |     scanf("%d",&n);
10 |     p=(int*)malloc(n*sizeof(int));
11 |     if(p==NULL)
12 |     {
13 |         
14 |         printf("no memory allocated");
15 |     }
16 |     else
17 |     {
18 |         for(int i=0;i<n;i++)
19 |         {
20 |             scanf("%d",p+i);
21 |         }
22 |         for(int i=0;i<n;i++)
23 |         {
24 |             printf("%d",p[i]);
25 |           
26 |         }
27 |         int k;
28 |         scanf("%d",&k);
29 |         p=realloc(p,k*sizeof(int));
30 |          for(int i=0;i<k;i++)
31 |         {
32 |             scanf("%d",p+i);
33 |         }
34 |         for(int i=0;i<k;i++)
35 |         {
36 |             printf("%d",p[i]);
37 |           
38 |         }
39 |         free(p);
40 |         p=NULL;
41 |     }
42 | 
43 |     return 0;
44 | }


--------------------------------------------------------------------------------
/Parent/relloc still user input/main.c:
--------------------------------------------------------------------------------
 1 | 
 2 | #include <stdio.h>
 3 | #include<stdlib.h>
 4 | int main()
 5 | {
 6 |     int n,*p=NULL;
 7 |     scanf("%d",&n);
 8 |     p=(int*)malloc(n*sizeof(int));
 9 |     if(p==NULL)
10 |     {
11 |         
12 |         printf("no memory allocated");
13 |     }
14 |     else
15 |     {
16 |         for(int i=0;i<n;i++)
17 |         {
18 |             scanf("%d",p+i);
19 |         }
20 |         for(int i=0;i<n;i++)
21 |         {
22 |             printf("%d",p[i]);
23 |           
24 |         }
25 |         int k,ch;
26 |         while(1)
27 |         {
28 |             
29 |         printf("\n1 memory allocate");
30 |         printf("\n0 no memory want");
31 |         printf("\n enter your choice:");
32 |         scanf("%d",&ch);
33 |         switch(ch)
34 |         {
35 |         case 1:
36 |             {
37 |             printf("\n give the size of extend memory: ");
38 |             scanf("%d",&k);
39 |             p=realloc(p,k*sizeof(int));
40 |             for(int i=n;i<k;i++)
41 |             {
42 |             scanf("%d",p+i);
43 |             }
44 |            
45 |                 n=k;
46 |             
47 |             }
48 |             break;
49 |             case 0:
50 |             {
51 |                  for(int i=0;i<k;i++)
52 |             {
53 |             printf("%d",p[i]);
54 |           
55 |             }
56 |             exit(0);
57 |             }
58 |         }
59 |     }
60 |     }
61 |     
62 | 
63 |     return 0;
64 | }
65 | 


--------------------------------------------------------------------------------
/Parent/reverse a singly list/Main.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | 
 3 | public class Main {
 4 |     public static void main(String[] args) {
 5 |         Practice o = new Practice();
 6 |         o.increase(1);
 7 |         o.increase(2);
 8 |         o.increase(3);
 9 |         o.increase(4);
10 |         o.increase(5);
11 |       //  o.tell();
12 |         o.person1=find(o.person1, o.p2);
13 |     o.tell();
14 |     }
15 | 
16 |     static inner find(inner a, inner b) {
17 |         inner prev = null;
18 |         inner current = a;
19 |         inner nextNode;
20 |         while (current != null) {
21 |             nextNode = current.next;
22 |             current.next = prev;
23 |             prev = current;
24 |             current = nextNode;
25 |         }
26 |        a=prev;
27 |              return prev;
28 |         // a = prev;
29 |         // System.out.println(" ");
30 |         // while(prev!=null)
31 |         // {
32 |         //   System.out.print(prev.value+"  ");
33 |         //   prev=prev.next;
34 |         // }
35 |     }
36 | }
37 | class inner {
38 |     int value;
39 |     inner next;
40 | 
41 |     inner(int l) {
42 |         value = l;
43 |     }
44 | }
45 | class Practice {
46 |     inner person1, p2;
47 |     void increase(int baby) {
48 |         inner name = new inner(baby);
49 |         if (person1 == null)
50 |             person1 = p2 = name;
51 |         else {
52 |             p2.next = name;
53 |             p2 = name;
54 |         }
55 |     }
56 | 
57 |     void tell() {
58 |         inner temp = person1;
59 |         while (temp != null) {
60 |             System.out.print(temp.value + "   ");
61 |             p2=temp;
62 |             temp = temp.next;
63 |         }
64 |         
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/Parent/simple array insertion/Main.java:
--------------------------------------------------------------------------------
  1 | import java.util.*;
  2 | public class Main {
  3 |     public static void main(String[] args) {
  4 |       //object creation for the ArrayList class
  5 |   ArrayList a=new ArrayList();
  6 |   //calling insert method in the ArrayList by using it's object 
  7 |  a.insert(1);
  8 |  a.insert(2);
  9 |  a.insert(3);
 10 |  a.insert(4);
 11 |  a.insert(5);
 12 |  a.display();
 13 |  a.insert(1);
 14 |  a.insert(2);
 15 |  a.insert(3);
 16 |  a.insert(4);
 17 |  a.insert(5);
 18 |  a.display();
 19 |  a.InsertParticular(28,3);
 20 |  a.DeleteParticularIndex(3);
 21 |  a.display();
 22 |  System.out.println("thank you for coming");
 23 |       }
 24 | }
 25 | class ArrayList{
 26 |   //initial size varible for every objects
 27 |  final static int initialSize=4;
 28 | //array declaration
 29 | private int a[]=new int[initialSize];
 30 | //index variable for data insertion and capacity for denoting total data can be added  
 31 |  int index=0,capacity=initialSize;
 32 |  //insert method
 33 |  void insert(int value){
 34 | //array capacity  reached condition 
 35 |   if(index==capacity)
 36 |   //calling grow method to increase the array size
 37 |   grow();
 38 |   //inserting data in the arraylist
 39 |    a[index++]=value;
 40 |  }
 41 |  void grow(){
 42 |   //increaing capacity value
 43 |    capacity=capacity*2;
 44 |    //copying original array with the increased capacity size and reassigning the new array referncwe to original array reference variable
 45 |    a=Arrays.copyOf(a,capacity);
 46 |    
 47 |    }
 48 |    void InsertParticular(int value,int pos)
 49 |    {
 50 |        if(pos>capacity||pos<0)
 51 |        {
 52 |           System.out.println("enter valid position");
 53 |           return;
 54 |        }
 55 |        if(pos==index)
 56 |        {
 57 |            a[pos]=value;
 58 |            return;
 59 |        }
 60 |        else 
 61 |        {
 62 |            if(index==capacity)
 63 |            {
 64 |                grow();
 65 |            }
 66 |            
 67 |            for(int i=index;i>pos;i--)
 68 |            {
 69 |                 a[i]=a[i-1];
 70 |            }
 71 |            a[pos]=value;
 72 |            index++;
 73 |            }
 74 |        
 75 |     
 76 |    }
 77 |    void DeleteParticularIndex(int pos){
 78 |     if(index==0)
 79 |     {
 80 |         System.out.println("no element to delete");
 81 |         return;
 82 |     }
 83 |     if(pos>=capacity){
 84 |         System.out.println("give correct index");
 85 |         return;
 86 |     }
 87 |     else{
 88 |         for(int i=pos;i<index-1;i++)
 89 |         {
 90 |             a[i]=a[i+1];
 91 |         }
 92 |       index--;
 93 |            }
 94 |     }
 95 |      
 96 |  //display method to show data to user
 97 |  void display(){
 98 |   //array under flow condition
 99 |    if(index==0)
100 |    System.out.println("List Is Empty");
101 |    else{
102 |      for(int i=0;i<index;i++)
103 |    System.out.print(a[i]+" ");
104 |    System.out.println();
105 |  }
106 | }
107 | }


--------------------------------------------------------------------------------
/Parent/singly linked insertion and display/main.c:
--------------------------------------------------------------------------------
 1 | 
 2 | #include <stdio.h>
 3 | #include<stdlib.h>
 4 | void insert();
 5 | void display();
 6 | struct node{
 7 |     int data;
 8 |     struct node*next;
 9 | }*head=NULL,*ne,*temp;
10 | 
11 | int main()
12 | {
13 |     int n;
14 |     head=(struct node*)malloc(sizeof(struct node));
15 |     printf("enter the head value:");
16 |     scanf("%d",&head->data);
17 |     head->next=NULL;
18 |     temp=head;
19 |     printf("enter how many node created:");
20 |     int k;
21 |     scanf("%d",&k);
22 |     for(int i=0;i<k;i++)
23 |     {
24 |         insert();
25 |     }
26 |   display();
27 | }
28 |     
29 |     
30 | void insert()
31 | {
32 |        ne=(struct node*)malloc(sizeof(struct node));
33 |        printf("enter the element to be inserted:");
34 |        scanf("%d",&ne->data);
35 |        temp->next=ne;
36 |        temp=ne;
37 |        ne->next=NULL;
38 |        
39 |        
40 | }
41 |        
42 | void display()
43 | {
44 |     temp=head;
45 |     while(temp!=NULL)
46 |     {
47 |         printf("%d ",temp->data);
48 |         temp=temp->next;
49 |     }
50 | }
51 | 
52 | 


--------------------------------------------------------------------------------
/Parent/singly linked list basic/main.c:
--------------------------------------------------------------------------------
 1 | 
 2 | #include <stdio.h>
 3 | #include<stdlib.h>
 4 | struct node{
 5 |     int data;
 6 |     struct node*next;
 7 | }*head=NULL;
 8 | 
 9 | int main()
10 | {
11 |     int n;
12 |     struct node*temp,*ne;
13 |     head=(struct node*)malloc(sizeof(struct node));
14 |     printf("enter the head value:");
15 |     scanf("%d",&head->data);
16 |     head->next=NULL;
17 |     temp=head;
18 |     int choice;
19 |     do
20 |     {
21 |        ne=(struct node*)malloc(sizeof(struct node));
22 |        printf("enter the element to be inserted:");
23 |        scanf("%d",&ne->data);
24 |        temp->next=ne;
25 |        temp=ne;
26 |        ne->next=NULL;
27 |        printf("enter your choice:");
28 |        scanf("%d",&choice);
29 |        
30 |        
31 |     }while(choice!=0);
32 |     temp=head;
33 |     while(temp!=NULL)
34 |     {
35 |         printf("%d ",temp->data);
36 |         temp=temp->next;
37 |     }
38 | }
39 | 
40 | 


--------------------------------------------------------------------------------
/Parent/singly linked list in java using switch/Main.java:
--------------------------------------------------------------------------------
  1 | import java.util.*;
  2 | public class Main
  3 | {
  4 |   public static void main (String[]args)
  5 |   {
  6 |     System.out.println
  7 |       ("**********************welcome to kidumutti shop******************************");
  8 |     Scanner scanner = new Scanner (System.in);
  9 |     Singly a = new Singly ();
 10 |       a.length ();
 11 |     int choice = 0, value = 0, pos = 0;
 12 |     do
 13 |       {
 14 | 	System.out.println ("1. Insert at beginning");
 15 | 	System.out.println ("2. Insert at end");
 16 | 	System.out.println ("3. InsertAtMiddle");
 17 | 	System.out.println ("4. DeleteBegin");
 18 | 	System.out.println ("5. DeleteAtMid");
 19 | 	System.out.println ("6. DeleteAtEnd");
 20 | 	System.out.println ("7. length");
 21 | 	System.out.println ("8. Display");
 22 | 	System.out.println ("0. Exit");
 23 | 	System.out.print ("Enter your choice: ");
 24 | 	choice = scanner.nextInt ();
 25 | 	switch (choice)
 26 | 	  {
 27 | 	  case 1:
 28 | 	    System.out.print ("Enter value: ");
 29 | 	    value = scanner.nextInt ();
 30 | 	    a.InsertAtBegin (value);
 31 | 	    System.out.println ("value is successfully inserted");
 32 | 	    break;
 33 | 	    case 2:System.out.print ("Enter value: ");
 34 | 	    value = scanner.nextInt ();
 35 | 	    a.InsertAtEnd (value);
 36 | 	    System.out.println ("value is successfully inserted");
 37 | 	    break;
 38 | 	    case 3:System.out.println ("Enter value to InsertAtMiddle: ");
 39 | 	    value = scanner.nextInt ();
 40 | 	    System.out.println ("Enter position");
 41 | 	    pos = scanner.nextInt ();
 42 | 	    a.InsertAtMiddle (value, pos);
 43 | 	    System.out.println ("value is successfully inserted");
 44 | 	    break;
 45 | 	    case 4:a.DeleteBegin ();
 46 | 	    System.out.println ("value is successfully delted");
 47 | 	    break;
 48 | 	    case 5:System.out.println ("enter the position to be deleted");
 49 | 	    pos = scanner.nextInt ();
 50 | 	    a.DeleteAtMid (pos);
 51 | 	    System.out.println ("value is successfully deleted");
 52 | 	    break;
 53 | 	    case 6:a.DeleteAtEnd ();
 54 | 	    System.out.println ("value is successfully deleted");
 55 | 	    break;
 56 | 
 57 | 	    case 7:a.length ();
 58 | 	    break;
 59 | 	    case 8:a.Display ();
 60 | 	    break;
 61 | 	    case 0:System.out.println ("mudunchu poda");
 62 | 	    break;
 63 | 
 64 | 	    default:System.out.println ("Invalid choice.");
 65 | 	  }
 66 |       }
 67 |     while (choice != 0);
 68 | 
 69 |   }
 70 | }
 71 | 
 72 | class Singly
 73 | {
 74 |   int len = 0;
 75 |   node head;
 76 |   class node
 77 |   {
 78 |     int data;
 79 |     node next;
 80 |       node (int value)
 81 |     {
 82 |       data = value;
 83 | 
 84 |     }
 85 |   }
 86 |   void InsertAtEnd (int insertValue)
 87 |   {
 88 |     node t = new node (insertValue);
 89 |     if (head == null)
 90 |       {
 91 | 	head = t;
 92 |       }
 93 |     else
 94 |       {
 95 | 	node temp = head;
 96 | 	while (temp.next != null)
 97 | 	  {
 98 | 	    temp = temp.next;
 99 | 	  }
100 | 	temp.next = t;
101 | 
102 |       }
103 | 
104 | 
105 |   }
106 |   void Display ()
107 |   {
108 |     if (head == null)
109 |       {
110 | 	System.out.println ("list is empty");
111 |       }
112 |     else
113 |       {
114 | 	node temp = head;
115 | 	while (temp != null)
116 | 	  {
117 | 	    System.out.print (temp.data + " ");
118 | 	    temp = temp.next;
119 | 	  }
120 | 	System.out.println ();
121 | 
122 |       }
123 |   }
124 |   void InsertAtMiddle (int insertValue, int pos)
125 |   {
126 |     node t = new node (insertValue);
127 |     if (head == null)
128 |       {
129 | 	System.out.println ("list is empty");
130 |       }
131 |     if (pos > len)
132 | 
133 |       {
134 | 	System.out.println ("enter valid position");
135 |       }
136 |     else if (pos == 0)
137 |       {
138 | 	node tem = head;
139 | 	head = t;
140 | 	t.next = tem;
141 |       }
142 |     else
143 |       {
144 | 	int a = 1;
145 | 	node temp = head;
146 | 	while (a != pos)
147 | 	  {
148 | 	    temp = temp.next;
149 | 	    a++;
150 | 	  }
151 | 	node te = temp.next;
152 | 	temp.next = t;
153 | 	t.next = te;
154 |       }
155 |   }
156 |   void InsertAtBegin (int insertValue)
157 |   {
158 |     node t = new node (insertValue);
159 |     if (head == null)
160 |       {
161 | 	head = t;
162 |       }
163 |     else
164 |       {
165 | 	node temp = head;
166 | 	head = t;
167 | 	head.next = temp;
168 |       }
169 |   }
170 |   void DeleteAtEnd ()
171 |   {
172 |     if (head == null)
173 |       {
174 | 	System.out.println ("no element to delete");
175 |       }
176 |     node temp = head;
177 |     while (temp.next.next != null)
178 |       {
179 | 	temp = temp.next;
180 |       }
181 |     temp.next = null;
182 |   }
183 |   void DeleteBegin ()
184 |   {
185 |     if (head == null)
186 |       {
187 | 	System.out.println ("no element to delete");
188 |       }
189 |     node temp = head.next;
190 |     head = temp;
191 | 
192 |   }
193 |   void DeleteAtMid (int pos)
194 |   {
195 |       if (pos >= len)
196 |       {
197 | 	System.out.println ("enter valid position");
198 |       }
199 |       else{
200 |     if (head == null)
201 |       {
202 | 	System.out.println ("no element to delete");
203 |       }
204 |     node temp = head;
205 |     
206 |     if (pos == 0)
207 |       {
208 | 	head = head.next;
209 | 
210 |       }
211 |     else
212 |       {
213 | 	int a = 1;
214 | 	while (a != pos)
215 | 	  {
216 | 	    temp = temp.next;
217 | 	    a++;
218 | 	  }
219 | 	node te = temp.next;
220 | 	temp.next = te.next;
221 | 	//te=null;
222 | 
223 |       }
224 |       }
225 |   }
226 |   void length ()
227 |   {
228 |     node temp = head;
229 |     while (temp != null)
230 |       {
231 | 	len++;
232 | 	temp = temp.next;
233 |       }
234 | 
235 |   }
236 | }
237 | 


--------------------------------------------------------------------------------
/Parent/singly linked list in java/Main.java:
--------------------------------------------------------------------------------
  1 | public class Main
  2 | {
  3 | 	public static void main(String[] args) {
  4 | 	System.out.println("Hello World");
  5 | 	
  6 | 	Singly a=new Singly();
  7 | 	a.InsertAtEnd(2);
  8 | 	a.InsertAtEnd(3);
  9 | 	a.InsertAtEnd(4);
 10 | 	a.InsertAtBegin(9);
 11 | 	a.InsertAtMiddle(8,34);
 12 | 	a.Display();
 13 | 	a.DeleteAtEnd();
 14 | 	a.Display();
 15 | 	a.DeleteBegin();
 16 | 	a.Display();
 17 | 	a.DeleteAtMid(0);
 18 | 	a.Display();
 19 | 	a.length();
 20 | 
 21 | 		}
 22 | }
 23 | class Singly{
 24 |     int len=0;
 25 |     node head;
 26 | class node{
 27 |     int data;
 28 |     node next;
 29 |     node(int value){
 30 |         data=value;
 31 |         
 32 |     }
 33 | }
 34 | void InsertAtEnd(int insertValue){
 35 |     node t=new node(insertValue);
 36 |     if(head==null){
 37 |         head=t;
 38 |     }
 39 |     else{
 40 |         node temp=head;
 41 |         while(temp.next!=null)
 42 |         {
 43 |             temp=temp.next;
 44 |         }
 45 |         temp.next=t;
 46 |         
 47 |     }
 48 |     
 49 |     
 50 | }
 51 | void Display()
 52 | {
 53 |     if(head==null)
 54 |     {
 55 |         System.out.println("list is empty");
 56 |     }
 57 |     else{
 58 |         node temp=head;
 59 |       while(temp!=null)
 60 |         {
 61 |             System.out.print(temp.data);
 62 |             temp=temp.next;
 63 |         }
 64 |         System.out.println();
 65 |        
 66 |     }
 67 | }
 68 | void InsertAtMiddle(int insertValue,int pos){
 69 |     node t=new node(insertValue);
 70 |     if(pos>len)
 71 |     {
 72 |         System.out.println("enter valid position");
 73 |     }
 74 |     else if(pos==0)
 75 |     {
 76 |         node tem=head;
 77 |         head=t;
 78 |         t.next=tem;
 79 |     }else{
 80 |     int a=1;
 81 |     node temp=head;
 82 |     while(a!=pos)
 83 |     {
 84 |         temp=temp.next;
 85 |         a++;
 86 |     }
 87 |     node te=temp.next;
 88 |     temp.next=t;
 89 |     t.next=te;
 90 | }
 91 | }
 92 | void InsertAtBegin(int insertValue){
 93 |     node t=new node(insertValue);
 94 |     if(head==null){
 95 |         head=t;
 96 |     }
 97 |     else{
 98 |         node temp=head;
 99 |         head=t;
100 |         head.next=temp;
101 |     }
102 | }
103 | void DeleteAtEnd(){
104 |     if(head==null)
105 |     {
106 |         System.out.println("no element to delete");
107 |     }
108 |     node temp=head;
109 |     while(temp.next.next!=null)
110 |     {
111 |         temp=temp.next;
112 |     }
113 |     temp.next=null;
114 | }
115 | void DeleteBegin(){
116 |     node temp=head.next;
117 |     head=temp;
118 |     
119 | }
120 | void DeleteAtMid(int pos){
121 |     node temp=head;
122 |     if(pos>len)
123 |     {
124 |         System.out.println("enter valid position");
125 |     }
126 |     else if(pos==0)
127 |     {
128 |         head=head.next;
129 |     
130 |     }
131 |     else{
132 |     int a=1;
133 |     while(a!=pos)
134 |     {
135 |         temp=temp.next;
136 |         a++;
137 |     }
138 |     node te=temp.next;
139 |     temp.next=te.next;
140 |    // te=null;
141 |     
142 | }
143 | }
144 | void length()
145 | {
146 |     node temp=head;
147 |     while(temp!=null)
148 |     {
149 |         len++;
150 |         temp=temp.next;
151 |     }
152 |     	System.out.println(len);
153 | }
154 | }


--------------------------------------------------------------------------------
/Parent/stack/Main.java:
--------------------------------------------------------------------------------
  1 | import java.util.*;
  2 | public class Main
  3 | {
  4 | 	public static void main(String[] args) {
  5 | 		
  6 | 		Scanner scanner=new Scanner(System.in);
  7 | 		int capacity=scanner.nextInt();
  8 | 		int choice,value;
  9 | 		Stack a=new Stack(capacity);
 10 | 	 do
 11 |       {
 12 | 	System.out.println ("1. push operation");
 13 | 	System.out.println ("2. pop operation");
 14 | 	System.out.println ("3. peek operation");
 15 | 	System.out.println ("4. isempty operation");
 16 | 	System.out.println ("5. is full operation");
 17 | 	System.out.println ("6. Display");
 18 | 	System.out.println ("0. Exit");
 19 | 	System.out.print ("Enter your choice: ");
 20 | 	choice = scanner.nextInt ();
 21 | 	switch (choice)
 22 | 	  {
 23 | 	  case 1:
 24 | 	    System.out.print ("Enter valueto be push: ");
 25 | 	    value = scanner.nextInt ();
 26 | 	    a.push(value);
 27 | 	    System.out.println ("value is successfully pushed");
 28 | 	    break;
 29 | 	    case 2:
 30 | 	    a.pop();
 31 | 	    System.out.println ("value is successfully poped");
 32 | 	    break;
 33 | 	    case 3:
 34 | 	     a.peek();
 35 | 	     break;
 36 | 	    case 4:
 37 | 	      a.isempty();
 38 | 	    break;
 39 | 	    case 5:
 40 | 	      a.isfull();
 41 | 	    break;
 42 | 	    case 6:
 43 | 	      a.display();
 44 | 	    break;
 45 | 	    case 0:System.out.println ("mudunchu poda");
 46 | 	    break;
 47 | 	    default:System.out.println ("Invalid choice.");
 48 | 	  }
 49 |       }
 50 |     while (choice != 0);
 51 | 		
 52 | 		
 53 | 	}
 54 | }
 55 | class Stack{
 56 |     final int size;
 57 |     int top=-1;
 58 |     int a[];
 59 |     Stack(int cap){
 60 |        size=cap;
 61 |        a=new int[size];
 62 |     }
 63 |     void push(int data)
 64 |     {
 65 |         if(top==size-1)
 66 |         {
 67 |             System.out.println("stack is overflow");
 68 |         }
 69 |         else{
 70 |             
 71 |             a[++top]=data;
 72 |         }
 73 |     }
 74 |     void pop()
 75 |     {
 76 |         if(top==-1)
 77 |         {
 78 |             System.out.println("stack is underflow");
 79 |         }
 80 |         else{
 81 |             top--;
 82 |         }
 83 |     }
 84 |     void display(){
 85 |         if(top==-1){
 86 |             System.out.println("stack is empty");
 87 |         }
 88 |         else{
 89 |             for(int i=0;i<=top;i++)
 90 |             {
 91 |                 System.out.print(a[i]+" ");
 92 |             }
 93 |             System.out.println(" ");
 94 |         }
 95 |         
 96 |     }
 97 |     void peek()
 98 |     {
 99 |          if(top==-1)
100 |         {
101 |             System.out.println("stack is underflow");
102 |         }
103 |         else{
104 |             System.out.println("the peek element is:"+a[top]);
105 |         }
106 |     }
107 |     void isfull()
108 |     {
109 |            if(top==size)
110 |         {
111 |             System.out.println("stack is full");
112 |         }
113 |         else{
114 |             System.out.println("Stack is not full");
115 |         }
116 |     }
117 |     void isempty()
118 |     {
119 |         if(top==-1)
120 |         {
121 |             System.out.println("Stack is empty");
122 |         }
123 |         else{
124 |             System.out.println("Stack is not empty");
125 |         }
126 |     }
127 | }


--------------------------------------------------------------------------------
/Parent/tree/Main.java:
--------------------------------------------------------------------------------
  1 | import java.util.*;
  2 | 
  3 | public class Main {
  4 |     public static void main(String[] args) {
  5 |         Scanner sc=new Scanner(System.in);
  6 |       BST o=new BST();
  7 |       for(int i=0;i<5;i++)
  8 |       o.insert(sc.nextInt());
  9 |     System.out.print("Inorder :");
 10 |      o.inorder(o.Realroot);
 11 |       System.out.println();
 12 |      System.out.print("preorder :");
 13 |       o.preorder(o.Realroot);
 14 |        System.out.println();
 15 |      System.out.print("postorder :");
 16 |       o.postorder(o.Realroot);
 17 |        System.out.println();
 18 |              System.out.println(o.Search(o.Realroot,4));
 19 |              o.count(o.Realroot);
 20 |              System.out.println(o.cout);
 21 |              o.minimum(o.Realroot);
 22 |              o.maximum(o.Realroot);
 23 |              o.secondmaximum(o.Realroot);
 24 |              o.secondminimum(o.Realroot);
 25 |   }
 26 | }
 27 | class node{
 28 |   int data;
 29 |   node left,right;
 30 |   node(int key){
 31 |     data=key;
 32 |     left=right=null;
 33 |   }
 34 | }
 35 | 
 36 | class BST{
 37 |       node Realroot;
 38 |     void insert(int key){
 39 |         Realroot=insertRecursively(Realroot,key);
 40 |     }
 41 |     node insertRecursively(node dupRoot,int key){
 42 |  
 43 |         if(dupRoot==null){
 44 |           dupRoot=new node(key);
 45 |             return dupRoot;
 46 |         }
 47 |         if(key>dupRoot.data){
 48 |             dupRoot.right=insertRecursively(dupRoot.right,key);
 49 |         }  
 50 |        else if(key<dupRoot.data){
 51 |               dupRoot.left=insertRecursively(dupRoot.left,key);
 52 |         }
 53 |         return dupRoot;
 54 |     }
 55 |     void inorder(node root)
 56 |     {
 57 |         if(root!=null)
 58 |         {
 59 |              inorder(root.left);
 60 |              System.out.print(root.data+" ");
 61 |              inorder(root.right);
 62 |         }
 63 |     }
 64 |         void preorder(node root)
 65 |     {
 66 |         if(root!=null)
 67 |         {
 68 |              System.out.print(root.data+" ");
 69 |              preorder(root.left);
 70 |              preorder(root.right);
 71 |         }
 72 |     }
 73 |         void postorder(node root)
 74 |     {
 75 |         if(root!=null)
 76 |         {
 77 |              postorder(root.left);
 78 |              postorder(root.right);
 79 |              System.out.print(root.data+" ");
 80 |         }
 81 |     }
 82 |     boolean Search(node temp,int key){
 83 |        // node temp=Realroot;
 84 |            if(temp==null){
 85 |             return false;}
 86 |         else if(key<temp.data){
 87 |             return Search(temp.left,key);
 88 |         }
 89 |         else if(key>temp.data){
 90 |             return Search(temp.right,key);
 91 |         }
 92 |         else{
 93 |             return true;
 94 |         }
 95 |     }
 96 |     int cout=1;
 97 |       void count(node root)
 98 |     {
 99 |         if(root!=null)
100 |         {
101 |              count(root.left);
102 |           //   System.out.print(root.data+" ");
103 |              cout=cout+1;
104 |              count(root.right);
105 |         }
106 |     }
107 |     int minva=0;
108 |     int maxva=0;
109 |     void minimum(node temp)
110 |     {
111 |         if(temp==null)
112 |         {
113 |             System.out.println("tree is empty");
114 |         }
115 |         else{
116 |             while(temp!=null)
117 |             {
118 |                 minva=temp.data;
119 |                 temp=temp.left;
120 |             }
121 |             System.out.println("minimum value is :"+ minva);
122 |         }
123 |         
124 |     }
125 |         void maximum(node temp)
126 |     {
127 |         if(temp==null)
128 |         {
129 |             System.out.println("tree is empty");
130 |         }
131 |         else{
132 |             while(temp!=null)
133 |             {
134 |                 maxva=temp.data;
135 |                 temp=temp.right;
136 |             }
137 |             System.out.println("maximum  value is :"+ maxva);
138 |         }
139 |         
140 |     }
141 |     int secmax=0;
142 |     void secondmaximum(node temp)
143 |     {
144 |         if(temp==null)
145 |         {
146 |             System.out.println("tree is empty");
147 |         }
148 |         else{
149 |           int m=temp.data;
150 |             while(temp!=null)
151 |             {
152 |                 m=temp.data;
153 |                 secmax=m;
154 |                 temp=temp.right;
155 |             }
156 |             System.out.println("second maximum  value is :"+ secmax);
157 |         }
158 |         
159 |     }
160 |         int secmin=0;
161 |     void secondminimum(node temp)
162 |     {
163 |         if(temp==null)
164 |         {
165 |             System.out.println("tree is empty");
166 |         }
167 |         else{
168 |             while(temp.left!=null)
169 |             {
170 |                 secmin=temp.data;
171 |                 temp=temp.left;
172 |             }
173 |             System.out.println("second minimum  value is :"+ secmin);
174 |         }
175 |         
176 |     }
177 |   }
178 | 


--------------------------------------------------------------------------------
/Parent/valid paranthesis/Main.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | public class Main
 3 | {
 4 | 	public static void main(String[] args) {
 5 | 		
 6 | 		Scanner scanner=new Scanner(System.in);
 7 | 		int capacity=scanner.nextInt();
 8 | 		int choice,value;
 9 | 		Stack stack=new Stack(capacity);
10 | 		String s=scanner.next();
11 | 		for(char c : s.toCharArray())
12 |         {
13 |             if(c=='{')
14 |             {
15 |                 stack.push('}');
16 |             }
17 |             else if(c=='(')
18 |             {
19 |                 stack.push(')');
20 |             }
21 |             else if(c=='[')
22 |             {
23 |                 stack.push(']');
24 |             }
25 |             else if(stack.isempty() || stack.pop() != c)
26 |             {
27 |              System.out.println("false");
28 |              return;
29 |             }
30 |         }
31 |         System.out.println("true");
32 |         return;
33 |     }
34 | 	}
35 | 
36 | class Stack{
37 |     final int size;
38 |     int top=-1;
39 |     int a[];
40 |     Stack(int cap){
41 |        size=cap;
42 |        a=new int[size];
43 |     }
44 |     void push(char data)
45 |     {
46 |         if(top==size-1)
47 |         {
48 |             System.out.println("stack is overflow");
49 |         }
50 |         else{
51 |             
52 |             a[++top]=data;
53 |         }
54 |     }
55 |     char pop()
56 |     {
57 |         if(top==-1)
58 |         {
59 |             System.out.println("stack is underflow");
60 |         }
61 |         else{
62 |             top--;
63 |         }
64 |         //return true;
65 |     }
66 |     boolean isempty()
67 |     {
68 |         if(top==-1)
69 |         {
70 |           return false;
71 |         }
72 |         return true;
73 |         
74 |     }
75 |     
76 | }


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # DataStructure_Java
2 | # DataStructure_Java
3 | 


--------------------------------------------------------------------------------
/STACK/main.c:
--------------------------------------------------------------------------------
  1 | #include<stdio.h>
  2 | #include<stdlib.h>
  3 | #define s 5 
  4 | int top=-1,a[5];
  5 | void push();
  6 | void pop();
  7 | void max();
  8 | void print();
  9 | void min();
 10 | void odd();
 11 | void even();
 12 | int main()
 13 | {
 14 |     int ch;
 15 |     while(1)
 16 |     {
 17 |        
 18 |         printf("\n1.PUSH operation");
 19 |         printf("\n2.POP operation");
 20 |         printf("\n3.PRINT operation");
 21 |         printf("\n4.maximum ");
 22 |          printf("\n5.minimum ");
 23 |           printf("\n6.odd ");
 24 |            printf("\n7.even ");
 25 |            printf("\n");
 26 |            printf("enter your choice");
 27 |       scanf("%d",&ch);
 28 |         switch(ch)
 29 |         {
 30 |             case 1:
 31 |                 push();
 32 |                 break;
 33 |             case 2:
 34 |                 pop();
 35 |                 break;
 36 |             case 3:
 37 |                 print();
 38 |                 break;
 39 |             case 4:
 40 |                 max();
 41 |             case 8:
 42 |                 exit(1);
 43 |                 break;
 44 |             case 5:
 45 |                 min();
 46 |                 break;
 47 |             case 6:
 48 |                 odd();
 49 |                 break;
 50 |                 
 51 |             case 7:
 52 |                 even();
 53 |                 break;
 54 |                 
 55 |             default:
 56 |                 printf("\n Enter correct choice:");
 57 |                 break;
 58 |         }
 59 |     }
 60 | }
 61 | void push(){
 62 |     int x;
 63 |     if(top==s-1)
 64 |     {
 65 |         printf("stack overflow");
 66 |     }
 67 |     else
 68 |     {
 69 |         printf("enter the element to be inserted:");
 70 |         scanf("%d",&x);
 71 |         top=top+1;
 72 |         a[top]=x;
 73 |     }
 74 | }
 75 | void pop()
 76 | {
 77 |     if(top==-1)
 78 |     {
 79 |         printf("stack overflow");
 80 |     }
 81 |     else
 82 |     {
 83 |         printf("the deleted element is:");
 84 |         printf("%d",a[top]);
 85 |         top=top-1;
 86 |     }
 87 | }
 88 | void print()
 89 |     {
 90 |      if(top==-1)
 91 |     {
 92 |         printf("stack overflow");
 93 |     }
 94 |     else
 95 |     {
 96 |         for(int i=0;i>=0;--i)
 97 |         {
 98 |             printf("%d",a[i]);
 99 |         }
100 |     }
101 |     
102 | }
103 | void max()
104 | {
105 |     int max=0;
106 |     for(int i=0;i<=top;i++)
107 |         {
108 |            if(a[i]>=max)
109 |            {
110 |                max=a[i];
111 |            }
112 |         }
113 |         printf("%d",max);
114 |     
115 | }
116 | void min()
117 | {
118 |     int min=a[0];
119 |     for(int i=0;i<=top;i++)
120 |         {
121 |            if(a[i]<=min)
122 |            {
123 |                min=a[i];
124 |            }
125 |         }
126 |         printf("%d",min);
127 |     
128 | }
129 | void odd()
130 | {
131 |        for(int i=0;i<=top;i++)
132 |         {
133 |            if(a[i]%2!=0)
134 |            {
135 |              printf("%d",a[i]);
136 |            }
137 |         }
138 |         
139 | }
140 | void even()
141 | {
142 |        for(int i=0;i<=top;i++)
143 |         {
144 |            if(a[i]%2==0)
145 |            {
146 |              printf("%d",a[i]);
147 |            }
148 |         }
149 |         
150 | }


--------------------------------------------------------------------------------
/calloc basic/source code:
--------------------------------------------------------------------------------
 1 | 
 2 | #include <stdio.h>
 3 | #include<stdlib.h>
 4 | 
 5 | 
 6 | int main()
 7 | {
 8 |     int n,*p=NULL;
 9 |     scanf("%d",&n);
10 |     p=(int*)calloc(n,sizeof(int));
11 |     if(p==NULL)
12 |     {
13 |         
14 |         printf("no memory allocated");
15 |     }
16 |     else
17 |     {
18 |         for(int i=0;i<n;i++)
19 |         {
20 |             scanf("%d",p+i);
21 |         }
22 |         for(int i=0;i<n;i++)
23 |         {
24 |             printf("%d",p[i]);
25 |              printf("%d",*p+i);
26 |         }
27 |         free(p);
28 |         p=NULL;
29 |     }
30 | 
31 |     return 0;
32 | }


--------------------------------------------------------------------------------
/circularlinked list/Main.java:
--------------------------------------------------------------------------------
 1 | public class Main
 2 | {
 3 |     public static void main(String[] args) {
 4 |         System.out.println("Hello World");
 5 |         circular a=new circular();
 6 |         a.InsertBegin(6);
 7 |         a.InsertBegin(6);
 8 |         a.InsertEnd(8);
 9 |         a.InsertAtMiddle(1,2);
10 |         a.display();
11 |     }
12 | }
13 | class circular{
14 |     node head,tail;
15 |     class node{
16 |         int data;
17 |         node next;
18 |         node(int value){
19 |             data=value;
20 |             next=null;
21 |         }
22 |     }
23 |     void InsertBegin(int n)
24 |     {
25 |         node t=new node(n);
26 |         if(head==null){
27 |             head=t;
28 |             tail=t;
29 |         }
30 |         else{
31 |            tail.next=t;
32 |            t.next=head;
33 |            head=t;
34 |             
35 |         }
36 |     }
37 |     void InsertEnd(int m)
38 |     {
39 |       node t=new node(m);
40 |       if(head==null){
41 |         head=tail=t;
42 |         t.next=head;
43 |       }
44 |       else{
45 |         tail.next=t;
46 |         t.next=head;
47 |         head=t;
48 |       }
49 |     }
50 |     void InsertAtMiddle(int insertValue,int pos){
51 |     node t=new node(insertValue);
52 |     /*if(pos>len)
53 |     {
54 |         System.out.println("enter valid position");
55 |     }
56 |     else*/ if(pos==0)
57 |     {
58 |         node tem=head;
59 |         head=t;
60 |         t.next=tem;
61 |     }else{
62 |     int a=1;
63 |     node temp=head;
64 |     while(a!=pos)
65 |     {
66 |         temp=temp.next;
67 |         a++;
68 |     }
69 |     node te=temp.next;
70 |     temp.next=t;
71 |     t.next=te;
72 | }
73 | }
74 | void display()
75 | {
76 |     if(head==null)
77 |     {
78 |         System.out.print("list is empty");
79 |     }
80 |     else{
81 |         node temp=head;
82 |         do{
83 |             System.out.print(temp.data+" ");
84 |             temp=temp.next;
85 |             
86 |         }while(temp!=head);
87 |     }
88 | }
89 | }


--------------------------------------------------------------------------------
/deletion of a bst/source code:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | 
 3 | public class Main {
 4 |     public static void main(String[] args) {
 5 |      BST o=new BST();
 6 |      o.insert(5);
 7 |      o.insert(3);
 8 |      o.insert(1);
 9 |      o.insert(11);
10 |      o.insert(6);
11 |      o.insert(12);
12 |      o.insert(13);
13 |      o.delete(o.Root,3);
14 |      o.delete(o.Root,1);
15 |      o.delete(o.Root,11);
16 |      o.inorder(o.Root);
17 |   }
18 | }
19 | class node{
20 |   int data;
21 |   node left,right;
22 |   node(int value){
23 |     data=value;
24 |     left=right=null;
25 |   }
26 | }
27 | class BST{
28 |   void inorder(node temp){
29 |     if(temp!=null){
30 |       inorder(temp.left);
31 |       System.out.print(temp.data+"  ");
32 |       inorder(temp.right);
33 |     }
34 |   }
35 |   node Root;
36 |   void insert(int key){
37 |     Root=inserting(Root,key);
38 |   }
39 |   node inserting(node duplicateRoot,int key){
40 |     if(duplicateRoot==null)
41 |     {
42 |       duplicateRoot=new node(key);
43 |       return duplicateRoot;
44 |     }
45 |     if(key>duplicateRoot.data)
46 |     duplicateRoot.right=inserting(duplicateRoot.right,key);
47 |     else if(key<duplicateRoot.data)
48 |     duplicateRoot.left=inserting(duplicateRoot.left,key);
49 |    
50 |      return duplicateRoot;
51 |     
52 |   }
53 |   node delete(node temp,int target){
54 |     if(temp==null)
55 |     return temp;
56 |     if(target>temp.data)
57 |     temp.right=delete(temp.right,target);
58 |     else if(target<temp.data)
59 |     temp.left=delete(temp.left,target);
60 |     else{
61 |       if(temp.left==null)
62 |       return temp.right;
63 |       else if(temp.right==null)
64 |       return temp.left;
65 |       temp.data=min(temp.right);
66 |       temp.right=delete(temp.right,temp.data);
67 |      
68 |     } return temp;
69 |   }
70 |   int min(node temp){
71 |     if(temp==null){
72 |     System.out.println("Empty tree");return -1;}
73 |     else {
74 |       int minValue=temp.data;
75 |       while(temp!=null){
76 |         minValue=temp.data;
77 |         temp=temp.left;
78 |       }
79 |       return minValue;
80 |     }
81 |   }
82 |   
83 | 
84 |   
85 | }
86 | 


--------------------------------------------------------------------------------
/depth of the tree/Main.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | 
 3 | public class Main {
 4 |     public static void main(String[] args) {
 5 |         Scanner sc=new Scanner(System.in);
 6 |       BST o=new BST();
 7 |       System.out.println("enter how many node to be created");
 8 |       int a=sc.nextInt();
 9 |       for(int i=0;i<a;i++)
10 |       o.insert(sc.nextInt());
11 |       System.out.println(o.depth(o.Realroot));
12 |     }
13 | }
14 | 
15 | 
16 | class node{
17 |   int data;
18 |   node left,right;
19 |   node(int key){
20 |     data=key;
21 |     left=right=null;
22 |   }
23 | }
24 | 
25 | class BST{
26 |       node Realroot;
27 |     void insert(int key){
28 |         Realroot=insertRecursively(Realroot,key);
29 |     }
30 |     node insertRecursively(node dupRoot,int key){
31 |  
32 |         if(dupRoot==null){
33 |           dupRoot=new node(key);
34 |             return dupRoot;
35 |         }
36 |         if(key>dupRoot.data){
37 |             dupRoot.right=insertRecursively(dupRoot.right,key);
38 |         }  
39 |        else if(key<dupRoot.data){
40 |               dupRoot.left=insertRecursively(dupRoot.left,key);
41 |         }
42 |         return dupRoot;
43 |     }
44 | 
45 | int depth(node root)
46 | {
47 |     if(root==null)
48 |     {
49 |         return 0;
50 |     }
51 |     if(root.left==null)
52 |     {
53 |         return depth(root.right)+1;
54 |     }
55 |      if(root.right==null)
56 |     {
57 |         return depth(root.left)+1;
58 |     }
59 |     return Math.max(depth(root.left),depth(root.right));
60 | }
61 | }


--------------------------------------------------------------------------------
/double ended queue/Main.java:
--------------------------------------------------------------------------------
 1 | public class Main{
 2 |   public static void main (String[] args) {
 3 |     DoubleEndedQueue o=new DoubleEndedQueue();
 4 |     
 5 |     o.enqRear(4);
 6 |     o.enqRear(5);
 7 |     o.enqRear(6);
 8 |     o.enqRear(7);
 9 |    o.enqFront(123);
10 |    o.dequeueFront();
11 |   }
12 | }
13 | class DoubleEndedQueue{
14 |   final int size;
15 |   int a[];
16 |   int front,rear;
17 |   DoubleEndedQueue(){
18 |     size=5;
19 |     a=new int[size];
20 |     rear=-1;front=-1;
21 |   }
22 |   DoubleEndedQueue(int userSize){
23 |     size=userSize;
24 |     a=new int[size];
25 |     rear=-1;front=-1;
26 |   }
27 |   boolean isFull(){
28 |     if((front==0&&rear==size-1)||( front==rear+1))
29 |     return true;
30 |     return false;
31 |   }
32 |   void enqFront(int value){
33 |     if(isFull()){
34 |     System.out.println("QUEUE OVERFLOW");
35 |     return ;
36 |     }
37 |     else if(front==-1&&rear==-1){
38 |       front=0;
39 |       a[front]=value;
40 |        front=size;
41 |     }
42 |   else if(front==0){
43 |       front=size;
44 |     }
45 |     a[--front]=value;
46 |      }
47 |   void enqRear(int value){
48 |    if(isFull())
49 |    System.out.println("QUEUE OVERFLOW");
50 |    else if(front==-1&&rear==-1)
51 |    front=rear=0;
52 |    else if(rear==-1 && front!=-1)
53 |    rear=1;
54 |    else rear++;
55 |    a[rear]=value;
56 |      }
57 |   void dequeueFront(){
58 |     if(front==-1&&rear==-1)
59 |     System.out.println("QUEUE UNDERFLOW");
60 |     else if(front==rear)
61 |     front=rear=-1;
62 |     else if(front==size-1)
63 |     front=0;
64 |     else front--;
65 |   }
66 | }


--------------------------------------------------------------------------------
/doubly/Main.java:
--------------------------------------------------------------------------------
  1 | 
  2 | public class Main
  3 | {
  4 | 	public static void main(String[] args) {
  5 | 		System.out.println("Hello World");
  6 | 		Doubly o=new Doubly();
  7 | 		    o.InsertAtBegin(9);
  8 | 			o.InsertAtBegin(9);
  9 | 			o.InsertAtBegin(9);
 10 | 			o.InsertAtBegin(9);
 11 | 			o.InsertAtBegin(9);
 12 | 			o.InsertAtEnd(4);
 13 | 			o.InsertAtMiddle(54,1);
 14 | 			o.Display();
 15 | 			
 16 | 		    o.length();
 17 | 		   
 18 | 				}
 19 | }
 20 | class Doubly{
 21 |     node head,tail;
 22 |     class node{
 23 |         int data;
 24 |         node prev,next;
 25 |         node(int value){
 26 |             data=value;
 27 |             prev=next=null;
 28 |         }
 29 |     }
 30 |     int l=0;
 31 |     void InsertAtEnd(int d){
 32 |         node t=new node(d);
 33 |         if(head==null)
 34 |         {
 35 |             head=tail=t;
 36 |             t.next=head;
 37 |             head.prev=t;
 38 |         }
 39 |         else{
 40 |             tail.next=t;
 41 |              t.prev=tail;
 42 |             t.next=head;
 43 |             head.prev=t;
 44 |             tail=t;
 45 |         }
 46 |         
 47 |     }
 48 |    void Display(){
 49 |         if(head==null){
 50 |           System.out.print("no element to display");
 51 |             
 52 |         }else{
 53 |           node t=head;
 54 |          do{
 55 |             System.out.print(t.data+" ");
 56 |             t=t.next;
 57 |           } while(t!=tail.next);
 58 |           System.out.println("");
 59 |         }
 60 |     }
 61 |     void InsertAtBegin(int d){
 62 |       node t=new node(d);
 63 |       if(head==null){
 64 |         head=tail=t;
 65 |        head.prev=tail;
 66 |       }else{
 67 |         node te=head;
 68 |         head=t;
 69 |         head.prev=tail;
 70 |         head.next=te;
 71 |         te.prev=head;
 72 |         tail.next=head;
 73 |  
 74 |       }
 75 |       
 76 |     }
 77 |     void InsertAtMiddle(int d,int pos){
 78 |      length();
 79 |       node t=new node(d);
 80 |       if(pos==0){
 81 |       InsertAtBegin(d);
 82 |       }
 83 |        else if(pos>=l|| pos<0){
 84 |               System.out.println("enter valid position");
 85 |                             }
 86 |           else{
 87 |                 int i=0;
 88 |                 node temp=head;
 89 |                 node temp1=head;
 90 |                 while(i!=pos){
 91 |                 temp1=temp;
 92 |                 temp=temp.next;
 93 |                  i++;
 94 |       }
 95 |     
 96 |       temp1.next=t;
 97 |       t.prev=temp1;
 98 |       t.next=temp;
 99 |       temp.prev=t;
100 |           }
101 |           
102 |     }
103 |     void length()
104 |     {
105 |         l=0;
106 |         node temp=head;
107 |     do        {
108 |             temp =temp.next;
109 |             l++;
110 |        
111 |         }   while(temp!=tail);
112 |         //System.out.println(l+1);
113 |     }
114 |     
115 | }


--------------------------------------------------------------------------------
/heterogeneous array list/source code:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | public class Main {
 3 |     public static void main(String[] args) {
 4 |   arrayList1<Integer> a=new arrayList1<Integer>();
 5 |  a.insert(1);
 6 |  a.insert(2);
 7 |  a.insert(3);
 8 |  a.insert(4);
 9 |  a.insert(5);
10 |  a.display();
11 |  arrayList1<String> b=new arrayList1<String>();
12 |   b.insert("a");
13 |  b.insert("b");
14 |  b.insert("c");
15 |  b.insert("d");
16 |  b.insert("e");
17 |  b.display();
18 |       }
19 | }
20 | class arrayList1<anytype>{
21 |  final static int initialSize=4;
22 | private anytype a[]=(anytype[])new Object[initialSize];
23 |  int index=0,capacity=initialSize;
24 |  
25 |  void insert(anytype value){
26 |   if(index==capacity)
27 |   grow();
28 |    a[index++]=value;
29 |  }
30 |  
31 |  void grow(){
32 |    capacity=capacity*2;
33 |    a=Arrays.copyOf(a,capacity);
34 |     }
35 |     
36 |  void display(){
37 |    if(index==0)
38 |    System.out.println("List Is Empty");
39 |    else{
40 |      for(int i=0;i<index;i++)
41 |    System.out.print(a[i]+" ");
42 |    System.out.println();
43 |  }
44 | }
45 | }


--------------------------------------------------------------------------------
/malloc basic/main.c:
--------------------------------------------------------------------------------
 1 | 
 2 | #include <stdio.h>
 3 | #include<stdlib.h>
 4 | 
 5 | 
 6 | int main()
 7 | {
 8 |     int n,*p=NULL;
 9 |     scanf("%d",&n);
10 |     p=(int*)malloc(n*sizeof(int));
11 |     if(p==NULL)
12 |     {
13 |         
14 |         printf("no memory allocated");
15 |     }
16 |     else
17 |     {
18 |         for(int i=0;i<n;i++)
19 |         {
20 |             scanf("%d",p+i);
21 |         }
22 |         for(int i=0;i<n;i++)
23 |         {
24 |             printf("%d",p[i]);
25 |              printf("%d",*p+i);
26 |         }
27 |         free(p);
28 |         p=NULL;
29 |     }
30 | 
31 |     return 0;
32 | }
33 | 


--------------------------------------------------------------------------------
/queue using array implementation/source code:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | 
 3 | public class Main {
 4 |     public static void main(String[] args) {
 5 |       Queue a=new Queue(6);
 6 |       a.enqueue(12);
 7 |       System.out.println(a.dequeue());
 8 |       System.out.println(a.dequeue());
 9 |     
10 |   }
11 | }
12 | class Queue{
13 |   final int size;
14 |   int a[];
15 |   int front,rear;
16 |   Queue(){
17 |     size=5;
18 |     a=new int[size];
19 |     front=rear=-1;
20 |   }
21 |   Queue(int userSize){
22 |     size=userSize;
23 |     a=new int[size];
24 |     front=rear=-1;
25 |   }
26 |   void enqueue(int data){
27 |     if(front==-1 && rear==-1){
28 |       front=0;
29 |       a[++rear]=data;
30 |     }
31 |     else if(rear==size-1)
32 |     System.out.println("QUEUE OVERFLOW");
33 |     else{
34 |        a[++rear]=data;
35 |     }
36 |   }
37 |   int dequeue(){
38 |      if(front==-1 && rear==-1){
39 |        System.out.println("QUEUE UNDERFLOW");  
40 |        return -1;
41 |      }
42 |      else if(front==rear){
43 |        int copy=a[front];
44 |      front=rear=-1;
45 |      return copy;
46 |   }
47 |   return a[front++];
48 | }
49 | }


--------------------------------------------------------------------------------
/realloc/main.c:
--------------------------------------------------------------------------------
 1 | 
 2 | #include <stdio.h>
 3 | #include<stdlib.h>
 4 | 
 5 | 
 6 | int main()
 7 | {
 8 |     int n,*p=NULL;
 9 |     scanf("%d",&n);
10 |     p=(int*)malloc(n*sizeof(int));
11 |     if(p==NULL)
12 |     {
13 |         
14 |         printf("no memory allocated");
15 |     }
16 |     else
17 |     {
18 |         for(int i=0;i<n;i++)
19 |         {
20 |             scanf("%d",p+i);
21 |         }
22 |         for(int i=0;i<n;i++)
23 |         {
24 |             printf("%d",p[i]);
25 |           
26 |         }
27 |         int k;
28 |         scanf("%d",&k);
29 |         p=realloc(p,k*sizeof(int));
30 |          for(int i=0;i<k;i++)
31 |         {
32 |             scanf("%d",p+i);
33 |         }
34 |         for(int i=0;i<k;i++)
35 |         {
36 |             printf("%d",p[i]);
37 |           
38 |         }
39 |         free(p);
40 |         p=NULL;
41 |     }
42 | 
43 |     return 0;
44 | }


--------------------------------------------------------------------------------
/relloc still user input/main.c:
--------------------------------------------------------------------------------
 1 | 
 2 | #include <stdio.h>
 3 | #include<stdlib.h>
 4 | int main()
 5 | {
 6 |     int n,*p=NULL;
 7 |     scanf("%d",&n);
 8 |     p=(int*)malloc(n*sizeof(int));
 9 |     if(p==NULL)
10 |     {
11 |         
12 |         printf("no memory allocated");
13 |     }
14 |     else
15 |     {
16 |         for(int i=0;i<n;i++)
17 |         {
18 |             scanf("%d",p+i);
19 |         }
20 |         for(int i=0;i<n;i++)
21 |         {
22 |             printf("%d",p[i]);
23 |           
24 |         }
25 |         int k,ch;
26 |         while(1)
27 |         {
28 |             
29 |         printf("\n1 memory allocate");
30 |         printf("\n0 no memory want");
31 |         printf("\n enter your choice:");
32 |         scanf("%d",&ch);
33 |         switch(ch)
34 |         {
35 |         case 1:
36 |             {
37 |             printf("\n give the size of extend memory: ");
38 |             scanf("%d",&k);
39 |             p=realloc(p,k*sizeof(int));
40 |             for(int i=n;i<k;i++)
41 |             {
42 |             scanf("%d",p+i);
43 |             }
44 |            
45 |                 n=k;
46 |             
47 |             }
48 |             break;
49 |             case 0:
50 |             {
51 |                  for(int i=0;i<k;i++)
52 |             {
53 |             printf("%d",p[i]);
54 |           
55 |             }
56 |             exit(0);
57 |             }
58 |         }
59 |     }
60 |     }
61 |     
62 | 
63 |     return 0;
64 | }
65 | 


--------------------------------------------------------------------------------
/reverse a singly list/Main.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | 
 3 | public class Main {
 4 |     public static void main(String[] args) {
 5 |         Practice o = new Practice();
 6 |         o.increase(1);
 7 |         o.increase(2);
 8 |         o.increase(3);
 9 |         o.increase(4);
10 |         o.increase(5);
11 |       //  o.tell();
12 |         o.person1=find(o.person1, o.p2);
13 |     o.tell();
14 |     }
15 | 
16 |     static inner find(inner a, inner b) {
17 |         inner prev = null;
18 |         inner current = a;
19 |         inner nextNode;
20 |         while (current != null) {
21 |             nextNode = current.next;
22 |             current.next = prev;
23 |             prev = current;
24 |             current = nextNode;
25 |         }
26 |        a=prev;
27 |              return prev;
28 |         // a = prev;
29 |         // System.out.println(" ");
30 |         // while(prev!=null)
31 |         // {
32 |         //   System.out.print(prev.value+"  ");
33 |         //   prev=prev.next;
34 |         // }
35 |     }
36 | }
37 | class inner {
38 |     int value;
39 |     inner next;
40 | 
41 |     inner(int l) {
42 |         value = l;
43 |     }
44 | }
45 | class Practice {
46 |     inner person1, p2;
47 |     void increase(int baby) {
48 |         inner name = new inner(baby);
49 |         if (person1 == null)
50 |             person1 = p2 = name;
51 |         else {
52 |             p2.next = name;
53 |             p2 = name;
54 |         }
55 |     }
56 | 
57 |     void tell() {
58 |         inner temp = person1;
59 |         while (temp != null) {
60 |             System.out.print(temp.value + "   ");
61 |             p2=temp;
62 |             temp = temp.next;
63 |         }
64 |         
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/simple array insertion/Main.java:
--------------------------------------------------------------------------------
  1 | import java.util.*;
  2 | public class Main {
  3 |     public static void main(String[] args) {
  4 |       //object creation for the ArrayList class
  5 |   ArrayList a=new ArrayList();
  6 |   //calling insert method in the ArrayList by using it's object 
  7 |  a.insert(1);
  8 |  a.insert(2);
  9 |  a.insert(3);
 10 |  a.insert(4);
 11 |  a.insert(5);
 12 |  a.display();
 13 |  a.insert(1);
 14 |  a.insert(2);
 15 |  a.insert(3);
 16 |  a.insert(4);
 17 |  a.insert(5);
 18 |  a.display();
 19 |  a.InsertParticular(28,3);
 20 |  a.DeleteParticularIndex(3);
 21 |  a.display();
 22 |  System.out.println("thank you for coming");
 23 |       }
 24 | }
 25 | class ArrayList{
 26 |   //initial size varible for every objects
 27 |  final static int initialSize=4;
 28 | //array declaration
 29 | private int a[]=new int[initialSize];
 30 | //index variable for data insertion and capacity for denoting total data can be added  
 31 |  int index=0,capacity=initialSize;
 32 |  //insert method
 33 |  void insert(int value){
 34 | //array capacity  reached condition 
 35 |   if(index==capacity)
 36 |   //calling grow method to increase the array size
 37 |   grow();
 38 |   //inserting data in the arraylist
 39 |    a[index++]=value;
 40 |  }
 41 |  void grow(){
 42 |   //increaing capacity value
 43 |    capacity=capacity*2;
 44 |    //copying original array with the increased capacity size and reassigning the new array referncwe to original array reference variable
 45 |    a=Arrays.copyOf(a,capacity);
 46 |    
 47 |    }
 48 |    void InsertParticular(int value,int pos)
 49 |    {
 50 |        if(pos>capacity||pos<0)
 51 |        {
 52 |           System.out.println("enter valid position");
 53 |           return;
 54 |        }
 55 |        if(pos==index)
 56 |        {
 57 |            a[pos]=value;
 58 |            return;
 59 |        }
 60 |        else 
 61 |        {
 62 |            if(index==capacity)
 63 |            {
 64 |                grow();
 65 |            }
 66 |            
 67 |            for(int i=index;i>pos;i--)
 68 |            {
 69 |                 a[i]=a[i-1];
 70 |            }
 71 |            a[pos]=value;
 72 |            index++;
 73 |            }
 74 |        
 75 |     
 76 |    }
 77 |    void DeleteParticularIndex(int pos){
 78 |     if(index==0)
 79 |     {
 80 |         System.out.println("no element to delete");
 81 |         return;
 82 |     }
 83 |     if(pos>=capacity){
 84 |         System.out.println("give correct index");
 85 |         return;
 86 |     }
 87 |     else{
 88 |         for(int i=pos;i<index-1;i++)
 89 |         {
 90 |             a[i]=a[i+1];
 91 |         }
 92 |       index--;
 93 |            }
 94 |     }
 95 |      
 96 |  //display method to show data to user
 97 |  void display(){
 98 |   //array under flow condition
 99 |    if(index==0)
100 |    System.out.println("List Is Empty");
101 |    else{
102 |      for(int i=0;i<index;i++)
103 |    System.out.print(a[i]+" ");
104 |    System.out.println();
105 |  }
106 | }
107 | }


--------------------------------------------------------------------------------
/singly linked insertion and display/main.c:
--------------------------------------------------------------------------------
 1 | 
 2 | #include <stdio.h>
 3 | #include<stdlib.h>
 4 | void insert();
 5 | void display();
 6 | struct node{
 7 |     int data;
 8 |     struct node*next;
 9 | }*head=NULL,*ne,*temp;
10 | 
11 | int main()
12 | {
13 |     int n;
14 |     head=(struct node*)malloc(sizeof(struct node));
15 |     printf("enter the head value:");
16 |     scanf("%d",&head->data);
17 |     head->next=NULL;
18 |     temp=head;
19 |     printf("enter how many node created:");
20 |     int k;
21 |     scanf("%d",&k);
22 |     for(int i=0;i<k;i++)
23 |     {
24 |         insert();
25 |     }
26 |   display();
27 | }
28 |     
29 |     
30 | void insert()
31 | {
32 |        ne=(struct node*)malloc(sizeof(struct node));
33 |        printf("enter the element to be inserted:");
34 |        scanf("%d",&ne->data);
35 |        temp->next=ne;
36 |        temp=ne;
37 |        ne->next=NULL;
38 |        
39 |        
40 | }
41 |        
42 | void display()
43 | {
44 |     temp=head;
45 |     while(temp!=NULL)
46 |     {
47 |         printf("%d ",temp->data);
48 |         temp=temp->next;
49 |     }
50 | }
51 | 
52 | 


--------------------------------------------------------------------------------
/singly linked list basic/main.c:
--------------------------------------------------------------------------------
 1 | 
 2 | #include <stdio.h>
 3 | #include<stdlib.h>
 4 | struct node{
 5 |     int data;
 6 |     struct node*next;
 7 | }*head=NULL;
 8 | 
 9 | int main()
10 | {
11 |     int n;
12 |     struct node*temp,*ne;
13 |     head=(struct node*)malloc(sizeof(struct node));
14 |     printf("enter the head value:");
15 |     scanf("%d",&head->data);
16 |     head->next=NULL;
17 |     temp=head;
18 |     int choice;
19 |     do
20 |     {
21 |        ne=(struct node*)malloc(sizeof(struct node));
22 |        printf("enter the element to be inserted:");
23 |        scanf("%d",&ne->data);
24 |        temp->next=ne;
25 |        temp=ne;
26 |        ne->next=NULL;
27 |        printf("enter your choice:");
28 |        scanf("%d",&choice);
29 |        
30 |        
31 |     }while(choice!=0);
32 |     temp=head;
33 |     while(temp!=NULL)
34 |     {
35 |         printf("%d ",temp->data);
36 |         temp=temp->next;
37 |     }
38 | }
39 | 
40 | 


--------------------------------------------------------------------------------
/singly linked list in java using switch/Main.java:
--------------------------------------------------------------------------------
  1 | import java.util.*;
  2 | public class Main
  3 | {
  4 |   public static void main (String[]args)
  5 |   {
  6 |     System.out.println
  7 |       ("**********************welcome to kidumutti shop******************************");
  8 |     Scanner scanner = new Scanner (System.in);
  9 |     Singly a = new Singly ();
 10 |       a.length ();
 11 |     int choice = 0, value = 0, pos = 0;
 12 |     do
 13 |       {
 14 | 	System.out.println ("1. Insert at beginning");
 15 | 	System.out.println ("2. Insert at end");
 16 | 	System.out.println ("3. InsertAtMiddle");
 17 | 	System.out.println ("4. DeleteBegin");
 18 | 	System.out.println ("5. DeleteAtMid");
 19 | 	System.out.println ("6. DeleteAtEnd");
 20 | 	System.out.println ("7. length");
 21 | 	System.out.println ("8. Display");
 22 | 	System.out.println ("0. Exit");
 23 | 	System.out.print ("Enter your choice: ");
 24 | 	choice = scanner.nextInt ();
 25 | 	switch (choice)
 26 | 	  {
 27 | 	  case 1:
 28 | 	    System.out.print ("Enter value: ");
 29 | 	    value = scanner.nextInt ();
 30 | 	    a.InsertAtBegin (value);
 31 | 	    System.out.println ("value is successfully inserted");
 32 | 	    break;
 33 | 	    case 2:System.out.print ("Enter value: ");
 34 | 	    value = scanner.nextInt ();
 35 | 	    a.InsertAtEnd (value);
 36 | 	    System.out.println ("value is successfully inserted");
 37 | 	    break;
 38 | 	    case 3:System.out.println ("Enter value to InsertAtMiddle: ");
 39 | 	    value = scanner.nextInt ();
 40 | 	    System.out.println ("Enter position");
 41 | 	    pos = scanner.nextInt ();
 42 | 	    a.InsertAtMiddle (value, pos);
 43 | 	    System.out.println ("value is successfully inserted");
 44 | 	    break;
 45 | 	    case 4:a.DeleteBegin ();
 46 | 	    System.out.println ("value is successfully delted");
 47 | 	    break;
 48 | 	    case 5:System.out.println ("enter the position to be deleted");
 49 | 	    pos = scanner.nextInt ();
 50 | 	    a.DeleteAtMid (pos);
 51 | 	    System.out.println ("value is successfully deleted");
 52 | 	    break;
 53 | 	    case 6:a.DeleteAtEnd ();
 54 | 	    System.out.println ("value is successfully deleted");
 55 | 	    break;
 56 | 
 57 | 	    case 7:a.length ();
 58 | 	    break;
 59 | 	    case 8:a.Display ();
 60 | 	    break;
 61 | 	    case 0:System.out.println ("mudunchu poda");
 62 | 	    break;
 63 | 
 64 | 	    default:System.out.println ("Invalid choice.");
 65 | 	  }
 66 |       }
 67 |     while (choice != 0);
 68 | 
 69 |   }
 70 | }
 71 | 
 72 | class Singly
 73 | {
 74 |   int len = 0;
 75 |   node head;
 76 |   class node
 77 |   {
 78 |     int data;
 79 |     node next;
 80 |       node (int value)
 81 |     {
 82 |       data = value;
 83 | 
 84 |     }
 85 |   }
 86 |   void InsertAtEnd (int insertValue)
 87 |   {
 88 |     node t = new node (insertValue);
 89 |     if (head == null)
 90 |       {
 91 | 	head = t;
 92 |       }
 93 |     else
 94 |       {
 95 | 	node temp = head;
 96 | 	while (temp.next != null)
 97 | 	  {
 98 | 	    temp = temp.next;
 99 | 	  }
100 | 	temp.next = t;
101 | 
102 |       }
103 | 
104 | 
105 |   }
106 |   void Display ()
107 |   {
108 |     if (head == null)
109 |       {
110 | 	System.out.println ("list is empty");
111 |       }
112 |     else
113 |       {
114 | 	node temp = head;
115 | 	while (temp != null)
116 | 	  {
117 | 	    System.out.print (temp.data + " ");
118 | 	    temp = temp.next;
119 | 	  }
120 | 	System.out.println ();
121 | 
122 |       }
123 |   }
124 |   void InsertAtMiddle (int insertValue, int pos)
125 |   {
126 |     node t = new node (insertValue);
127 |     if (head == null)
128 |       {
129 | 	System.out.println ("list is empty");
130 |       }
131 |     if (pos > len)
132 | 
133 |       {
134 | 	System.out.println ("enter valid position");
135 |       }
136 |     else if (pos == 0)
137 |       {
138 | 	node tem = head;
139 | 	head = t;
140 | 	t.next = tem;
141 |       }
142 |     else
143 |       {
144 | 	int a = 1;
145 | 	node temp = head;
146 | 	while (a != pos)
147 | 	  {
148 | 	    temp = temp.next;
149 | 	    a++;
150 | 	  }
151 | 	node te = temp.next;
152 | 	temp.next = t;
153 | 	t.next = te;
154 |       }
155 |   }
156 |   void InsertAtBegin (int insertValue)
157 |   {
158 |     node t = new node (insertValue);
159 |     if (head == null)
160 |       {
161 | 	head = t;
162 |       }
163 |     else
164 |       {
165 | 	node temp = head;
166 | 	head = t;
167 | 	head.next = temp;
168 |       }
169 |   }
170 |   void DeleteAtEnd ()
171 |   {
172 |     if (head == null)
173 |       {
174 | 	System.out.println ("no element to delete");
175 |       }
176 |     node temp = head;
177 |     while (temp.next.next != null)
178 |       {
179 | 	temp = temp.next;
180 |       }
181 |     temp.next = null;
182 |   }
183 |   void DeleteBegin ()
184 |   {
185 |     if (head == null)
186 |       {
187 | 	System.out.println ("no element to delete");
188 |       }
189 |     node temp = head.next;
190 |     head = temp;
191 | 
192 |   }
193 |   void DeleteAtMid (int pos)
194 |   {
195 |       if (pos >= len)
196 |       {
197 | 	System.out.println ("enter valid position");
198 |       }
199 |       else{
200 |     if (head == null)
201 |       {
202 | 	System.out.println ("no element to delete");
203 |       }
204 |     node temp = head;
205 |     
206 |     if (pos == 0)
207 |       {
208 | 	head = head.next;
209 | 
210 |       }
211 |     else
212 |       {
213 | 	int a = 1;
214 | 	while (a != pos)
215 | 	  {
216 | 	    temp = temp.next;
217 | 	    a++;
218 | 	  }
219 | 	node te = temp.next;
220 | 	temp.next = te.next;
221 | 	//te=null;
222 | 
223 |       }
224 |       }
225 |   }
226 |   void length ()
227 |   {
228 |     node temp = head;
229 |     while (temp != null)
230 |       {
231 | 	len++;
232 | 	temp = temp.next;
233 |       }
234 | 
235 |   }
236 | }
237 | 


--------------------------------------------------------------------------------
/singly linked list in java/Main.java:
--------------------------------------------------------------------------------
  1 | public class Main
  2 | {
  3 | 	public static void main(String[] args) {
  4 | 	System.out.println("Hello World");
  5 | 	
  6 | 	Singly a=new Singly();
  7 | 	a.InsertAtEnd(2);
  8 | 	a.InsertAtEnd(3);
  9 | 	a.InsertAtEnd(4);
 10 | 	a.InsertAtBegin(9);
 11 | 	a.InsertAtMiddle(8,34);
 12 | 	a.Display();
 13 | 	a.DeleteAtEnd();
 14 | 	a.Display();
 15 | 	a.DeleteBegin();
 16 | 	a.Display();
 17 | 	a.DeleteAtMid(0);
 18 | 	a.Display();
 19 | 	a.length();
 20 | 
 21 | 		}
 22 | }
 23 | class Singly{
 24 |     int len=0;
 25 |     node head;
 26 | class node{
 27 |     int data;
 28 |     node next;
 29 |     node(int value){
 30 |         data=value;
 31 |         
 32 |     }
 33 | }
 34 | void InsertAtEnd(int insertValue){
 35 |     node t=new node(insertValue);
 36 |     if(head==null){
 37 |         head=t;
 38 |     }
 39 |     else{
 40 |         node temp=head;
 41 |         while(temp.next!=null)
 42 |         {
 43 |             temp=temp.next;
 44 |         }
 45 |         temp.next=t;
 46 |         
 47 |     }
 48 |     
 49 |     
 50 | }
 51 | void Display()
 52 | {
 53 |     if(head==null)
 54 |     {
 55 |         System.out.println("list is empty");
 56 |     }
 57 |     else{
 58 |         node temp=head;
 59 |       while(temp!=null)
 60 |         {
 61 |             System.out.print(temp.data);
 62 |             temp=temp.next;
 63 |         }
 64 |         System.out.println();
 65 |        
 66 |     }
 67 | }
 68 | void InsertAtMiddle(int insertValue,int pos){
 69 |     node t=new node(insertValue);
 70 |     if(pos>len)
 71 |     {
 72 |         System.out.println("enter valid position");
 73 |     }
 74 |     else if(pos==0)
 75 |     {
 76 |         node tem=head;
 77 |         head=t;
 78 |         t.next=tem;
 79 |     }else{
 80 |     int a=1;
 81 |     node temp=head;
 82 |     while(a!=pos)
 83 |     {
 84 |         temp=temp.next;
 85 |         a++;
 86 |     }
 87 |     node te=temp.next;
 88 |     temp.next=t;
 89 |     t.next=te;
 90 | }
 91 | }
 92 | void InsertAtBegin(int insertValue){
 93 |     node t=new node(insertValue);
 94 |     if(head==null){
 95 |         head=t;
 96 |     }
 97 |     else{
 98 |         node temp=head;
 99 |         head=t;
100 |         head.next=temp;
101 |     }
102 | }
103 | void DeleteAtEnd(){
104 |     if(head==null)
105 |     {
106 |         System.out.println("no element to delete");
107 |     }
108 |     node temp=head;
109 |     while(temp.next.next!=null)
110 |     {
111 |         temp=temp.next;
112 |     }
113 |     temp.next=null;
114 | }
115 | void DeleteBegin(){
116 |     node temp=head.next;
117 |     head=temp;
118 |     
119 | }
120 | void DeleteAtMid(int pos){
121 |     node temp=head;
122 |     if(pos>len)
123 |     {
124 |         System.out.println("enter valid position");
125 |     }
126 |     else if(pos==0)
127 |     {
128 |         head=head.next;
129 |     
130 |     }
131 |     else{
132 |     int a=1;
133 |     while(a!=pos)
134 |     {
135 |         temp=temp.next;
136 |         a++;
137 |     }
138 |     node te=temp.next;
139 |     temp.next=te.next;
140 |    // te=null;
141 |     
142 | }
143 | }
144 | void length()
145 | {
146 |     node temp=head;
147 |     while(temp!=null)
148 |     {
149 |         len++;
150 |         temp=temp.next;
151 |     }
152 |     	System.out.println(len);
153 | }
154 | }


--------------------------------------------------------------------------------
/stack/Main.java:
--------------------------------------------------------------------------------
  1 | import java.util.*;
  2 | public class Main
  3 | {
  4 | 	public static void main(String[] args) {
  5 | 		
  6 | 		Scanner scanner=new Scanner(System.in);
  7 | 		int capacity=scanner.nextInt();
  8 | 		int choice,value;
  9 | 		Stack a=new Stack(capacity);
 10 | 	 do
 11 |       {
 12 | 	System.out.println ("1. push operation");
 13 | 	System.out.println ("2. pop operation");
 14 | 	System.out.println ("3. peek operation");
 15 | 	System.out.println ("4. isempty operation");
 16 | 	System.out.println ("5. is full operation");
 17 | 	System.out.println ("6. Display");
 18 | 	System.out.println ("0. Exit");
 19 | 	System.out.print ("Enter your choice: ");
 20 | 	choice = scanner.nextInt ();
 21 | 	switch (choice)
 22 | 	  {
 23 | 	  case 1:
 24 | 	    System.out.print ("Enter valueto be push: ");
 25 | 	    value = scanner.nextInt ();
 26 | 	    a.push(value);
 27 | 	    System.out.println ("value is successfully pushed");
 28 | 	    break;
 29 | 	    case 2:
 30 | 	    a.pop();
 31 | 	    System.out.println ("value is successfully poped");
 32 | 	    break;
 33 | 	    case 3:
 34 | 	     a.peek();
 35 | 	     break;
 36 | 	    case 4:
 37 | 	      a.isempty();
 38 | 	    break;
 39 | 	    case 5:
 40 | 	      a.isfull();
 41 | 	    break;
 42 | 	    case 6:
 43 | 	      a.display();
 44 | 	    break;
 45 | 	    case 0:System.out.println ("mudunchu poda");
 46 | 	    break;
 47 | 	    default:System.out.println ("Invalid choice.");
 48 | 	  }
 49 |       }
 50 |     while (choice != 0);
 51 | 		
 52 | 		
 53 | 	}
 54 | }
 55 | class Stack{
 56 |     final int size;
 57 |     int top=-1;
 58 |     int a[];
 59 |     Stack(int cap){
 60 |        size=cap;
 61 |        a=new int[size];
 62 |     }
 63 |     void push(int data)
 64 |     {
 65 |         if(top==size-1)
 66 |         {
 67 |             System.out.println("stack is overflow");
 68 |         }
 69 |         else{
 70 |             
 71 |             a[++top]=data;
 72 |         }
 73 |     }
 74 |     void pop()
 75 |     {
 76 |         if(top==-1)
 77 |         {
 78 |             System.out.println("stack is underflow");
 79 |         }
 80 |         else{
 81 |             top--;
 82 |         }
 83 |     }
 84 |     void display(){
 85 |         if(top==-1){
 86 |             System.out.println("stack is empty");
 87 |         }
 88 |         else{
 89 |             for(int i=0;i<=top;i++)
 90 |             {
 91 |                 System.out.print(a[i]+" ");
 92 |             }
 93 |             System.out.println(" ");
 94 |         }
 95 |         
 96 |     }
 97 |     void peek()
 98 |     {
 99 |          if(top==-1)
100 |         {
101 |             System.out.println("stack is underflow");
102 |         }
103 |         else{
104 |             System.out.println("the peek element is:"+a[top]);
105 |         }
106 |     }
107 |     void isfull()
108 |     {
109 |            if(top==size)
110 |         {
111 |             System.out.println("stack is full");
112 |         }
113 |         else{
114 |             System.out.println("Stack is not full");
115 |         }
116 |     }
117 |     void isempty()
118 |     {
119 |         if(top==-1)
120 |         {
121 |             System.out.println("Stack is empty");
122 |         }
123 |         else{
124 |             System.out.println("Stack is not empty");
125 |         }
126 |     }
127 | }


--------------------------------------------------------------------------------
/tree/Main.java:
--------------------------------------------------------------------------------
  1 | import java.util.*;
  2 | 
  3 | public class Main {
  4 |     public static void main(String[] args) {
  5 |         Scanner sc=new Scanner(System.in);
  6 |       BST o=new BST();
  7 |       for(int i=0;i<5;i++)
  8 |       o.insert(sc.nextInt());
  9 |     System.out.print("Inorder :");
 10 |      o.inorder(o.Realroot);
 11 |       System.out.println();
 12 |      System.out.print("preorder :");
 13 |       o.preorder(o.Realroot);
 14 |        System.out.println();
 15 |      System.out.print("postorder :");
 16 |       o.postorder(o.Realroot);
 17 |        System.out.println();
 18 |              System.out.println(o.Search(o.Realroot,4));
 19 |              o.count(o.Realroot);
 20 |              System.out.println(o.cout);
 21 |              o.minimum(o.Realroot);
 22 |              o.maximum(o.Realroot);
 23 |              o.secondmaximum(o.Realroot);
 24 |              o.secondminimum(o.Realroot);
 25 |   }
 26 | }
 27 | class node{
 28 |   int data;
 29 |   node left,right;
 30 |   node(int key){
 31 |     data=key;
 32 |     left=right=null;
 33 |   }
 34 | }
 35 | 
 36 | class BST{
 37 |       node Realroot;
 38 |     void insert(int key){
 39 |         Realroot=insertRecursively(Realroot,key);
 40 |     }
 41 |     node insertRecursively(node dupRoot,int key){
 42 |  
 43 |         if(dupRoot==null){
 44 |           dupRoot=new node(key);
 45 |             return dupRoot;
 46 |         }
 47 |         if(key>dupRoot.data){
 48 |             dupRoot.right=insertRecursively(dupRoot.right,key);
 49 |         }  
 50 |        else if(key<dupRoot.data){
 51 |               dupRoot.left=insertRecursively(dupRoot.left,key);
 52 |         }
 53 |         return dupRoot;
 54 |     }
 55 |     void inorder(node root)
 56 |     {
 57 |         if(root!=null)
 58 |         {
 59 |              inorder(root.left);
 60 |              System.out.print(root.data+" ");
 61 |              inorder(root.right);
 62 |         }
 63 |     }
 64 |         void preorder(node root)
 65 |     {
 66 |         if(root!=null)
 67 |         {
 68 |              System.out.print(root.data+" ");
 69 |              preorder(root.left);
 70 |              preorder(root.right);
 71 |         }
 72 |     }
 73 |         void postorder(node root)
 74 |     {
 75 |         if(root!=null)
 76 |         {
 77 |              postorder(root.left);
 78 |              postorder(root.right);
 79 |              System.out.print(root.data+" ");
 80 |         }
 81 |     }
 82 |     boolean Search(node temp,int key){
 83 |        // node temp=Realroot;
 84 |            if(temp==null){
 85 |             return false;}
 86 |         else if(key<temp.data){
 87 |             return Search(temp.left,key);
 88 |         }
 89 |         else if(key>temp.data){
 90 |             return Search(temp.right,key);
 91 |         }
 92 |         else{
 93 |             return true;
 94 |         }
 95 |     }
 96 |     int cout=1;
 97 |       void count(node root)
 98 |     {
 99 |         if(root!=null)
100 |         {
101 |              count(root.left);
102 |           //   System.out.print(root.data+" ");
103 |              cout=cout+1;
104 |              count(root.right);
105 |         }
106 |     }
107 |     int minva=0;
108 |     int maxva=0;
109 |     void minimum(node temp)
110 |     {
111 |         if(temp==null)
112 |         {
113 |             System.out.println("tree is empty");
114 |         }
115 |         else{
116 |             while(temp!=null)
117 |             {
118 |                 minva=temp.data;
119 |                 temp=temp.left;
120 |             }
121 |             System.out.println("minimum value is :"+ minva);
122 |         }
123 |         
124 |     }
125 |         void maximum(node temp)
126 |     {
127 |         if(temp==null)
128 |         {
129 |             System.out.println("tree is empty");
130 |         }
131 |         else{
132 |             while(temp!=null)
133 |             {
134 |                 maxva=temp.data;
135 |                 temp=temp.right;
136 |             }
137 |             System.out.println("maximum  value is :"+ maxva);
138 |         }
139 |         
140 |     }
141 |     int secmax=0;
142 |     void secondmaximum(node temp)
143 |     {
144 |         if(temp==null)
145 |         {
146 |             System.out.println("tree is empty");
147 |         }
148 |         else{
149 |           int m=temp.data;
150 |             while(temp!=null)
151 |             {
152 |                 m=temp.data;
153 |                 secmax=m;
154 |                 temp=temp.right;
155 |             }
156 |             System.out.println("second maximum  value is :"+ secmax);
157 |         }
158 |         
159 |     }
160 |         int secmin=0;
161 |     void secondminimum(node temp)
162 |     {
163 |         if(temp==null)
164 |         {
165 |             System.out.println("tree is empty");
166 |         }
167 |         else{
168 |             while(temp.left!=null)
169 |             {
170 |                 secmin=temp.data;
171 |                 temp=temp.left;
172 |             }
173 |             System.out.println("second minimum  value is :"+ secmin);
174 |         }
175 |         
176 |     }
177 |   }
178 | 


--------------------------------------------------------------------------------
/valid paranthesis/Main.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | public class Main
 3 | {
 4 | 	public static void main(String[] args) {
 5 | 		
 6 | 		Scanner scanner=new Scanner(System.in);
 7 | 		int capacity=scanner.nextInt();
 8 | 		int choice,value;
 9 | 		Stack stack=new Stack(capacity);
10 | 		String s=scanner.next();
11 | 		for(char c : s.toCharArray())
12 |         {
13 |             if(c=='{')
14 |             {
15 |                 stack.push('}');
16 |             }
17 |             else if(c=='(')
18 |             {
19 |                 stack.push(')');
20 |             }
21 |             else if(c=='[')
22 |             {
23 |                 stack.push(']');
24 |             }
25 |             else if(stack.isempty() || stack.pop() != c)
26 |             {
27 |              System.out.println("false");
28 |              return;
29 |             }
30 |         }
31 |         System.out.println("true");
32 |         return;
33 |     }
34 | 	}
35 | 
36 | class Stack{
37 |     final int size;
38 |     int top=-1;
39 |     int a[];
40 |     Stack(int cap){
41 |        size=cap;
42 |        a=new int[size];
43 |     }
44 |     void push(char data)
45 |     {
46 |         if(top==size-1)
47 |         {
48 |             System.out.println("stack is overflow");
49 |         }
50 |         else{
51 |             
52 |             a[++top]=data;
53 |         }
54 |     }
55 |     char pop()
56 |     {
57 |         if(top==-1)
58 |         {
59 |             System.out.println("stack is underflow");
60 |         }
61 |         else{
62 |             top--;
63 |         }
64 |         //return true;
65 |     }
66 |     boolean isempty()
67 |     {
68 |         if(top==-1)
69 |         {
70 |           return false;
71 |         }
72 |         return true;
73 |         
74 |     }
75 |     
76 | }


--------------------------------------------------------------------------------