Added Validate Stack Sequences to Stack

Author: SamsonPN

.ipynb_checkpoints/Stack-checkpoint.ipynb

@@ -417,10 +417,126 @@
     "};"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "d238789d",
+   "metadata": {},
+   "source": [
+    "## Validate Stack Sequences\n",
+    "\n",
+    "* https://leetcode.com/problems/validate-stack-sequences/description/\n",
+    "***\n",
+    "* Time Complexity: O(n)\n",
+    "    - pushed and popped are the same length since they're just permutations of each other\n",
+    "    - you will traverse all of pushed and all of popped so it's O(2n) = O(n)\n",
+    "* Space Complexity: O(n) with stack, O(1) using pushed as stack\n",
+    "    - you can push/pop from a stack to find the answer\n",
+    "    - using pushed as a stack will just overwrite its earlier values\n",
+    "***\n",
+    "* we iterate through pushed and push the values into a stack\n",
+    "* we also keep a pointer in popped as well\n",
+    "* if we get to a pushed value that was also popped, so if pushed[i] === popped[j]\n",
+    "    - we will not push that value but instead see if there are others in the stack that can be popped after j\n",
+    "    - so we enter a while loop for this where we continually pop from the stack and increment j\n",
+    "* for the space-optimized version, the concept is the same except pushed can be used as the stack\n",
+    "    - we just have another pointer to keep track of where the top of the stack is and rewrite the values with later values of pushed\n",
+    "    - then once we meet the condition of pushed === popped, instead of actually popping, we just decrement pointer that points to the top of the stack\n",
+    "        * this effectively pops b/c we overwrite those values anyway\n",
+    "    - then once we've finished traversing both, we check if i === 0.\n",
+    "        * when i = 0 that means the stack is empty"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "bc11b464",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "/**\n",
+    " * @param {number[]} pushed\n",
+    " * @param {number[]} popped\n",
+    " * @return {boolean}\n",
+    " */\n",
+    "var validateStackSequences = function(pushed, popped) {\n",
+    "    const stack = [];\n",
+    "\n",
+    "    let j = 0;\n",
+    "    for (let i = 0; i < pushed.length; i++) {\n",
+    "        // remember that pushed and popped are INTEGER ARRAYS, NOT STACKS\n",
+    "        // so if we traverse them from L --> R, we can see the order of pushed and popped\n",
+    "\n",
+    "        // if we pushed and then immediately popped, then this will guarantee\n",
+    "        // the items we pushed beforehand will also be popped off\n",
+    "\n",
+    "        // e.g. \n",
+    "        // pushed = [1, 2, 0, 3, 4]\n",
+    "        // popped = [0, 2, 1, 4, 3]\n",
+    "        // stack = [1, 2]\n",
+    "        // and once we get to i = 2 and j = 0, we see that pushed (0) === popped (0)\n",
+    "        // so then we enter our while loop\n",
+    "        // j = 1, 2 is at the top of our stack so we pop\n",
+    "        // j = 2, 1 is now at the top of our stack so we pop\n",
+    "        // j = 3, stack is empty now []\n",
+    "        if (pushed[i] === popped[j]) {\n",
+    "            j++;\n",
+    "            while((stack.length > 0) && (stack[stack.length - 1] === popped[j])) {\n",
+    "                stack.pop();\n",
+    "                j++;\n",
+    "            }\n",
+    "        }\n",
+    "        else {\n",
+    "            stack.push(pushed[i]);\n",
+    "        }\n",
+    "    }\n",
+    "\n",
+    "    return stack.length === 0;\n",
+    "}\n",
+    "\n",
+    "// space - efficient\n",
+    "var validateStackSequences = function(pushed, popped) {\n",
+    "    let i = 0;\n",
+    "    let j = 0;\n",
+    "\n",
+    "    for (const val of pushed) {\n",
+    "        // this overwrites pushed and treats it as a stack\n",
+    "        pushed[i] = val;\n",
+    "        i++;\n",
+    "\n",
+    "        // essentially the same as above\n",
+    "        while (i > 0 && pushed[i - 1] === popped[j]) {\n",
+    "            // decrementing i effectively removes a value from our \"stack\"\n",
+    "            // since we overwrite it later\n",
+    "            i--;\n",
+    "            j++;\n",
+    "        }\n",
+    "    }\n",
+    "\n",
+    "    // if we are back at i, that means we have \"popped\" everything from our \"stack\"\n",
+    "    return i === 0;\n",
+    "}\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f800b524",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5c279eb9",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "c8a008e0",
+   "id": "e5e99a2d",
    "metadata": {},
    "outputs": [],
    "source": []

Stack.ipynb

@@ -417,10 +417,126 @@
     "};"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "d238789d",
+   "metadata": {},
+   "source": [
+    "## Validate Stack Sequences\n",
+    "\n",
+    "* https://leetcode.com/problems/validate-stack-sequences/description/\n",
+    "***\n",
+    "* Time Complexity: O(n)\n",
+    "    - pushed and popped are the same length since they're just permutations of each other\n",
+    "    - you will traverse all of pushed and all of popped so it's O(2n) = O(n)\n",
+    "* Space Complexity: O(n) with stack, O(1) using pushed as stack\n",
+    "    - you can push/pop from a stack to find the answer\n",
+    "    - using pushed as a stack will just overwrite its earlier values\n",
+    "***\n",
+    "* we iterate through pushed and push the values into a stack\n",
+    "* we also keep a pointer in popped as well\n",
+    "* if we get to a pushed value that was also popped, so if pushed[i] === popped[j]\n",
+    "    - we will not push that value but instead see if there are others in the stack that can be popped after j\n",
+    "    - so we enter a while loop for this where we continually pop from the stack and increment j\n",
+    "* for the space-optimized version, the concept is the same except pushed can be used as the stack\n",
+    "    - we just have another pointer to keep track of where the top of the stack is and rewrite the values with later values of pushed\n",
+    "    - then once we meet the condition of pushed === popped, instead of actually popping, we just decrement pointer that points to the top of the stack\n",
+    "        * this effectively pops b/c we overwrite those values anyway\n",
+    "    - then once we've finished traversing both, we check if i === 0.\n",
+    "        * when i = 0 that means the stack is empty"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "bc11b464",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "/**\n",
+    " * @param {number[]} pushed\n",
+    " * @param {number[]} popped\n",
+    " * @return {boolean}\n",
+    " */\n",
+    "var validateStackSequences = function(pushed, popped) {\n",
+    "    const stack = [];\n",
+    "\n",
+    "    let j = 0;\n",
+    "    for (let i = 0; i < pushed.length; i++) {\n",
+    "        // remember that pushed and popped are INTEGER ARRAYS, NOT STACKS\n",
+    "        // so if we traverse them from L --> R, we can see the order of pushed and popped\n",
+    "\n",
+    "        // if we pushed and then immediately popped, then this will guarantee\n",
+    "        // the items we pushed beforehand will also be popped off\n",
+    "\n",
+    "        // e.g. \n",
+    "        // pushed = [1, 2, 0, 3, 4]\n",
+    "        // popped = [0, 2, 1, 4, 3]\n",
+    "        // stack = [1, 2]\n",
+    "        // and once we get to i = 2 and j = 0, we see that pushed (0) === popped (0)\n",
+    "        // so then we enter our while loop\n",
+    "        // j = 1, 2 is at the top of our stack so we pop\n",
+    "        // j = 2, 1 is now at the top of our stack so we pop\n",
+    "        // j = 3, stack is empty now []\n",
+    "        if (pushed[i] === popped[j]) {\n",
+    "            j++;\n",
+    "            while((stack.length > 0) && (stack[stack.length - 1] === popped[j])) {\n",
+    "                stack.pop();\n",
+    "                j++;\n",
+    "            }\n",
+    "        }\n",
+    "        else {\n",
+    "            stack.push(pushed[i]);\n",
+    "        }\n",
+    "    }\n",
+    "\n",
+    "    return stack.length === 0;\n",
+    "}\n",
+    "\n",
+    "// space - efficient\n",
+    "var validateStackSequences = function(pushed, popped) {\n",
+    "    let i = 0;\n",
+    "    let j = 0;\n",
+    "\n",
+    "    for (const val of pushed) {\n",
+    "        // this overwrites pushed and treats it as a stack\n",
+    "        pushed[i] = val;\n",
+    "        i++;\n",
+    "\n",
+    "        // essentially the same as above\n",
+    "        while (i > 0 && pushed[i - 1] === popped[j]) {\n",
+    "            // decrementing i effectively removes a value from our \"stack\"\n",
+    "            // since we overwrite it later\n",
+    "            i--;\n",
+    "            j++;\n",
+    "        }\n",
+    "    }\n",
+    "\n",
+    "    // if we are back at i, that means we have \"popped\" everything from our \"stack\"\n",
+    "    return i === 0;\n",
+    "}\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f800b524",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5c279eb9",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "c8a008e0",
+   "id": "e5e99a2d",
    "metadata": {},
    "outputs": [],
    "source": []