#Modification 15

Author: amangit1314

stack_and_queue/.cph/.Stack_Queue_Problem_03.java_4cd5b7badd85dac4f4b1d9cce25274ef.prob

@@ -0,0 +1 @@
+{"name":"Local: Stack_Queue_Problem_03","url":"c:\\Users\\AmanSoni\\Desktop\\Java Program's\\Java-Eclipse\\Placement Prepration\\src\\stack_and_queue\\Stack_Queue_Problem_03.java","tests":[{"id":1609222893914,"input":"","output":""}],"interactive":false,"memoryLimit":1024,"timeLimit":3000,"srcPath":"c:\\Users\\AmanSoni\\Desktop\\Java Program's\\Java-Eclipse\\Placement Prepration\\src\\stack_and_queue\\Stack_Queue_Problem_03.java","group":"local","local":true}

stack_and_queue/Infix_To_Postfix.java

@@ -0,0 +1,76 @@
+package stack_and_queue;
+import java.util.*;
+
+public class Infix_To_Postfix {
+
+    static int Prec(char ch){
+        switch(ch){
+            case '+':
+            case '-':
+                return 1;
+            
+            case '*':
+            case '/':
+                return 2;
+            
+            case '^':
+                return 3;
+        }
+
+        return -1;
+    }
+
+    static String infixToPostfix(String exp){
+
+        String result = new String(" ");
+        Stack<Character> stack = new Stack<>();
+
+        for(int i = 0 ; i < exp.length() ; ++i){
+            char c = exp.charAt(i);
+
+            if(Character.isLetterOrDigit(c))
+                result += c;
+
+            else if(c == '(')
+                stack.push(c);
+
+            else if (c == ')'){
+                while (!stack.isEmpty() && stack.peek() != '(') 
+                    result += stack.pop(); 
+
+                stack.pop();
+            }
+
+            else{
+                while(!stack.isEmpty() && Prec(c) <= Prec(stack.peek())){
+                    result += stack.pop();
+                }   
+            }
+
+            stack.push(c);
+        }
+
+        while (!stack.isEmpty()) {
+
+            if(stack.peek() == '(')
+                return "Invalid Expression";
+
+            result += stack.pop(); 
+        }
+
+        return result;
+    }
+
+    public static void main(String[] args) {
+
+        Scanner sc = new Scanner(System.in);
+        String exp = sc.nextLine();
+        
+        @SuppressWarnings("unused")
+		Infix_To_Postfix post = new Infix_To_Postfix();
+
+        System.out.println(infixToPostfix(exp));
+        sc.close();
+    }
+
+}

stack_and_queue/Parenthesis_Checker_Problem.java

@@ -0,0 +1,75 @@
+package stack_and_queue;
+import java.util.Scanner;
+import java.util.Stack;
+
+public class Parenthesis_Checker_Problem {
+
+	@SuppressWarnings("resource")
+	public static void main(String[] args) {
+		
+		Scanner sc = new Scanner(System.in);
+		int t = sc.nextInt();
+		while(t-- != 0) {
+			
+			String s = sc.nextLine();
+			Stack<Character> stack = new Stack<>();
+			
+			boolean isBalanced = true;
+			
+			for(int i = 0 ; i < s.length() ; i++) {
+				
+				char ch = s.charAt(i);
+				if(ch == '(' || ch == '{' || ch == '[') {
+					stack.push(ch);
+					continue;
+				}
+				
+				if(stack.isEmpty()) {
+					isBalanced = false;
+					break;
+				}
+				
+				if(ch == ')') {
+					if(stack.peek() == '(') {
+						stack.pop();
+					}else {
+						isBalanced = false;
+						break;
+					}
+				}
+				
+				if(ch == '}') {
+					if(stack.peek() == '{') {
+						stack.pop();
+					}else {
+						isBalanced = false;
+						break;
+					}
+				}
+				
+				if(ch == ']') {
+					if(stack.peek() == '[') {
+						stack.pop();
+					}else {
+						isBalanced = false;
+						break;
+					}
+				}
+				
+			}
+			
+			if(!stack.isEmpty()) {
+				isBalanced = false;
+			}
+			
+			if(isBalanced) {
+				System.out.println("isBalanced");
+			}else {
+				System.out.println("not balanced");
+			}
+			
+		}
+
+	}
+
+}

stack_and_queue/Stack_Queue_Problem_01_i.java

@@ -0,0 +1,69 @@
+package stack_and_queue;
+import java.util.*;
+
+/*
+ * Implement Stack from Scratch Array Implementation
+ */
+public class Stack_Queue_Problem_01_i<Item> implements Iterable<Item> {
+
+    @SuppressWarnings("unchecked")
+    private Item[] a = (Item[]) new Object[1]; // Stack Items
+    private int N = 0; // number of items
+
+    public boolean isEmpty() {
+        return N == 0;
+    }
+
+    public int size() {
+        return N;
+    }
+
+    private void resize(int max) {
+        @SuppressWarnings("unchecked")
+        Item[] temp = (Item[]) new Object[max];
+        for (int i = 0; i < N; i++)
+            temp[i] = a[i];
+        a = temp;
+    }
+
+    public void push(Item item) {
+        if (N == a.length)
+            resize(2 * a.length);
+        a[N++] = item;
+
+    }
+
+    public Item pop() {
+        Item item = a[--N];
+        a[N] = null;
+        
+        if (N > 0 && N == a.length / 4)
+            resize(a.length / 2);
+        
+        return item;
+    }
+
+    public Iterator<Item> iterator() {
+        return new ReverseArrayIterator();
+    }
+
+    private class ReverseArrayIterator implements Iterator<Item> {
+        public int i = N;
+
+        public boolean hasNext() {
+            return i > 0;
+        }
+
+        public Item next() {
+            return a[--i];
+        }
+
+        public void remove() {
+
+        }
+    }
+
+    public static void main(String[] args) {
+
+    }
+}

stack_and_queue/Stack_Queue_Problem_01_ii.java

@@ -0,0 +1,115 @@
+package stack_and_queue;
+import static java.lang.System.exit;
+
+//Java program to Implement a stack using singly linked list  
+
+//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 tempt 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 Stack_Queue_Problem_01_ii {
+  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());
+  }
+}