m.e data structures lab

Ex no: 1

MIN HEAP

To implement the min heap structure with insert and delete minimum operation using Java program

ALGORITHM

Step 4:

Step 5:

Step 6:

Step 1: Step 2: Step 3:

Start the program by creating function with min heap property Two functions namely insert () and deletemin() are created The insert () is used to insert new element in the tree structure with heap property. The deletemin() is used to delete the minimum element which is usually a root node. The two operations are performed satisfying heapness and completeness property. End of the program.

CS9215 - DATASTRUCTURES LAB

PROGRAM :

import java.io.*;

class heapalg

int maxsize=100,size;

int[] h=new int[maxsize];

public int leftchild(int i)

return 2*i;

public int rightchild(int i)

return 2*i + 1;

public int parent(int i)

return i/2;

public boolean isleaf(int i)

return ((i<=size) && (i>size/2));

public void swap(int i,int j)

int t;

t=h[i];h[i]=h[j];h[j]=t;

public void display()

System.out.println("The heap elements are:"+"\n");

for(int i=1;i<=size;i++)

System.out.println("\n"+h[i]);

public void insert()

size++;

if(size>maxsize)

System.out.println("Heapfull");

System.out.println("Enter the element:");

DataInputStream din=new DataInputStream(System.in);

h[size]=Integer.parseInt(din.readLine());

catch(Exception e) { }

insertelt(size);

public void insertelt(int i)

while ((h[parent(i)]>h[i]))

int par=parent(i);

swap(par,i);

i=par;

public void delet()

if(size==0)

System.out.println("Heapempty");

System.out.println("The deleted min elt:"+h[1]);

h[1]=h[size--];

if(size!=0)

percolate(1);

public void percolate(int i)

while(!isleaf(i))

int small=leftchild(i);

if( (small<size)&& h[small] > h[small+1])

small+=1;

if(h[small] < h[i])

swap(small,i);

i=small;

class minheap

public static void main(String args[]) throws IOException

int ch=0,cont=0;

heapalg h1=new heapalg();

System.out.println("\tMIN HEAP \n 1.Insert \n 2.Delete Min");

ch=Integer.parseInt(din.readLine());

if(ch==1)

h1.insert();

h1.display();

else if(ch==2)

h1.delet();

h1.display();

System.out.println("Enter the correct choice");

System.out.println("press 1 to continue:");

cont=Integer.parseInt(din.readLine());

}while(cont==1);

OUTPUT:

I:\M.E\Sem - I\DS Lab\01>javac minheap.java

Note: minheap.java uses or overrides a deprecated API.

Note: Recompile with -Xlint:deprecation for details.

I:\M.E\Sem - I\DS Lab\01>java minheap

MIN HEAP

1. Insert

2. Delete

Enter the element :

The heap elements are :

Press 1 to continue...

MIN HEAP

1. Insert

2. Delete

Enter the element :

MIN HEAP

1. Insert

2. Delete

Enter the element :

MIN HEAP

1. Insert

2. Delete

Enter the element :

MIN HEAP

1. Insert

2. Delete

Enter the element :

MIN HEAP

1. Insert

2. Delete

Enter the element :

MIN HEAP

1. Insert

2. Delete

Enter the element :

MIN HEAP

1. Insert

2. Delete

The deleted min elt :5

MIN HEAP

1. Insert

2. Delete

MIN HEAP

1. Insert

2. Delete

MIN HEAP

1. Insert

2. Delete

I:\M.E\Sem - I\DS Lab\01>

RESULT :

Thus the program f or Minheap using Java has been implemented and executed

Successfully.

Ex no: 2

To implement program for doubly ended heaps (deaps) structure with insert and

delete operations using java.

ALGORITHM

Step 6: Step 7:

Step 1: Step 2: Step 3: Step 4: Step 5:

Start the program by creating Deap Structure. Perform insert and delete functions. The insert() is done with 2 methods namely maxinsert() and mininsert(). The delete() is done with 2 methods namely deletemax() and deletemin() The leftChild and rightChild are compared and the appropriate element is placed in the root node. After the insert and delete operation Deap elements are displayed. Stop of the program.

PROGRAM :

import java.io.*;

class deapsalg

int maxsize=100,size;

int[] h=new int[maxsize+1];

public int leftchild(int i)

return 2*i;

public int rightchild(int i)

return 2*i + 1;

public int parent(int i)

return i/2;

public boolean isleaf(int i)

return ((i<=size) && (i>size/2));

int t;

t=h[i];h[i]=h[j];h[j]=t;

System.out.println("The deaps elements are:");

for(int i=1;i<=size+1;i++)

System.out.println("\n"+h[i]);

public int MaxHeap(int i)

int t=i;

while(t!=2 && t!=3)

t=t/2;

if(t==2)

return 0;

return 1;

public int MinPartner(int p)

int powvalue=(int) ((Math.floor(Math.log(p)/Math.log(2)))-1);

int partner=p-(int)(Math.pow(2,powvalue));

return partner;

public int MaxPartner(int p)

int powvalue=(int) ((Math.floor(Math.log(p)/Math.log(2)))-1);

int partner=p+(int)(Math.pow(2,powvalue));

if(partner>size+1)

partner/=2;

return partner;

public void MinInsert(int i)

while (parent(i)!=1 && (h[parent(i)]>h[i]))

int par=parent(i);

swap(par,i);

i=par;

public void MaxInsert(int i)

while (parent(i) !=1 && (h[parent(i)]<h[i]))

int par=parent(i);

swap(par,i);

i=par;

int newelt=0;

size++;

if(size>maxsize)

System.out.println("Deap full");

newelt=Integer.parseInt(din.readLine());

catch(Exception e){ }

if(size==1)

h[2]=newelt;

return;

int p=size+1;

h[p]=newelt;

switch(MaxHeap(p))

case 1:

int partner=MinPartner(p);

if(h[partner]>h[p])

swap(p,partner);

MinInsert(partner);

MaxInsert(p);

break;

case 0:

partner=MaxPartner(p);

if(h[partner]<h[p])

swap(p,partner);

MaxInsert(partner);

MinInsert(p);

break;

default:

System.out.println("ERROR");

public void deletemin()

if(size==0)

System.out.println("Deap empty");

System.out.println("The deleted min elt:"+ h[2]);

int i;

int p=size+1;

int t=h[p];

size--;

int small;

for( i=2;2*i<=size+1;i=small)

if(h[rightchild(i)]<h[leftchild(i)])

small=rightchild(i);

small=leftchild(i);

h[i]=h[small];

h[p]=t;

for(i=2;i<=size+1;i++)

switch(MaxHeap(i))

case 1:

int partner=MinPartner(i);

if(h[partner]>h[i])

swap(i,partner);

MinInsert(partner);

MaxInsert(i);

break;

case 0:

partner=MaxPartner(i);

if(h[partner]<h[i])

swap(i,partner);

MaxInsert(partner);

MinInsert(i);

break;

default:

public void deletemax()

if(size==0)

System.out.println("Deap empty");

System.out.println("The deleted max elt:"+ h[3]);

int i;

int p=size+1;

int t=h[p];

size--;

int big;

for( i=3;2*i<=size+1;i=big)

if(h[rightchild(i)]>h[leftchild(i)])

big=rightchild(i);

big=leftchild(i);

h[i]=h[big];

h[p]=t;

for(i=2;i<=size+1;i++)

switch(MaxHeap(i))

case 1:

int partner=MinPartner(i);

if(h[partner]>h[i])

swap(i,partner);

MinInsert(partner);

MaxInsert(i);

break;

case 0:

partner=MaxPartner(i);

if(h[partner]<h[i])

swap(i,partner);

MaxInsert(partner);

MinInsert(i);

break;

default:

public class deaps

public static void main(String args[]) throws IOException

int ch=0,cont=0;

deapsalg h1=new deapsalg();

System.out.println(" DEAPs \n1.Insert \n2.Delete Min \n3.Delete Max");

if(ch==1)

h1.insert();

h1.display();

else if(ch==2)

h1.deletemin();

h1.display();

else if(ch==3)

h1.deletemax();

h1.display();

}while(cont==1);

OUTPUT :

I:\M.E\Sem - I\DS Lab\02>javac deaps.java

Note: deaps.java uses or overrides a deprecated API.

I:\M.E\Sem - I\DS Lab\02>java deaps

1.Insert

2.Delete Min

3.Delete Max

Enter the element:

The deaps elements are:

press 1 to continue:

1.Insert

2.Delete Min

3.Delete Max

Enter the element:

1.Insert

2.Delete Min

3.Delete Max

Enter the element:

1.Insert

2.Delete Min

3.Delete Max

Enter the element:

1.Insert

2.Delete Min

3.Delete Max

Enter the element:

1.Insert

2.Delete Min

3.Delete Max

Enter the element:

1.Insert

2.Delete Min

3.Delete Max

Enter the element:

1.Insert

2.Delete Min

3.Delete Max

Enter the element:

1.Insert

2.Delete Min

3.Delete Max

Enter the element:

1.Insert

2.Delete Min

3.Delete Max

The deleted min elt:8

1.Insert

2.Delete Min

3.Delete Max

The deleted min elt:19

1.Insert

2.Delete Min

3.Delete Max

The deleted max elt:90

1.Insert

2.Delete Min

3.Delete Max

The deleted max elt:70

I:\M.E\Sem - I\DS Lab\02>

RESULT :

Thus the program for Doubly ended heaps (Deaps) using Java has been implemented

and executed successfully.

Ex no: 3

LEFTIST HEAP

To implement the leftist heap with insert and deletemin operation using Java.

ALGORITHM

Step 4: Step 5: Step 6: Step 7:

Start the program by defining function. We know heap as the root node with minimum element. The insert and delete operations are performed with the help of combining 2 trees. The insert operation is performed by combining the two leftist trees. The deletemin() is used to delete the minimum element in the heap. After the insert and delete operations leftist heap elements are displayed. Stop the program.

PROGRAM :

import java.io.*;

class node

public int data;

public node LC,RC;

public int shortest;

class minleftist

node root = null;

int newelt=0;

catch(Exception e){}

node temp = new node();

temp.data=newelt;

temp.LC=temp.RC=null;

temp.shortest=1;

if(root==null)

root=temp;

root=meld(root,temp);

public node meld(node a, node b)

if(a.data > b.data)

node t;

if(a.RC==null)

a.RC=b;

a.RC=meld(a.RC,b);

if((a.LC==null) || (a.LC.shortest < a.RC.shortest))

node t=new node();

t=a.LC;

a.LC=a.RC;

a.RC=t;

if(a.RC==null)

a.shortest=1;

a.shortest=a.RC.shortest+1;

return a;

public void remove()

System.out.println("Deleted element is "+root.data+"\n");

root=meld(root.LC,root.RC);

if(root==null)

System.out.println("EMPTY");

System.out.println("\nIn Order");

dispin(root);

public void dispin(node currentnode)

if(currentnode!=null)

dispin(currentnode.LC);

System.out.println(currentnode.data+" "+"SHORTEST "+currentnode.shortest);

dispin(currentnode.RC);

class LeftistTree

public static void main(String args[ ])throws IOException

int ch=0,cont=0;

minleftist m = new minleftist();

System.out.println(" LEFTIST TREE \n1. Insert \n2. Delete");

DataInputStream din = new DataInputStream(System.in);

if(ch==1)

m.insert();

m.display();

else if(ch==2)

m.remove();

m.display();

}while(cont==1);

OUTPUT :

H:\M.E\Sem - I\DS Lab\03>javac LeftistTree.java

Note: LeftistTree.java uses or overrides a deprecated API.

H:\M.E\Sem - I\DS Lab\03>java LeftistTree

LEFTIST TREE

1. Insert

2. Delete

Enter the element:

In Order

8 SHORTEST 1

LEFTIST TREE

1. Insert

2. Delete

Enter the element:

In Order

23 SHORTEST 1

8 SHORTEST 1

LEFTIST TREE

1. Insert

2. Delete

Enter the element:

In Order

23 SHORTEST 1

8 SHORTEST 2

13 SHORTEST 1

LEFTIST TREE

1. Insert

2. Delete

Enter the element:

In Order

23 SHORTEST 1

8 SHORTEST 2

52 SHORTEST 1

13 SHORTEST 1

LEFTIST TREE

1. Insert

2. Delete

Enter the element:

In Order

23 SHORTEST 1

8 SHORTEST 2

52 SHORTEST 1

13 SHORTEST 1

10 SHORTEST 1

LEFTIST TREE

1. Insert

2. Delete

Enter the element:

In Order

23 SHORTEST 1

8 SHORTEST 2

52 SHORTEST 1

13 SHORTEST 1

10 SHORTEST 1

6 SHORTEST 1

LEFTIST TREE

1. Insert

2. Delete

Enter the element:

In Order

23 SHORTEST 1

8 SHORTEST 2

52 SHORTEST 1

13 SHORTEST 1

10 SHORTEST 1

6 SHORTEST 2

45 SHORTEST 1

LEFTIST TREE

1. Insert

2. Delete

Deleted element is 6

In Order

52 SHORTEST 1

13 SHORTEST 1

10 SHORTEST 2

45 SHORTEST 1

8 SHORTEST 2

23 SHORTEST 1

LEFTIST TREE

1. Insert

2. Delete

In Order

52 SHORTEST 1

13 SHORTEST 1

10 SHORTEST 2

45 SHORTEST 1

23 SHORTEST 1

LEFTIST TREE

1. Insert

2. Delete

In Order

52 SHORTEST 1

13 SHORTEST 2

45 SHORTEST 1

23 SHORTEST 1

LEFTIST TREE

1. Insert

2. Delete

In Order

45 SHORTEST 1

23 SHORTEST 2

52 SHORTEST 1

LEFTIST TREE

1. Insert

2. Delete

In Order

52 SHORTEST 1

45 SHORTEST 1

RESULT :

Thus the program for leftist heap using Java has been implemented and

executed successfully.

Ex no: 4

AVL TREE

AIM To implement the AVL tree with insert & delete operations using Java.

ALGORITHM

Start the program by defining the functions. Insert the elements to the AVL tree. Check the tree if it is balanced or not. The balance factor is one of 0, 1 and -1. If it is not balanced, balance the tree using (i) Left-left

(ii) Left-right

(iii) Right-left (iv) Right-right Balancing

And if the tree is balanced and then the insert() and the delete() operations are performed. Stop the program.

Step 6:

Step 7:

PROGRAM :

import java.io.*;

class node

public int data;

public node LC,RC;

public int bf;

class avltree

node root = null;

public boolean insert()

int newelt=0;

if(root==null)

node y=new node();

y.data=newelt;

y.bf=0;

y.LC=null;

y.RC=null;

root=y;

return true;

node f,a,q,p;

node b,c;

int d;

node y=new node();

boolean found, unbalanced;

f=null;

a=root;

p=root;

q=null;

found=false;

while (p!=null && found!=true)

if(p.bf!=0)

if(newelt<p.data)

p=p.LC;

else if(newelt>p.data)

p=p.RC;

found=true;

if(found==false)

y.data=newelt;

y.bf=0;

y.LC=null;

y.RC=null;

if(newelt<q.data)

q.LC=y;

q.RC=y;

if(newelt >a.data)

p=a.RC;

p=a.LC;

while(p!=y)

if(newelt > p.data)

p.bf=-1;

p=p.RC;

p.bf=1;

p=p.LC;

unbalanced=true;

if((a.bf==0)||((a.bf+d)==0))

a.bf+=d;

unbalanced=false;

if(unbalanced==true)

if(d==1)

if(b.bf==1)

System.out.println("LL imbalance");

a.LC=b.RC;

b.RC=a;

a.bf=0;

b.bf=0;

System.out.println("LR imbalance");

c=b.RC;

b.RC=c.LC;

a.LC=c.RC;

c.LC=b;

c.RC=a;

switch(c.bf)

case 1:

a.bf=-1;

b.bf=0;

break;

case -1:

a.bf=0;

b.bf=1;

break;

case 0:

a.bf=0;

b.bf=0;

break;

c.bf=0;

if(b.bf==-1)

System.out.println("RR imbalance");

a.RC=b.LC;

b.LC=a;

a.bf=0;

b.bf=0;

System.out.println("RL imbalance");

c=b.LC;

b.LC=c.RC;

a.RC=c.LC;

c.RC=b;

c.LC=a;

switch(c.bf)

case 1:

a.bf=0;

b.bf=-1;

break;

case -1:

a.bf=1;

b.bf=0;

break;

case 0:

a.bf=0;

b.bf=0;

break;

c.bf=0;

if(f==null)

root=b;

else if(a==f.LC)

f.LC=b;

else if(a==f.RC)

f.RC=b;

return true;

return false;

if(root==null)

dispin(root);

System.out.println(currentnode.data+" "+"BF "+currentnode.bf);

class AVLTreeImp

int ch=0,cont=0;

avltree a = new avltree();

System.out.println(" AVLTREES \n 1. Insert ");

if(ch==1)

boolean y=true;

y=a.insert();

a.display();

if(y==false)

System.out.println("Data already exists");

}while(cont==1);

OUTPUT :

AVLTREES

1. Insert

Enter the element:

In Order

25 BF 0

AVLTREES

1. Insert

Enter the element:

In Order

25 BF -1

36 BF 0

AVLTREES

1. Insert

Enter the element:

RR imbalance

In Order

25 BF 0

36 BF 0

50 BF 0

AVLTREES

1. Insert

Enter the element:

In Order

10 BF 0

25 BF 1

36 BF 1

50 BF 0

AVLTREES

1. Insert

Enter the element:

LL imbalance

In Order

5 BF 0

10 BF 0

25 BF 0

36 BF 1

50 BF 0

AVLTREES

1. Insert

Enter the element:

LR imbalance

In Order

5 BF 0

10 BF 0

20 BF 0

25 BF 0

36 BF -1

50 BF 0

AVLTREES

1. Insert

Enter the element:

RR imbalance

In Order

5 BF 0

10 BF 0

20 BF 0

25 BF 0

36 BF 0

50 BF 0

90 BF 0

AVLTREES

1. Insert

Enter the element:

In Order

2 BF 0

5 BF 1

10 BF 1

20 BF 0

25 BF 1

36 BF 0

50 BF 0

90 BF 0

RESULT :

Thus the program for AVL Tree using Java has been implemented and

executed successfully.

Ex no: 5

B-TREE

To implement the b-tree with insert and delete operations using Java.

ALGORITHM

Step 1: Step 2: Step 3: Step 4:

Start the program by defining function. Declare the class btree The insert and delete operations are performed To insert, check if root is empty, if it is empty Insert the element as root. If it is greater insert it into right sub tree. Otherwise, insert it into left sub tree Use the function split, to split the nodes Call the function display to display data1, data2, address and parent End of the program

PROGRAM :

import java.io.*;

class bnode

int data1,data2;

bnode lptr,mptr,rptr,parent;

public void bnode()

this.data1=this.data2=0;

this.lptr=this.mptr=this.rptr=this.parent=null;

class btree

bnode root=null;

bnode p,p1;

bnode prev;

void insert(int ele)

bnode temp=new bnode();

temp.data1=ele;

if(root==null)

root=temp;

p1=root;

while(p1!=null)

prev=p1;

if(temp.data1<p1.data1)

p1=p1.lptr;

else if((temp.data1>p1.data1) &&(temp.data1<p1.data2))

p1=p1.mptr;

p1=p1.rptr;

p1=prev;

while(p1!=null)

if(p1.data2==0)

if(temp.data1<p1.data1)

int t=p1.data1;

p1.data1=temp.data1;

p1.data2=t;

p1.lptr=temp.lptr;

if(temp.lptr!=null)

temp.lptr.parent=p1;

p1.mptr=temp.rptr;

if(temp.rptr!=null)

temp.rptr.parent=p1;

p1.data2=temp.data1;

p1.mptr=temp.lptr;

if(temp.lptr!=null)

temp.lptr.parent=p1;

p1.rptr=temp.rptr;

if(temp.rptr!=null)

temp.rptr.parent=p1;

temp.parent=p1.parent;

break;

else if((p1.data1!=0) && (p1.data2!=0))

p1=split(temp,p1);

temp=p1;

p1=p1.parent;

display(root);

bnode split(bnode t,bnode p)

bnode n1=null;

bnode n2=null;

if(t.data1<p.data1)

if(p.mptr!=null)

n1=p.mptr;

if(p.rptr!=null)

n2=p.rptr;

p.lptr=new bnode();

p.lptr=t;

t.parent=p;

p.mptr=null;

p.rptr=new bnode();

p.rptr.data1=p.data2;

p.rptr.lptr=n1;

if(n1!=null)

p.rptr.lptr.parent=p.rptr;

p.rptr.rptr=n2;

if(n2!=null)

p.rptr.rptr.parent=p.rptr;

p.rptr.parent=p;

p.data2=0;

else if((t.data1>p.data1) && (t.data1<p.data2))

if(p.lptr!=null)

n1=p.lptr;

if(p.rptr!=null)

n2=p.rptr;

p.lptr=new bnode();

p.lptr.data1=p.data1;

p.lptr.parent=p;

p.data1=t.data1;

p.lptr.lptr=n1;

if(n1!=null)

p.lptr.lptr.parent=p.lptr;

p.lptr.rptr=t.lptr;

if(t.lptr!=null)

p.lptr.rptr.parent=p.lptr;

p.rptr=new bnode();

p.rptr.data1=p.data2;

p.rptr.rptr=n2;

if(n2!=null)

p.rptr.rptr.parent=p.rptr;

p.rptr.lptr=t.rptr;

if(t.rptr!=null)

p.rptr.lptr.parent=p.rptr;

p.rptr.parent=p;

p.data2=0;

p.mptr=null;

if(p.lptr!=null)

n1=p.lptr;

if(p.mptr!=null)

n2=p.mptr;

p.lptr=new bnode();

p.lptr.data1=p.data1;

p.lptr.parent=p;

p.mptr=null;

p.lptr.lptr=n1;

if(n1!=null)

p.lptr.lptr.parent=p.lptr;

p.lptr.rptr=n2;

if(n2!=null)

p.lptr.rptr.parent=p.lptr;

p.data1=p.data2;

p.data2=0;

p.rptr=new bnode();

p.rptr=t;

p.rptr.parent=p;

return p;

void display(bnode temp)

if(temp!=null)

display(temp.lptr);

display(temp.mptr);

display(temp.rptr);

System.out.println("data1::"+temp.data1+" data2::"+temp.

data2+" Address::"+temp+" parent::"+temp.parent);

class BTrees

public static void main(String[] args)throws IOException

System.out.println("B-Trees");

DataInputStream in=new DataInputStream(System.in);

btree bt=new btree();

int x,ch;

System.out.println("Enter the element");

x=Integer.parseInt(in.readLine());

bt.insert(x);

System.out.println("To continue...press 1");

ch=Integer.parseInt(in.readLine());

}while(ch==1);

OUTPUT :

B-Trees

Enter the element

data1::20 data2::0 Address::bnode@addbf1 parent::null

To continue...press 1

Enter the element

data1::10 data2::0 Address::bnode@9304b1 parent::bnode@addbf1

data1::30 data2::0 Address::bnode@190d11 parent::bnode@addbf1

Enter the element

data1::30 data2::45 Address::bnode@190d11 parent::bnode@addbf1

Enter the element

data1::30 data2::0 Address::bnode@a90653 parent::bnode@addbf1

data1::45 data2::0 Address::bnode@de6ced parent::bnode@addbf1

Enter the element

data1::30 data2::0 Address::bnode@a90653 parent::bnode@addbf1

data1::45 data2::0 Address::bnode@de6ced parent::bnode@addbf1

Enter the element

data1::8 data2::0 Address::bnode@c17164 parent::bnode@9304b1

data1::12 data2::0 Address::bnode@1fb8ee3 parent::bnode@9304b1

data1::30 data2::0 Address::bnode@a90653 parent::bnode@61de33

data1::45 data2::0 Address::bnode@de6ced parent::bnode@61de33

data1::35 data2::0 Address::bnode@61de33 parent::bnode@addbf1

Enter the element

RESULT :

Thus the program for b-tree using Java has been implemented and executed

successfully.

Ex no: 6

To implement the tries with insert operation using Java.

ALGORITHM

Step 4:

Step 5:

Step 6:

Step 7: Step 8:

Start the program by defining the functions. First initialize the node to null To find the particular element use function finds Check the element to root node, if it is not found check for left or right side of the root. If it’s found return the element To insert the particular element read that element and Insert the element with tag as 0 and level as 1. To display the elements, display if root as null, print as empty, otherwise call empty Print the current node in left sub tree in the format as currentnode.data + level and tag. Display current node in the right sub tree End of the program

PROGRAM :

import java.io.*;

class node

public int tag,level;

public int data;

public node LC,RC,par;

class trie

public node cptr;

public node root=null;

public node find(int key)

int item=key;

node temp=root;

while(temp!=null)

cptr=temp;

if(temp.tag==1)

if((item & 1)==0)

temp=temp.LC;

item=item >> 1;

temp=temp.RC;

item=item >> 1;

if(key==temp.data)

return temp;

break;

return null;

int key=0;

key=Integer.parseInt(din.readLine());

if(root==null)

root=new node();

root.data=key;

root.tag=0;

root.level=1;

root.par=null;

root.LC=null;

root.RC=null;

node temp=find(key);

if(temp==null)

temp=cptr;

if(temp.tag==0)

node n1=new node();

node n2=new node();

temp.tag=1;

n1.tag=0;n2.tag=0;

int k1=temp.data;

temp.data=0;

int k2=key;

int kk1;

n1.data=k1;

n2.data=k2;

int lv=1;

while ( (k1 & 1 ) ==(k2 & 1 ))

kk1=k1;

k1=k1 >> 1;

k2=k2 >> 1;

if(lv>=temp.level)

node n3=new node();

n3.tag=1;

if((kk1 & 1)==0)

temp.LC=n3;

temp.RC=null;

n3.level=temp.level+1;

temp.RC=n3;

temp.LC=null;

n3.par=temp;

temp=n3;

if((k1 & 1)==0)

temp.LC=n1;

temp.RC=n2;

n1.level=n2.level=temp.level+1;

temp.LC=n2;

temp.RC=n1;

n1.level=n2.level=temp.level+1;

n1.par=temp;

n2.par=temp;

node n1=new node();

n1.tag=0;

n1.data=key;

if(temp.LC==null)

temp.LC=n1;

temp.RC=n1;

n1.par=temp;

System.out.println("Element already exists");

if(root==null)

dispin(root);

System.out.println(currentnode.data+" \t "+"LEVEL- "+currentnode.level+" "+"TAG-

"+currentnode.tag);

class TrieImp

int ch=0,cont=0;

trie t = new trie();

System.out.println("\t TRIES \n 1. Insert ");

if(ch==1)

t.insert();

t.display();

System.out.println("Enter the correct choice :");

}while(cont==1);

OUTPUT :

1. Insert

Enter the element:

In Order

1234 LEVEL- 1 TAG-0

1. Insert

Enter the element:

Element already exists

In Order

1234 LEVEL- 2 TAG-0

0 LEVEL- 1 TAG-1

4321 LEVEL- 2 TAG-0

1. Insert

Enter the element:

In Order

0 LEVEL- 2 TAG-1

5634 LEVEL- 6 TAG-0

0 LEVEL- 5 TAG-1

1234 LEVEL- 6 TAG-0

0 LEVEL- 4 TAG-1

0 LEVEL- 3 TAG-1

0 LEVEL- 1 TAG-1

4321 LEVEL- 2 TAG-0

1. Insert

Enter the element:

In Order

0 LEVEL- 2 TAG-1

5634 LEVEL- 7 TAG-0

0 LEVEL- 6 TAG-1

34 LEVEL- 7 TAG-0

0 LEVEL- 5 TAG-1

1234 LEVEL- 6 TAG-0

0 LEVEL- 4 TAG-1

0 LEVEL- 3 TAG-1

0 LEVEL- 1 TAG-1

4321 LEVEL- 2 TAG-0

1. Insert

Enter the element:

In Order

0 LEVEL- 2 TAG-1

5634 LEVEL- 7 TAG-0

0 LEVEL- 6 TAG-1

34 LEVEL- 7 TAG-0

0 LEVEL- 5 TAG-1

1234 LEVEL- 6 TAG-0

0 LEVEL- 4 TAG-1

0 LEVEL- 3 TAG-1

0 LEVEL- 1 TAG-1

4321 LEVEL- 4 TAG-0

0 LEVEL- 3 TAG-1

9821 LEVEL- 4 TAG-0

0 LEVEL- 2 TAG-1

1. Insert

Enter the element:

In Order

0 LEVEL- 2 TAG-1

5634 LEVEL- 7 TAG-0

0 LEVEL- 6 TAG-1

34 LEVEL- 7 TAG-0

0 LEVEL- 5 TAG-1

1234 LEVEL- 6 TAG-0

0 LEVEL- 4 TAG-1

0 LEVEL- 3 TAG-1

0 LEVEL- 1 TAG-1

4321 LEVEL- 5 TAG-0

0 LEVEL- 4 TAG-1

921 LEVEL- 5 TAG-0

0 LEVEL- 3 TAG-1

9821 LEVEL- 4 TAG-0

0 LEVEL- 2 TAG-1

RESULT :

Thus the program for tries using Java has been implemented and the output was

verified successfully.

Ex no: 7

QUICK SORT

AIM To write a Java program for the implementation the quick sort

ALGORITHM

Step1: start the program

Step2: Declare and initialize the array size

Step3: Enter the number of elements to be quick sorted.

Step4: Enter the elements using for loop

Step5: call the function quick (1, noe) Void quick (int first,int last)

Step6: if the first element is less than the last

(a) then the first element is taken as the pivot &i=first, &j=last (b)The condition is checked for i<j if true

Step7: set a loop to check the elements

(a) while (a[pivot]>=a[i]&&i<last)i++; (b) while (a[pivot]>=a[j]&&j>first)j--;

Step8: if (i>j)

Swap (i,j)

Step9: sort the elements and display the sorted values.

PROGRAM :

import java.io.*;

class quicksortalg

int noe;

int[] a=new int[100];

public void sort()

System.out.println("Enter the number of elements : ");

noe=Integer.parseInt(din.readLine());

System.out.println("Enter the elements : ");

for(int i=1;i<=noe;i++)

a[i]=Integer.parseInt(din.readLine());

System.out.println("The array:");

display();

quick(1,noe);

int t;

t=a[i];

a[i]=a[j];

a[j]=t;

public void quick(int first,int last)

if(first<last)

int pivot=first;

int i=first;

int j=last;

while(i<j)

while(a[pivot]>=a[i] && i<last)

while(a[pivot]<=a[j] && j>first)

if(i<j)

swap(i,j);

swap(pivot,j);

quick(first,j-1);

quick(j+1,last);

for(int i=1;i<=noe;i++)

System.out.println(a[i]+"\n");

class quicksort

public static void main(String args[])throws IOException

quicksortalg q1=new quicksortalg();

q1.sort();

System.out.println("The sorted array is : ");

q1.display();

OUTPUT :

Enter the number of elements :

Enter the elements :

The array:

The sorted array is :

RESULT :

Thus the program for quick sort has been implemented using Java and the

output is verified.

Ex no: 8

CONVEX HULL

To write a Java program for the implementation of convex hull ALGORITHM

Step1: Start the program

Step2: Create a class convexhullalg

Step3: Read the number of points

Step4: Get the x and y co-ordinate values

Step5: Sort the values using sort function

Step6: To sort two values swap the values of i and j

Step7: Call the function display to display the boundary points

Step8: The function check id used to check whether the point is angular or not(180▫)

Step9: End of the program

PROGRAM :

import java.io.*;

class convexhullalg

int x[],y[],n;

boolean status[];

void insert()

System.out.println("Enter number of points:");

n=Integer.parseInt(in.readLine());

x=new int[n];

y=new int[n];

status=new boolean[n];

System.out.println("Enter x and y coordinates for ");

for(int i=0;i<n;i++)

System.out.println("point "+(i+1));

x[i]=Integer.parseInt(in.readLine());

y[i]=Integer.parseInt(in.readLine());

status[i]=false;

sort();

check(0,'L');

check(0,'H');

display();

void sort()

for(int i=0;i<n-1;i++)

for(int j=i+1;j<n;j++)

if((x[i]>x[j]) || ((x[i]==x[j]) && (y[i]>y[j])))

swap(i, j);

void swap(int i,int j)

int temp=x[i];

x[i]=x[j];

x[j]=temp;

temp=y[i];

y[i]=y[j];

y[j]=temp;

void display()

System.out.println("Boundary points are");

if(status[i]==true)

System.out.println("("+x[i]+", "+y[i]+")");

void check(int p,char c)

double slope=0,degree=0,deg=0;

int next=0;

status[p]=true;

for(int i=p+1;i<n;i++)

slope=(double)(x[i]-x[p])/(double)(y[i]-y[p]);

degree=Math.toDegrees(Math.atan(slope));

if(degree < 0)

degree+=180;

catch(Exception e)

degree=90;

if(i==p+1)

deg=degree;

next=i;

if((c=='L' && deg>degree)||(c!='L' && deg<degree) ||(degree==deg && x[i]<x[next]))

deg=degree;

next=i;

if(next!=0)

check(next,c);

class convexhull

convexhullalg c=new convexhullalg();

c.insert();

OUTPUT :

Enter number of points:

Enter x and y coordinates for

point 1

point 2

point 3

point 4

point 5

Boundary points are

(1, 5)

(2, 3)

(5, 8)

(6, 4)

RESULT :

Thus the program for convex hull has been implemented using Java and

Executed successfully.

Ex no: 9

0/1 KNAPSACK USING DYNAMIC

PROGRAMMING

To write a Java program for the implementation of 0/1 knapsack using dynamic programming. ALGORITHM

Step 1: Step 2: Step 3: Step 4: Step 5: Step 6: Step 7: Step 8:

Start the program and define the function. Initialize the weight and profit. Read the number of objects that are given. For each objects, print the profit and weight Initializing is set to false. Display and print the item weight and profit Display the total cost End of the program.

PROGRAM :

import java.io.*;

class objects

int weight;

int profit;

public class knapsack

static int N,W;

static objects st[];

System.out.println("Enter the number of objects:");

N=Integer.parseInt(in.readLine());

System.out.println("Enter the maximum weight sack can take:");

W=Integer.parseInt(in.readLine());

st=new objects[N+1];

st[0]=new objects();st[0].weight=st[0].profit=0;

for(int i=1;i<=N;i++)

st[i]=new objects();

System.out.println("\nFor object "+i);

System.out.print("Enter profit: ");

st[i].profit=Integer.parseInt(in.readLine());

System.out.print("Enter Weight: ");

st[i].weight=Integer.parseInt(in.readLine());

int [][] opt=new int[N+1][W+1];

boolean [][] sol= new boolean[N+1][W+1];

for(int n=1;n<=N;n++)

for(int w=1;w<=W;w++)

int option1=opt[n-1][w];

int option2=-1;

if(st[n].weight<=w)

option2=st[n].profit+opt[n-1][w-st[n].weight];

opt[n][w]=Math.max(option1, option2);

sol[n][w]=(option2 > option1);

boolean take[]=new boolean[N+1];

int prof=0;

for(int n=N,w=W;n>0;n--)

if(sol[n][w])

take[n]=true;

w=w-st[n].weight;

prof+=st[n].profit;

take[n]=false;

System.out.println("\nThe optimal solution is:");

System.out.println("Item \t weight \t profit");

for(int n=1;n<=N;n++)

if(take[n])

System.out.println(n+" \t "+st[n].weight+" \t\t "+st[n].profit);

System.out.println("\n Total profit:"+prof);

OUTPUT :

Enter the number of objects:

Enter the maximum weight sack can take:

For object 1

Enter profit: 10

Enter Weight: 5

For object 2

Enter profit: 20

Enter Weight: 7

For object 3

Enter profit: 15

Enter Weight: 12

For object 4

Enter profit: 17

Enter Weight: 2

The optimal solution is:

Item weight profit

1 5 10

2 7 20

4 2 17

Total profit:47

RESULT :

Thus the program for 0/1 knapsack using dynamic program has been

implemented using Java and Executed successfully.

Ex no: 10

GRAPH COLORING USING

BACKTRACKING

To write the Java program for the implementation of graph Coloring using backtracking.

ALGORITHM

Step 1: Step 2: Step 3: Step 4: Step 5: Step 6: Step 7: Step 8: Step 9:

Start the program and define the function Create a class coloring Get the number of vertices in the graph Enter one if there is an edge in the graph And enter zero if there is no edge in the graph. Get the adjacency matrix of the given values Perform all possible combinations that are given Display all the combination End of the program

PROGRAM :

import java.io.*;

class gcoloring

int a[][]=new int[10][10];

int x[]=new int[10];

int m, n;

void read()

System.out.println("Enter number of vertices in the graph");

n=Integer.parseInt(in.readLine());

System.out.println("Enter 1 if there is an edge Otherwise 0");

for(int i=1;i<=n;i++)

for(int j=1;j<=n;j++)

System.out.println("between "+i+" and "+j);

a[i][j]=Integer.parseInt(in.readLine());

System.out.println("Given adjacency matrix is ");

for(int j=1;j<=n;j++)

System.out.print(a[i][j]+"\t");

System.out.println();

x[i]=0;

System.out.println("All possible combinations for m = "+i+" are ");

mcoloring(1);

void mcoloring(int k)

nextvalue(k);

if(x[k]==0)

break;

if(k==n)

System.out.print(x[i]+"\t");

System.out.println();

mcoloring(k+1);

}while(true);

void nextvalue(int k)

int j;

x[k]=(x[k]+1)%(m+1);

if(x[k]==0) return;

for(j=1;j<=n;j++)

if((a[k][j]==1) && (x[k]==x[j]))

break;

if(j==n+1)

return;

}while(true);

class Graphcoloring

gcoloring g=new gcoloring();

g.read();

OUTPUT :

Enter number of vertices in the graph

Enter 1 if there is an edge Otherwise 0

between 1 and 1

between 1 and 2

between 1 and 3

between 1 and 4

between 2 and 1

between 2 and 2

between 2 and 3

between 2 and 4

between 3 and 1

between 3 and 2

between 3 and 3

between 3 and 4

between 4 and 1

between 4 and 2

between 4 and 3

between 4 and 4

Given adjacency matrix is

0 1 0 1

1 0 1 0

0 1 0 1

1 0 1 0

All possible combinations for m = 2 are

1 2 1 2

2 1 2 1

All possible combinations for m = 3 are

1 2 1 2

1 2 1 3

1 2 3 2

1 3 1 2

1 3 1 3

1 3 2 3

2 1 2 1

2 1 2 3

2 1 3 1

2 3 1 3

2 3 2 1

2 3 2 3

3 1 2 1

3 1 3 1

3 1 3 2

3 2 1 2

3 2 3 1

3 2 3 2

RESULT :

Thus the program for graph coloring using backtracking in Java has been

implemented and executed successfully.

m.e data structures lab

Documents

lab 3: language structures user interface lab: gui lab sep....

m.e lab 3 experiment 4 heat losses from pipes (3)

structures lab report

data structures and algorithms lab mannual

data structures lab manual

university of pune m.e. (civil) (structures) course ... of...

ae2305 - aircraft structures repair lab manual

data structures and algorithms lab[1]

aircraft structures lab- i

data structures lab programs

lab 5: sedimentary structures & palaeocurrent analysis...

scilab manual for lab practices ii (m.e. instrumentation

data structures ( may 2019) - m.e. | b.com

structures lab finl copy

m.e. in civil engineering with specilization...

m.e-communication systems lab-i

8085 microprocessor programs · microprocessor &...

c and data structures lab solutions

advanced data structures lab manual

m.e cs-1 lab manual.doc