Replaced java Stack with ArrayDeque

javadev · web-flow · commit 7936e11c2235 · 2023-07-23T14:52:19.000+03:00
diff --git a/src/main/kotlin/g0001_0100/s0020_valid_parentheses/Solution.kt b/src/main/kotlin/g0001_0100/s0020_valid_parentheses/Solution.kt
@@ -4,21 +4,19 @@ package g0001_0100.s0020_valid_parentheses
 // #Data_Structure_I_Day_9_Stack_Queue #Udemy_Strings
 // #2023_07_03_Time_137_ms_(88.76%)_Space_33.7_MB_(90.45%)
 
-import java.util.Stack
-
 class Solution {
     fun isValid(s: String): Boolean {
-        val stack = Stack<Char>()
+        val stack = ArrayDeque<Char>()
         for (element in s) {
             val c = element
             if (c == '(' || c == '[' || c == '{') {
-                stack.push(c)
-            } else if (c == ')' && stack.isNotEmpty() && stack.peek() == '(') {
-                stack.pop()
-            } else if (c == '}' && stack.isNotEmpty() && stack.peek() == '{') {
-                stack.pop()
-            } else if (c == ']' && stack.isNotEmpty() && stack.peek() == '[') {
-                stack.pop()
+                stack.addLast(c)
+            } else if (c == ')' && stack.isNotEmpty() && stack.last() == '(') {
+                stack.removeLast()
+            } else if (c == '}' && stack.isNotEmpty() && stack.last() == '{') {
+                stack.removeLast()
+            } else if (c == ']' && stack.isNotEmpty() && stack.last() == '[') {
+                stack.removeLast()
             } else {
                 return false
             }
diff --git a/src/main/kotlin/g0001_0100/s0077_combinations/Solution.kt b/src/main/kotlin/g0001_0100/s0077_combinations/Solution.kt
@@ -3,20 +3,18 @@ package g0001_0100.s0077_combinations
 // #Medium #Backtracking #Algorithm_I_Day_11_Recursion_Backtracking
 // #2023_07_10_Time_232_ms_(100.00%)_Space_41.1_MB_(95.65%)
 
-import java.util.Stack
-
 class Solution {
     fun combine(n: Int, k: Int): List<List<Int>> {
         val ans: MutableList<List<Int>> = ArrayList()
         // Boundary case
         if (n > 20 || k < 1 || k > n) {
             return ans
         }
-        backtrack(ans, n, k, 1, Stack())
+        backtrack(ans, n, k, 1, ArrayDeque())
         return ans
     }
 
-    private fun backtrack(ans: MutableList<List<Int>>, n: Int, k: Int, s: Int, stack: Stack<Int>) {
+    private fun backtrack(ans: MutableList<List<Int>>, n: Int, k: Int, s: Int, stack: ArrayDeque<Int>) {
         // Base case
         // If k becomes 0
         if (k == 0) {
@@ -25,10 +23,10 @@ class Solution {
         }
         // Start with s till n-k+1
         for (i in s..n - k + 1) {
-            stack.push(i)
+            stack.addLast(i)
             // Update start for recursion and decrease k by 1
             backtrack(ans, n, k - 1, i + 1, stack)
-            stack.pop()
+            stack.removeLast()
         }
     }
 }
diff --git a/src/main/kotlin/g0101_0200/s0144_binary_tree_preorder_traversal/Solution.kt b/src/main/kotlin/g0101_0200/s0144_binary_tree_preorder_traversal/Solution.kt
@@ -4,7 +4,6 @@ package g0101_0200.s0144_binary_tree_preorder_traversal
 // #Udemy_Tree_Stack_Queue #2022_10_09_Time_277_ms_(37.90%)_Space_34.2_MB_(82.19%)
 
 import com_github_leetcode.TreeNode
-import java.util.Stack
 
 /*
  * Example:
@@ -22,15 +21,15 @@ class Solution {
         if (root == null) {
             return result
         }
-        val stack: Stack<TreeNode> = Stack<TreeNode>()
+        val stack: ArrayDeque<TreeNode?> = ArrayDeque()
         var current: TreeNode? = root
         while (current != null || stack.isNotEmpty()) {
             while (current != null) {
                 result.add(current.`val`)
-                stack.push(current.right)
+                stack.addLast(current.right)
                 current = current.left
             }
-            current = stack.pop()
+            current = stack.removeLast()
         }
         return result
     }
diff --git a/src/main/kotlin/g0101_0200/s0155_min_stack/MinStack.kt b/src/main/kotlin/g0101_0200/s0155_min_stack/MinStack.kt
@@ -4,31 +4,28 @@ package g0101_0200.s0155_min_stack
 // #Data_Structure_II_Day_14_Stack_Queue #Programming_Skills_II_Day_18 #Level_2_Day_16_Design
 // #Udemy_Design #2022_09_06_Time_331_ms_(84.88%)_Space_54.3_MB_(46.34%)
 
-import java.util.Stack
-
 class MinStack() {
-    private val stack: Stack<Pair<Int, Int>> = Stack()
+    private val stack: ArrayDeque<Pair<Int, Int>> = ArrayDeque()
 
     fun push(x: Int) {
         val min: Int = if (stack.isEmpty()) x
         else getMin()
-
-        stack.push(x to minOf(min, x))
+        stack.addLast(x to minOf(min, x))
     }
 
     fun pop() {
-        stack.pop()
+        stack.removeLast()
     }
 
     fun top(): Int {
         return stack
-            .peek()
+            .last()
             .first
     }
 
     fun getMin(): Int {
         return stack
-            .peek()
+            .last()
             .second
     }
 }
diff --git a/src/main/kotlin/g0701_0800/s0770_basic_calculator_iv/Solution.kt b/src/main/kotlin/g0701_0800/s0770_basic_calculator_iv/Solution.kt
@@ -4,7 +4,6 @@ package g0701_0800.s0770_basic_calculator_iv
 // #2023_03_10_Time_222_ms_(100.00%)_Space_39.2_MB_(100.00%)
 
 import java.util.Collections
-import java.util.Stack
 
 class Solution {
     internal inner class Node {
@@ -126,10 +125,10 @@ class Solution {
         return 0
     }
 
-    private fun helper(numS: Stack<Node>, ops: Stack<Char>): Node {
-        val b = numS.pop()
-        val a = numS.pop()
-        val op = ops.pop()
+    private fun helper(numS: ArrayDeque<Node>, ops: ArrayDeque<Char>): Node {
+        val b = numS.removeLast()
+        val a = numS.removeLast()
+        val op = ops.removeLast()
         if (op == '*') {
             return a.mul(b)
         } else if (op == '+') {
@@ -148,8 +147,8 @@ class Solution {
             vars[evalvarS[i]] = evalintS[i]
         }
         val n = expression.length
-        val numS = Stack<Node>()
-        val ops = Stack<Char>()
+        val numS = ArrayDeque<Node>()
+        val ops = ArrayDeque<Char>()
         var i = 0
         while (i < n) {
             val a = expression[i]
@@ -162,12 +161,12 @@ class Solution {
             } else if (a == '(') {
                 ops.add(a)
             } else if (a == ')') {
-                while (ops.peek() != '(') {
+                while (ops.last() != '(') {
                     numS.add(helper(numS, ops))
                 }
-                ops.pop()
+                ops.removeLast()
             } else if (a == '+' || a == '-' || a == '*') {
-                while (ops.isNotEmpty() && getPriority(ops.peek()) >= getPriority(a)) {
+                while (ops.isNotEmpty() && getPriority(ops.last()) >= getPriority(a)) {
                     numS.add(helper(numS, ops))
                 }
                 ops.add(a)
@@ -177,6 +176,6 @@ class Solution {
         while (ops.isNotEmpty()) {
             numS.add(helper(numS, ops))
         }
-        return numS.peek().evaluate(vars).toList()
+        return numS.last().evaluate(vars).toList()
     }
 }
diff --git a/src/main/kotlin/g1101_1200/s1172_dinner_plate_stacks/DinnerPlates.kt b/src/main/kotlin/g1101_1200/s1172_dinner_plate_stacks/DinnerPlates.kt
@@ -3,11 +3,10 @@ package g1101_1200.s1172_dinner_plate_stacks
 // #Hard #Hash_Table #Stack #Design #Heap_Priority_Queue
 // #2023_05_25_Time_1160_ms_(50.00%)_Space_177.1_MB_(50.00%)
 
-import java.util.Stack
 import java.util.TreeSet
 
 class DinnerPlates(private val stackCap: Int) {
-    private val stacks: MutableList<Stack<Int>>
+    private val stacks: MutableList<ArrayDeque<Int>>
     private val leftIndex: TreeSet<Int>
 
     init {
@@ -18,17 +17,17 @@ class DinnerPlates(private val stackCap: Int) {
     fun push(`val`: Int) {
         if (leftIndex.isNotEmpty()) {
             val i = leftIndex.first()
-            stacks[i].push(`val`)
+            stacks[i].addLast(`val`)
             if (stacks[i].size == stackCap) {
                 leftIndex.remove(i)
             }
             return
         }
         if (stacks.isEmpty() || stacks[stacks.size - 1].size == stackCap) {
-            val newStack = Stack<Int>()
+            val newStack = ArrayDeque<Int>()
             stacks.add(newStack)
         }
-        stacks[stacks.size - 1].push(`val`)
+        stacks[stacks.size - 1].addLast(`val`)
     }
 
     fun pop(): Int {
@@ -39,7 +38,7 @@ class DinnerPlates(private val stackCap: Int) {
             leftIndex.remove(stacks.size - 1)
             stacks.removeAt(stacks.size - 1)
         }
-        val `val` = stacks[stacks.size - 1].pop()
+        val `val` = stacks[stacks.size - 1].removeLast()
         if (stacks[stacks.size - 1].isEmpty()) {
             leftIndex.remove(stacks.size - 1)
             stacks.removeAt(stacks.size - 1)
@@ -51,7 +50,7 @@ class DinnerPlates(private val stackCap: Int) {
         if (stacks.size - 1 >= index) {
             var `val` = -1
             if (stacks[index].isNotEmpty()) {
-                `val` = stacks[index].pop()
+                `val` = stacks[index].removeLast()
             }
             if (stacks[index].isEmpty() && index == stacks.size - 1) {
                 leftIndex.remove(stacks.size - 1)
diff --git a/src/main/kotlin/g1401_1500/s1496_path_crossing/Solution.kt b/src/main/kotlin/g1401_1500/s1496_path_crossing/Solution.kt
@@ -2,14 +2,12 @@ package g1401_1500.s1496_path_crossing
 
 // #Easy #String #Hash_Table #2023_06_13_Time_120_ms_(100.00%)_Space_34.9_MB_(93.33%)
 
-import java.util.Stack
-
 class Solution {
     fun isPathCrossing(path: String): Boolean {
-        val visited = Stack<Coord>()
+        val visited = ArrayDeque<Coord>()
         visited.add(Coord(0, 0))
         for (c in path.toCharArray()) {
-            val last = visited.peek()
+            val last = visited.last()
             if (c == 'N') {
                 val nextStep = Coord(last.x, last.y + 1)
                 if (visited.contains(nextStep)) {
diff --git a/src/main/kotlin/g1501_1600/s1544_make_the_string_great/Solution.kt b/src/main/kotlin/g1501_1600/s1544_make_the_string_great/Solution.kt
@@ -2,20 +2,18 @@ package g1501_1600.s1544_make_the_string_great
 
 // #Easy #String #Stack #2023_06_12_Time_164_ms_(92.16%)_Space_34.7_MB_(100.00%)
 
-import java.util.Stack
-
 class Solution {
     fun makeGood(s: String): String {
-        val stack = Stack<Char>()
+        val stack = ArrayDeque<Char>()
         for (element in s) {
             if (stack.isEmpty()) {
                 stack.add(element)
             } else {
-                if (stack.peek().lowercaseChar() == element.lowercaseChar()) {
-                    if (Character.isLowerCase(stack.peek()) && Character.isUpperCase(element)) {
-                        stack.pop()
-                    } else if (Character.isUpperCase(stack.peek()) && Character.isLowerCase(element)) {
-                        stack.pop()
+                if (stack.last().lowercaseChar() == element.lowercaseChar()) {
+                    if (Character.isLowerCase(stack.last()) && Character.isUpperCase(element)) {
+                        stack.removeLast()
+                    } else if (Character.isUpperCase(stack.last()) && Character.isLowerCase(element)) {
+                        stack.removeLast()
                     } else {
                         stack.add(element)
                     }
@@ -26,7 +24,7 @@ class Solution {
         }
         val sb = StringBuilder()
         while (stack.isNotEmpty()) {
-            sb.append(stack.pop())
+            sb.append(stack.removeLast())
         }
         return sb.reverse().toString()
     }
diff --git a/src/test/kotlin/g1101_1200/s1114_print_in_order/FooTest.kt b/src/test/kotlin/g1101_1200/s1114_print_in_order/FooTest.kt
@@ -14,7 +14,7 @@ internal class FooTest {
         Thread { foo.first { fooData[0]++ } }.start()
         Thread { foo.second { fooData[0]++ } }.start()
         Thread { foo.third { fooData[0]++ } }.start()
-        TimeUnit.MILLISECONDS.sleep(800)
+        TimeUnit.MILLISECONDS.sleep(1000)
         assertThat(fooData[0], equalTo(3))
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -3,20 +3,18 @@ package g0001_0100.s0077_combinations`
`3`	`3`	`// #Medium #Backtracking #Algorithm_I_Day_11_Recursion_Backtracking`
`4`	`4`	`// #2023_07_10_Time_232_ms_(100.00%)_Space_41.1_MB_(95.65%)`
`5`	`5`
`6`		`-import java.util.Stack`
`7`		`-`
`8`	`6`	`class Solution {`
`9`	`7`	`fun combine(n: Int, k: Int): List<List<Int>> {`
`10`	`8`	`val ans: MutableList<List<Int>> = ArrayList()`
`11`	`9`	`// Boundary case`
`12`	`10`	`if (n > 20 \|\| k < 1 \|\| k > n) {`
`13`	`11`	`return ans`
`14`	`12`	`}`
`15`		`- backtrack(ans, n, k, 1, Stack())`
	`13`	`+ backtrack(ans, n, k, 1, ArrayDeque())`
`16`	`14`	`return ans`
`17`	`15`	`}`
`18`	`16`
`19`		`- private fun backtrack(ans: MutableList<List<Int>>, n: Int, k: Int, s: Int, stack: Stack<Int>) {`
	`17`	`+ private fun backtrack(ans: MutableList<List<Int>>, n: Int, k: Int, s: Int, stack: ArrayDeque<Int>) {`
`20`	`18`	`// Base case`
`21`	`19`	`// If k becomes 0`
`22`	`20`	`if (k == 0) {`
`@@ -25,10 +23,10 @@ class Solution {`
`25`	`23`	`}`
`26`	`24`	`// Start with s till n-k+1`
`27`	`25`	`for (i in s..n - k + 1) {`
`28`		`- stack.push(i)`
	`26`	`+ stack.addLast(i)`
`29`	`27`	`// Update start for recursion and decrease k by 1`
`30`	`28`	`backtrack(ans, n, k - 1, i + 1, stack)`
`31`		`- stack.pop()`
	`29`	`+ stack.removeLast()`
`32`	`30`	`}`
`33`	`31`	`}`
`34`	`32`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,6 @@ package g0101_0200.s0144_binary_tree_preorder_traversal`
`4`	`4`	`// #Udemy_Tree_Stack_Queue #2022_10_09_Time_277_ms_(37.90%)_Space_34.2_MB_(82.19%)`
`5`	`5`
`6`	`6`	`import com_github_leetcode.TreeNode`
`7`		`-import java.util.Stack`
`8`	`7`
`9`	`8`	`/*`
`10`	`9`	`* Example:`
`@@ -22,15 +21,15 @@ class Solution {`
`22`	`21`	`if (root == null) {`
`23`	`22`	`return result`
`24`	`23`	`}`
`25`		`- val stack: Stack<TreeNode> = Stack<TreeNode>()`
	`24`	`+ val stack: ArrayDeque<TreeNode?> = ArrayDeque()`
`26`	`25`	`var current: TreeNode? = root`
`27`	`26`	`while (current != null \|\| stack.isNotEmpty()) {`
`28`	`27`	`while (current != null) {`
`29`	`28`	result.add(current.`val`)
`30`		`- stack.push(current.right)`
	`29`	`+ stack.addLast(current.right)`
`31`	`30`	`current = current.left`
`32`	`31`	`}`
`33`		`- current = stack.pop()`
	`32`	`+ current = stack.removeLast()`
`34`	`33`	`}`
`35`	`34`	`return result`
`36`	`35`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ internal class FooTest {`
`14`	`14`	`Thread { foo.first { fooData[0]++ } }.start()`
`15`	`15`	`Thread { foo.second { fooData[0]++ } }.start()`
`16`	`16`	`Thread { foo.third { fooData[0]++ } }.start()`
`17`		`- TimeUnit.MILLISECONDS.sleep(800)`
	`17`	`+ TimeUnit.MILLISECONDS.sleep(1000)`
`18`	`18`	`assertThat(fooData[0], equalTo(3))`
`19`	`19`	`}`
`20`	`20`	`}`