JAva program update

Author: amangit1314

dataStructure/MYStackByList.java

@@ -0,0 +1,121 @@
+package dataStructure;
+
+//Java program to Implement a stack 
+//using singly linked list 
+//import package 
+import static java.lang.System.exit; 
+
+//Create Stack Using Linked list 
+class StackUsingLinkedlist { 
+
+ // A linked list node 
+ private class Node { 
+
+     int data; // integer data 
+     Node link; // reference variable Node type 
+ } 
+ // create global top reference variable global 
+ Node top; 
+ // Constructor 
+ StackUsingLinkedlist() 
+ { 
+     this.top = null; 
+ } 
+
+ // Utility function to add an element x in the stack 
+ public void push(int x) // insert at the beginning 
+ { 
+     // create new node temp and allocate memory 
+     Node temp = new Node(); 
+
+     // initialize data into data field 
+     temp.data = x; 
+
+     // put top reference into link 
+     temp.link = top; 
+
+     // update top reference 
+     top = temp; 
+ } 
+
+ // Utility function to check if the stack is empty or not 
+ public boolean isEmpty() 
+ { 
+     return top == null; 
+ } 
+
+ // Utility function to return top element in a stack 
+ public int peek() 
+ { 
+     // check for empty stack 
+     if (!isEmpty()) { 
+         return top.data; 
+     } 
+     else { 
+         System.out.println("Stack is empty"); 
+         return -1; 
+     } 
+ } 
+
+ // Utility function to pop top element from the stack 
+ public void pop() // remove at the beginning 
+ { 
+     // check for stack underflow 
+     if (top == null) { 
+         System.out.print("\nStack Underflow"); 
+         return; 
+     } 
+
+     // update the top pointer to point to the next node 
+     top = (top).link; 
+ } 
+
+ public void display() 
+ { 
+     // check for stack underflow 
+     if (top == null) { 
+         System.out.printf("\nStack Underflow"); 
+         exit(1); 
+     } 
+     else { 
+         Node temp = top; 
+         while (temp != null) { 
+
+             // print node data 
+             System.out.printf("%d->", temp.data); 
+
+             // assign temp link to temp 
+             temp = temp.link; 
+         } 
+     } 
+ } 
+} 
+//main class 
+public class MYStackByList { 
+ public static void main(String[] args) 
+ { 
+     // create Object of Implementing class 
+     StackUsingLinkedlist obj = new StackUsingLinkedlist(); 
+     // insert Stack value 
+     obj.push(11); 
+     obj.push(22); 
+     obj.push(33); 
+     obj.push(44); 
+
+     // print Stack elements 
+     obj.display(); 
+
+     // print Top element of Stack 
+     System.out.printf("\nTop element is %d\n", obj.peek()); 
+
+     // Delete top element of Stack 
+     obj.pop(); 
+     obj.pop(); 
+
+     // print Stack elements 
+     obj.display(); 
+
+     // print Top element of Stack 
+     System.out.printf("\nTop element is %d\n", obj.peek()); 
+ } 
+}

dataStructure/MyQueue.java

@@ -0,0 +1,82 @@
+//Java program for array implementation of queue
+package dataStructure;
+//A class to represent a queue 
+class Queue{
+	int front, rear, size;
+	int capacity;
+	int array[];
+
+	public Queue(int capacity) {
+		this.capacity = capacity;
+		front = this.size = 0;
+		rear = capacity - 1;
+		array = new int[this.capacity];
+	}
+
+	//Queue is full when size becomes equal to capacity
+	boolean isFull(Queue queue) {
+		return(queue.size == queue.capacity);
+	}
+
+	//Queue is Empty when size is 0
+	boolean isEmpty(Queue queue){
+		return(queue.size == 0);
+	}
+
+	//Method to add an item to the queue 
+	//It changes rear and size
+	void enqueue(int item) {
+		if(isFull(this))
+			return;
+		this.rear = (this.rear+1)%this.capacity;
+		this.array[this.rear] = item;
+		this.size = this.size+1;
+		System.out.println(item + " enqueud to queue");
+	} 
+
+	//Method to remove an item from queue
+	//It changes front and size
+	int dequeue() {
+		if(isEmpty(this))
+			return Integer.MIN_VALUE;
+	
+		int item = this.array[this.front];
+		this.front = (this.front + 1) % this.capacity;
+		this.size = this.size-1;
+		return item;
+	
+	}
+
+	//Method to get front of queue
+	int front() {
+		if(isEmpty(this)) 
+			return Integer.MIN_VALUE;
+	
+		return this.array[this.front];		
+	}
+
+	//Method to get rear of queue
+	int rear() {
+		if(isEmpty(this))		
+			return Integer.MIN_VALUE;
+		
+		return this.array[this.rear];
+	}
+}
+
+//Driver Class
+public class MyQueue{
+	public static void main(String[] args){
+		
+		Queue queue = new Queue(1000);
+		
+		queue.enqueue(10);
+		queue.enqueue(20);
+		queue.enqueue(30);
+		queue.enqueue(40);
+	
+		System.out.println(queue.dequeue()+(" dequeued from queue"));
+		System.out.println("Front item is " + queue.front());
+		System.out.println("Rear item is "+ queue.rear());
+	}
+}

dataStructure/MyStack.java

@@ -0,0 +1,58 @@
+package dataStructure;
+
+    class Stack {
+	static final int MAX = 1000;
+	int top;
+	int a[] = new int[MAX];
+	
+	boolean isEmpty() {
+		return (top<0);
+	}
+	
+	Stack(){
+		top = -1;
+	}
+	
+	boolean push(int x) {
+		if(top>= (MAX-1)) {
+			System.out.println(x+"pushed into stack");
+			return false;
+		}
+		else {
+			a[++top] = x;
+			System.out.println(x+"pushed into stack");
+			return true;
+		}
+	}
+	
+	int pop() {
+		if(top<0) {
+			System.out.println("Stack underflow");
+			return 0;
+		}
+		else {
+			int x = a[top--];
+			return x;
+		}
+	}
+	
+	int peek() {
+		if(top<0) {
+			System.out.println("Stack underflow");
+			return 0;
+		}
+		else {
+			int x = a[top];	return x;
+		}
+	}
+	
+	class MyStack{
+		public void main (String[] args) {
+			Stack s = new Stack();
+			s.push(10);
+			s.push(20);
+			s.push(30);
+			System.out.println(s.pop() + " Popped from stack");
+		}
+	}
+}