Update QueueUsingTwoStacks.java

jumpman-cmd · web-flow · commit 4148be792605 · 2024-09-17T14:00:21.000+02:00
diff --git a/QueueUsingTwoStacks.java b/QueueUsingTwoStacks.java
@@ -23,54 +23,56 @@ The first line contains an integer q (the number of queries).
 import java.io.*;
 import java.util.*;
 
-public class QueueUsingTwoStacks 
+public class Solution 
 {
     public static void main(String[] args) 
     {
         /* Enter your code here. Read input from STDIN. Print output to STDOUT. Your class should be named Solution. */
-        Scanner count = new Scanner(System.in);
-        int numberOfOperations = count.nextInt();
+        Scanner scan = new Scanner(System.in);
+        int numberOfOperations = scan.nextInt();
         
-        Stack<Integer> stack1 = new Stack<>();
-        Stack<Integer> stack2 = new Stack<>();
+        Stack<Integer> quStack1 = new Stack<>();
+        Stack<Integer> quStack2 = new Stack<>();
         
         for(int i = 0; i < numberOfOperations; i++)
         {
-            int typeOfOperation = count.nextInt();
-            
+            int typeOfOperation = scan.nextInt();
             if(typeOfOperation == 1)
             {
-                int addToQu = count.nextInt();
-                stack1.push(addToQu);
+                int x = scan.nextInt();
+                quStack1.push(x);
             }
             
             else if(typeOfOperation == 2)
             {
-                if(stack2.isEmpty())
+                if(quStack2.isEmpty())
                 {
-                    while(!stack1.isEmpty())
+                    while(!quStack1.isEmpty())
                     {
-                        stack2.push(stack1.pop());
+                        quStack2.push(quStack1.pop());
                     }
                 }
                 
-                stack2.pop();
+                quStack2.pop();
             }
             
             else
             {
-                if(typeOfOperation == 3 && stack2.isEmpty())
+                if(typeOfOperation == 3)
                 {
-                    while(!stack1.isEmpty())
+                    if(quStack2.isEmpty())
                     {
-                        stack2.push(stack1.pop());
+                        while(!quStack1.isEmpty())
+                        {
+                            quStack2.push(quStack1.pop());
+                        }
                     }
                 }
                 
-                System.out.println(stack2.peek());
+                System.out.println(quStack2.peek());
             }
         }
         
-        count.close();
+        scan.close();
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -23,54 +23,56 @@ The first line contains an integer q (the number of queries).`
`23`	`23`	`import java.io.*;`
`24`	`24`	`import java.util.*;`
`25`	`25`
`26`		`-public class QueueUsingTwoStacks`
	`26`	`+public class Solution`
`27`	`27`	`{`
`28`	`28`	`public static void main(String[] args)`
`29`	`29`	`{`
`30`	`30`	`/* Enter your code here. Read input from STDIN. Print output to STDOUT. Your class should be named Solution. */`
`31`		`- Scanner count = new Scanner(System.in);`
`32`		`- int numberOfOperations = count.nextInt();`
	`31`	`+ Scanner scan = new Scanner(System.in);`
	`32`	`+ int numberOfOperations = scan.nextInt();`
`33`	`33`
`34`		`- Stack<Integer> stack1 = new Stack<>();`
`35`		`- Stack<Integer> stack2 = new Stack<>();`
	`34`	`+ Stack<Integer> quStack1 = new Stack<>();`
	`35`	`+ Stack<Integer> quStack2 = new Stack<>();`
`36`	`36`
`37`	`37`	`for(int i = 0; i < numberOfOperations; i++)`
`38`	`38`	`{`
`39`		`- int typeOfOperation = count.nextInt();`
`40`		`-`
	`39`	`+ int typeOfOperation = scan.nextInt();`
`41`	`40`	`if(typeOfOperation == 1)`
`42`	`41`	`{`
`43`		`- int addToQu = count.nextInt();`
`44`		`- stack1.push(addToQu);`
	`42`	`+ int x = scan.nextInt();`
	`43`	`+ quStack1.push(x);`
`45`	`44`	`}`
`46`	`45`
`47`	`46`	`else if(typeOfOperation == 2)`
`48`	`47`	`{`
`49`		`- if(stack2.isEmpty())`
	`48`	`+ if(quStack2.isEmpty())`
`50`	`49`	`{`
`51`		`- while(!stack1.isEmpty())`
	`50`	`+ while(!quStack1.isEmpty())`
`52`	`51`	`{`
`53`		`- stack2.push(stack1.pop());`
	`52`	`+ quStack2.push(quStack1.pop());`
`54`	`53`	`}`
`55`	`54`	`}`
`56`	`55`
`57`		`- stack2.pop();`
	`56`	`+ quStack2.pop();`
`58`	`57`	`}`
`59`	`58`
`60`	`59`	`else`
`61`	`60`	`{`
`62`		`- if(typeOfOperation == 3 && stack2.isEmpty())`
	`61`	`+ if(typeOfOperation == 3)`
`63`	`62`	`{`
`64`		`- while(!stack1.isEmpty())`
	`63`	`+ if(quStack2.isEmpty())`
`65`	`64`	`{`
`66`		`- stack2.push(stack1.pop());`
	`65`	`+ while(!quStack1.isEmpty())`
	`66`	`+ {`
	`67`	`+ quStack2.push(quStack1.pop());`
	`68`	`+ }`
`67`	`69`	`}`
`68`	`70`	`}`
`69`	`71`
`70`		`- System.out.println(stack2.peek());`
	`72`	`+ System.out.println(quStack2.peek());`
`71`	`73`	`}`
`72`	`74`	`}`
`73`	`75`
`74`		`- count.close();`
	`76`	`+ scan.close();`
`75`	`77`	`}`
`76`	`78`	`}`