第一份工作前最后更新

Author: hiha3456

TODO.md

@@ -1,8 +1,9 @@
 # 计划
 
-- 然后是stack 和 dp
-- 图论到时候看看面试考吗
+- 然后是stack 
+- 图论
+- 线段树
 
-- 剩下的慢慢补全
+- 剩下的零星题慢慢补全
 
 之后就是看leetcode和剑指（如果还没找到工作的话）

Untitled.ipynb

@@ -391,221 +391,8 @@
    "metadata": {},
    "source": [
     "## 题目\n",
-    "\n",
     "### [kth-largest-element-in-an-array](https://leetcode-cn.com/problems/kth-largest-element-in-an-array/)\n",
-    "\n",
-    "- 思路 1: sort 后取第 k 个，最简单直接，复杂度 O(N log N) 代码略\n",
-    "\n",
-    "- 思路 2: 使用最小堆，复杂度 O(N log k)，排前k个最大的，数据流的思路，如果小于对顶直接不用加入，如果大于堆顶就将堆顶替换为该数字进行重排，最后堆顶就是我们想要的结果。\n",
-    "\n",
-    "- 思路 3：把整个数组建最大堆，然后按堆排序把最大的k-1个数挪后边，排序的思路\n",
-    "\n",
-    "- 思路 4：quick select\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "直接使用python原生库的思路"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class Solution:\n",
-    "    def findKthLargest(self, nums: List[int], k: int) -> int:\n",
-    "        return heapq.nlargest(k,nums)[-1]\n",
-    "    \n",
-    "class Solution:\n",
-    "    def findKthLargest(self, nums: List[int], k: int) -> int:\n",
-    "        heap = []\n",
-    "        for num in nums:\n",
-    "            if len(heap) < k:\n",
-    "                heapq.heappush(heap,num)\n",
-    "            else:\n",
-    "                #heapreplace 删除当前堆中最小元素，然后加一个元素\n",
-    "                #heappushpop 是先推再删除最小元素，意味着有可能被删除的就是新推入的这个数本身， 应该用这种做法\n",
-    "                heapq.heappushpop(heap,num)\n",
-    "        \n",
-    "        return heap[0]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "思路2"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# 单独分一个堆\n",
-    "class Solution:\n",
-    "    def findKthLargest(self, nums: List[int], k: int) -> int:\n",
-    "        def minheapify(heap,root,len_heap):\n",
-    "            p = root\n",
-    "            while p*2 + 1 < len_heap:\n",
-    "                left = p*2 + 1\n",
-    "                right = p*2 + 2\n",
-    "\n",
-    "                min_index = left\n",
-    "                if right < len_heap and heap[right] < heap[left]:\n",
-    "                    min_index = right\n",
-    "                \n",
-    "                if heap[p] > heap[min_index]:\n",
-    "                    heap[p],heap[min_index] = heap[min_index],heap[p]\n",
-    "                    p = min_index\n",
-    "                else:\n",
-    "                    break\n",
-    "        \n",
-    "        def build_heap(heap,k):\n",
-    "            for i in range(k-1,-1,-1):\n",
-    "                minheapify(heap,i,k)\n",
-    "        \n",
-    "        min_heap = nums[:k].copy()\n",
-    "        build_heap(min_heap,k)\n",
-    "        \n",
-    "\n",
-    "        for num in nums[k:]:\n",
-    "            if num <= min_heap[0]:\n",
-    "                continue\n",
-    "            elif num > min_heap[0]:\n",
-    "                min_heap[0] = num\n",
-    "                minheapify(min_heap,0,k)\n",
-    "\n",
-    "        return min_heap[0]\n",
-    "    \n",
-    "# 原地\n",
-    "class Solution:\n",
-    "    def findKthLargest(self, nums: List[int], k: int) -> int:\n",
-    "        def minheapify(root,len_heap):\n",
-    "            p = root\n",
-    "            while p*2 + 1 < len_heap:\n",
-    "                left = p*2 + 1\n",
-    "                right = p*2 + 2\n",
-    "\n",
-    "                min_index = left\n",
-    "                if right < len_heap and nums[right] < nums[left]:\n",
-    "                    min_index = right\n",
-    "                \n",
-    "                if nums[p] > nums[min_index]:\n",
-    "                    nums[p],nums[min_index] = nums[min_index],nums[p]\n",
-    "                    p = min_index\n",
-    "                else:\n",
-    "                    break\n",
-    "        \n",
-    "        def build_heap(k):\n",
-    "            for i in range(k-1,-1,-1):\n",
-    "                minheapify(i,k)\n",
-    "        \n",
-    "        build_heap(k)\n",
-    "\n",
-    "        for i in range(k,len(nums)):\n",
-    "            if nums[i] <= nums[0]:\n",
-    "                continue\n",
-    "            elif nums[i] > nums[0]:\n",
-    "                nums[0],nums[i] = nums[i],nums[0] \n",
-    "                minheapify(0,k)\n",
-    "\n",
-    "        return nums[0]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "思路3"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class Solution:\n",
-    "    def findKthLargest(self, nums: List[int], k: int) -> int:\n",
-    "        \n",
-    "        def maxheapify(root,len_heap):\n",
-    "            p = root\n",
-    "            while p * 2 + 1 < len_heap:\n",
-    "                left = p*2 + 1\n",
-    "                right = p*2 + 2\n",
-    "\n",
-    "                max_index = left \n",
-    "\n",
-    "                if right < len_heap and nums[right] > nums[left]:\n",
-    "                    max_index = right\n",
-    "                \n",
-    "                if nums[p] < nums[max_index]:\n",
-    "                    nums[p],nums[max_index] = nums[max_index],nums[p]\n",
-    "                    p = max_index\n",
-    "                else:\n",
-    "                    break\n",
-    "\n",
-    "        def build_heap(): \n",
-    "            for i in range(len(nums)//2 - 1, -1, -1):\n",
-    "                maxheapify(i,len(nums))\n",
-    "        \n",
-    "        build_heap()\n",
-    "        for i in range(len(nums),len(nums) - k + 1,-1):\n",
-    "            nums[0],nums[i-1] = nums[i-1],nums[0]\n",
-    "            maxheapify(0,i-1)\n",
-    "        return nums[0]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "思路4\n",
-    "这里就可以用迭代而非递归的方式去做，节约成本，注意用randint，同时还有pivot = random.randint(left,right)。并且我不习惯用randint，所以赋值要格外注意。除了上来nums[left],nums[pivot] = nums[pivot],nums[left] ，把quick转换成我所习惯的形式外，也要把pivot改成left。"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class Solution:\n",
-    "    def findKthLargest(self, nums: List[int], k: int) -> int:\n",
-    "        index = len(nums) - k \n",
-    "        left = 0\n",
-    "        right = len(nums) - 1\n",
-    "        while True:\n",
-    "            if left >= right:\n",
-    "                return nums[left]\n",
-    "            pivot = random.randint(left,right) \n",
-    "            i = left \n",
-    "            j = right\n",
-    "\n",
-    "            nums[left],nums[pivot] = nums[pivot],nums[left]\n",
-    "\n",
-    "            while i < j:\n",
-    "                while i < j and nums[left] <= nums[j]:\n",
-    "                    j -= 1\n",
-    "                while i < j and nums[left] >= nums[i]:\n",
-    "                    i += 1\n",
-    "\n",
-    "                nums[i],nums[j] = nums[j],nums[i]\n",
-    "\n",
-    "            nums[i],nums[left] = nums[left],nums[i]\n",
-    "\n",
-    "            if i < index:\n",
-    "                left = i + 1\n",
-    "            elif i > index:\n",
-    "                right = i - 1\n",
-    "            elif i == index:\n",
-    "                return nums[i]"
+    "### [链接](http://localhost:8888/notebooks/algorithm-pattern-python/data_structure/%E5%A0%86%E7%AC%94%E8%AE%B0.ipynb)\n"
    ]
   }
  ],

basic_algorithm/.ipynb_checkpoints/sort-checkpoint.ipynb

@@ -69,7 +69,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "- 模板 2 的实现"
+    "- 模板 2 的实现(在结果不是符合某个target，而是满足和邻居间的大小关系时，这种做法更为适用,因为middle在满足大小关系时不能被剔除出搜索结果)"
    ]
   },
   {
@@ -127,6 +127,13 @@
     "        return -1"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "例题参见 https://leetcode-cn.com/leetbook/detail/binary-search/"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},