Skip to content

Commit 9bea0ea

Browse files
hiha3456hiha3456
committed
Update
1 parent be11986 commit 9bea0ea

File tree

3 files changed

+114
-127
lines changed

3 files changed

+114
-127
lines changed

‎basic_algorithm/.ipynb_checkpoints/sort-checkpoint.ipynb‎

Lines changed: 67 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -142,7 +142,27 @@
142142
"cell_type": "markdown",
143143
"metadata": {},
144144
"source": [
145-
"归并排序:O(nlogn的时间复杂度)，O(n)的空间复杂度"
145+
"归并排序:O(nlogn的时间复杂度)，O(n)的空间复杂度\n",
146+
"\n",
147+
"1. 迭代法\n",
148+
" ① 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列\n",
149+
" ② 设定两个指针，最初位置分别为两个已经排序序列的起始位置\n",
150+
" ③ 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置\n",
151+
" ④ 重复步骤③直到某一指针到达序列尾\n",
152+
" ⑤ 将另一序列剩下的所有元素直接复制到合并序列尾\n",
153+
"2. 递归法\n",
154+
" ① 将序列每相邻两个数字进行归并操作，形成floor(n/2)个序列，排序后每个序列包含两个元素\n",
155+
" ② 将上述序列再次归并，形成floor(n/4)个序列，每个序列包含四个元素\n",
156+
" ③ 重复步骤②，直到所有元素排序完毕\n",
157+
"\n",
158+
"不管元素在什么情况下都要做这些步骤，所以花销的时间是不变的，所以该算法的最优时间复杂度和最差时间复杂度及平均时间复杂度都是一样的为：O( nlogn )\n",
159+
"\n",
160+
"归并的空间复杂度就是那个临时的数组和递归时压入栈的数据占用的空间：n + logn；所以空间复杂度为: O(n)。\n",
161+
"\n",
162+
"归并排序算法中，归并最后到底都是相邻元素之间的比较交换，并不会发生相同元素的相对位置发生变化，故是稳定性算法。\n",
163+
"稳定排序，外排序（占用额外内存），时间复杂度O(nlogn)\n",
164+
"\n",
165+
"递归需要返回结果用于合并"
146166
]
147167
},
148168
{
@@ -189,14 +209,16 @@
189209
" \n",
190210
"快速排序 的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。\n",
191211
"\n",
192-
"6.1 算法描述\n",
212+
"## 算法描述\n",
193213
"\n",
194214
"快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：\n",
195-
"步骤1：从数列中挑出一个元素，称为 “基准”（pivot ）；\n",
196-
"步骤2：重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；\n",
197-
"步骤3：递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。\n",
215+
"1. 从数列中挑出一个元素，称为 “基准”（pivot ）；\n",
216+
"2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；\n",
217+
"3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。\n",
218+
"\n",
219+
"时间复杂度：最好情况O(n * logn)——Partition函数每次恰好能均分序列，其递归树的深度就为.log2n.+1（.x.表示不大于x的最大整数），即仅需递归log2n次； 最坏情况O（n^2）,每次划分只能将序列分为一个元素与其他元素两部分，这时的快速排序退化为冒泡排序，如果用数画出来，得到的将会是一棵单斜树，也就是说所有所有的节点只有左（右）节点的树；平均时间复杂度O(n*logn)\n",
198220
"\n",
199-
"时间复杂度：最好情况O(n * logn)——Partition函数每次恰好能均分序列，其递归树的深度就为.log2n.+1（.x.表示不大于x的最大整数），即仅需递归log2n次； 最坏情况O（n^2）,每次划分只能将序列分为一个元素与其他元素两部分，这时的快速排序退化为冒泡排序，如果用数画出来，得到的将会是一棵单斜树，也就是说所有所有的节点只有左（右）节点的树；平均时间复杂度O(n*logn)"
221+
"快排由于是原地交换所以没有合并过程 传入的索引是存在的索引（如：0、length-1 等），越界可能导致崩溃"
200222
]
201223
},
202224
{
@@ -215,12 +237,20 @@
215237
" i = left\n",
216238
" j = right\n",
217239
" while i < j:\n",
218-
" while i < j and nums[j] > nums[pivot]:#从右向左找第一个小于x的数\n",
240+
" #先右后左是根据挖坑法的顺序，而等号比较其实是无所谓的,除了不能一个等于号都没有以外（两边相同会造成死循环），一个等于号或者两个都可以，\n",
241+
" #为了方便记忆（我也懒得一个个验证）就用两个等号了。\n",
242+
" #原算法是上边是>下边是<=\n",
243+
" while i < j and nums[j] >= nums[pivot]:#从右向左找第一个小于x的数\n",
244+
" #while i < j and nums[j] > nums[pivot]:#从右向左找第一个小于等于x的数\n",
219245
" j -= 1\n",
220-
" while i < j and nums[i] <= nums[pivot]:#从左向右找第一个大于x的数\n",
246+
" while i < j and nums[i] <= nums[pivot]:#从左向右找第一个大于x的数，因为是大于x的数所以跳过了pivot，相当于把pivot空出\n",
221247
" i += 1\n",
222248
" nums[i], nums[j] = nums[j], nums[i]#两者交换\n",
223-
" nums[pivot], nums[j] = nums[j], nums[pivot]#把pivot放到停止的位置（之前小于pivot的数已经被挖走，此处是空的）\n",
249+
" nums[pivot], nums[j] = nums[j], nums[pivot]#把pivot放到停止的位置（按挖坑法之前小于pivot的数已经被挖走，此处是空的，\n",
250+
" #按交换法该位置就是pivot应该在的位置，且该位置的数一定 <= pivot，所以转换到左边是一定的）\n",
251+
" #i = j 时数一定<= pivot 的原因\n",
252+
" #1. 若j停下了，那一定说明i往右推和j会合的数的就是<= pivot的数\n",
253+
" #2. 若j没停下，最后势必会找到一个<=pivot的数（因为上一轮i,j交换，i指向的位置<=pivot; 若是第一轮，i指向的位置等于pivot）\n",
224254
" quick(left, j - 1)\n",
225255
" quick(j + 1, right)\n",
226256
" return nums\n",
@@ -316,6 +346,33 @@
316346
" heap_sort(nums)\n",
317347
" return nums"
318348
]
349+
},
350+
{
351+
"cell_type": "code",
352+
"execution_count": 3,
353+
"metadata": {},
354+
"outputs": [
355+
{
356+
"name": "stdout",
357+
"output_type": "stream",
358+
"text": [
359+
"10\n",
360+
"9\n",
361+
"8\n",
362+
"7\n",
363+
"6\n",
364+
"5\n",
365+
"4\n",
366+
"3\n",
367+
"2\n",
368+
"1\n"
369+
]
370+
}
371+
],
372+
"source": [
373+
"for i in range(10,0,-1):\n",
374+
" print(i)"
375+
]
319376
}
320377
],
321378
"metadata": {
@@ -334,7 +391,7 @@
334391
"name": "python",
335392
"nbconvert_exporter": "python",
336393
"pygments_lexer": "ipython3",
337-
"version": "3.8.5"
394+
"version": "3.7.0"
338395
}
339396
},
340397
"nbformat": 4,

‎basic_algorithm/sort.ipynb‎

Lines changed: 39 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -142,7 +142,27 @@
142142
"cell_type": "markdown",
143143
"metadata": {},
144144
"source": [
145-
"归并排序:O(nlogn的时间复杂度)，O(n)的空间复杂度"
145+
"归并排序:O(nlogn的时间复杂度)，O(n)的空间复杂度\n",
146+
"\n",
147+
"1. 迭代法\n",
148+
" ① 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列\n",
149+
" ② 设定两个指针，最初位置分别为两个已经排序序列的起始位置\n",
150+
" ③ 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置\n",
151+
" ④ 重复步骤③直到某一指针到达序列尾\n",
152+
" ⑤ 将另一序列剩下的所有元素直接复制到合并序列尾\n",
153+
"2. 递归法\n",
154+
" ① 将序列每相邻两个数字进行归并操作，形成floor(n/2)个序列，排序后每个序列包含两个元素\n",
155+
" ② 将上述序列再次归并，形成floor(n/4)个序列，每个序列包含四个元素\n",
156+
" ③ 重复步骤②，直到所有元素排序完毕\n",
157+
"\n",
158+
"不管元素在什么情况下都要做这些步骤，所以花销的时间是不变的，所以该算法的最优时间复杂度和最差时间复杂度及平均时间复杂度都是一样的为：O( nlogn )\n",
159+
"\n",
160+
"归并的空间复杂度就是那个临时的数组和递归时压入栈的数据占用的空间：n + logn；所以空间复杂度为: O(n)。\n",
161+
"\n",
162+
"归并排序算法中，归并最后到底都是相邻元素之间的比较交换，并不会发生相同元素的相对位置发生变化，故是稳定性算法。\n",
163+
"稳定排序，外排序（占用额外内存），时间复杂度O(nlogn)\n",
164+
"\n",
165+
"递归需要返回结果用于合并"
146166
]
147167
},
148168
{
@@ -189,14 +209,16 @@
189209
" \n",
190210
"快速排序 的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。\n",
191211
"\n",
192-
"6.1 算法描述\n",
212+
"## 算法描述\n",
193213
"\n",
194214
"快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：\n",
195-
"步骤1：从数列中挑出一个元素，称为 “基准”（pivot ）；\n",
196-
"步骤2：重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；\n",
197-
"步骤3：递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。\n",
215+
"1. 从数列中挑出一个元素，称为 “基准”（pivot ）；\n",
216+
"2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；\n",
217+
"3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。\n",
218+
"\n",
219+
"时间复杂度：最好情况O(n * logn)——Partition函数每次恰好能均分序列，其递归树的深度就为.log2n.+1（.x.表示不大于x的最大整数），即仅需递归log2n次； 最坏情况O（n^2）,每次划分只能将序列分为一个元素与其他元素两部分，这时的快速排序退化为冒泡排序，如果用数画出来，得到的将会是一棵单斜树，也就是说所有所有的节点只有左（右）节点的树；平均时间复杂度O(n*logn)\n",
198220
"\n",
199-
"时间复杂度：最好情况O(n * logn)——Partition函数每次恰好能均分序列，其递归树的深度就为.log2n.+1（.x.表示不大于x的最大整数），即仅需递归log2n次； 最坏情况O（n^2）,每次划分只能将序列分为一个元素与其他元素两部分，这时的快速排序退化为冒泡排序，如果用数画出来，得到的将会是一棵单斜树，也就是说所有所有的节点只有左（右）节点的树；平均时间复杂度O(n*logn)"
221+
"快排由于是原地交换所以没有合并过程 传入的索引是存在的索引（如：0、length-1 等），越界可能导致崩溃"
200222
]
201223
},
202224
{
@@ -215,12 +237,20 @@
215237
" i = left\n",
216238
" j = right\n",
217239
" while i < j:\n",
218-
" while i < j and nums[j] > nums[pivot]:#从右向左找第一个小于等于x的数\n",
240+
" #先右后左是根据挖坑法的顺序，而等号比较其实是无所谓的,除了不能一个等于号都没有以外（两边相同会造成死循环），一个等于号或者两个都可以，\n",
241+
" #为了方便记忆（我也懒得一个个验证）就用两个等号了。\n",
242+
" #原算法是上边是>下边是<=\n",
243+
" while i < j and nums[j] >= nums[pivot]:#从右向左找第一个小于x的数\n",
244+
" #while i < j and nums[j] > nums[pivot]:#从右向左找第一个小于等于x的数\n",
219245
" j -= 1\n",
220-
" while i < j and nums[i] <= nums[pivot]:#从左向右找第一个大于x的数\n",
246+
" while i < j and nums[i] <= nums[pivot]:#从左向右找第一个大于x的数，因为是大于x的数所以跳过了pivot，相当于把pivot空出\n",
221247
" i += 1\n",
222248
" nums[i], nums[j] = nums[j], nums[i]#两者交换\n",
223-
" nums[pivot], nums[j] = nums[j], nums[pivot]#把pivot放到停止的位置（之前小于pivot的数已经被挖走，此处是空的）\n",
249+
" nums[pivot], nums[j] = nums[j], nums[pivot]#把pivot放到停止的位置（按挖坑法之前小于pivot的数已经被挖走，此处是空的，\n",
250+
" #按交换法该位置就是pivot应该在的位置，且该位置的数一定 <= pivot，所以转换到左边是一定的）\n",
251+
" #i = j 时数一定<= pivot 的原因\n",
252+
" #1. 若j停下了，那一定说明i往右推和j会合的数的就是<= pivot的数\n",
253+
" #2. 若j没停下，最后势必会找到一个<=pivot的数（因为上一轮i,j交换，i指向的位置<=pivot; 若是第一轮，i指向的位置等于pivot）\n",
224254
" quick(left, j - 1)\n",
225255
" quick(j + 1, right)\n",
226256
" return nums\n",

‎data_structure/二叉树笔记.ipynb‎

Lines changed: 8 additions & 108 deletions
Original file line numberDiff line numberDiff line change
@@ -781,118 +781,14 @@
781781
"cell_type": "markdown",
782782
"metadata": {},
783783
"source": [
784-
"### 归并排序"
784+
"### 归并排序(见文件sort)"
785785
]
786786
},
787787
{
788788
"cell_type": "markdown",
789789
"metadata": {},
790790
"source": [
791-
"2.1 迭代法\n",
792-
" ① 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列\n",
793-
" ② 设定两个指针，最初位置分别为两个已经排序序列的起始位置\n",
794-
" ③ 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置\n",
795-
" ④ 重复步骤③直到某一指针到达序列尾\n",
796-
" ⑤ 将另一序列剩下的所有元素直接复制到合并序列尾\n",
797-
"2.2 递归法\n",
798-
" ① 将序列每相邻两个数字进行归并操作，形成floor(n/2)个序列，排序后每个序列包含两个元素\n",
799-
" ② 将上述序列再次归并，形成floor(n/4)个序列，每个序列包含四个元素\n",
800-
" ③ 重复步骤②，直到所有元素排序完毕\n",
801-
"\n",
802-
"不管元素在什么情况下都要做这些步骤，所以花销的时间是不变的，所以该算法的最优时间复杂度和最差时间复杂度及平均时间复杂度都是一样的为：O( nlogn )\n",
803-
"\n",
804-
"归并的空间复杂度就是那个临时的数组和递归时压入栈的数据占用的空间：n + logn；所以空间复杂度为: O(n)。\n",
805-
"\n",
806-
"归并排序算法中，归并最后到底都是相邻元素之间的比较交换，并不会发生相同元素的相对位置发生变化，故是稳定性算法。\n",
807-
"稳定排序，外排序（占用额外内存），时间复杂度O(nlogn)\n",
808-
"\n",
809-
"递归需要返回结果用于合并"
810-
]
811-
},
812-
{
813-
"cell_type": "code",
814-
"execution_count": null,
815-
"metadata": {},
816-
"outputs": [],
817-
"source": [
818-
"class Solution:\n",
819-
" def sortArray(self, nums: List[int]) -> List[int]:\n",
820-
" def merge_sort(nums):\n",
821-
" if len(nums) <= 1:\n",
822-
" return nums\n",
823-
" mid = len(nums) // 2\n",
824-
" # 分\n",
825-
" left = merge_sort(nums[:mid])\n",
826-
" right = merge_sort(nums[mid:])\n",
827-
" # 合并\n",
828-
" return merge(left, right)\n",
829-
"\n",
830-
"\n",
831-
" def merge(left, right):\n",
832-
" res = []\n",
833-
" i = 0\n",
834-
" j = 0\n",
835-
" while i < len(left) and j < len(right):\n",
836-
" if left[i] <= right[j]:\n",
837-
" res.append(left[i])\n",
838-
" i += 1\n",
839-
" else:\n",
840-
" res.append(right[j])\n",
841-
" j += 1\n",
842-
" res += left[i:]\n",
843-
" res += right[j:]\n",
844-
" return res\n",
845-
" return merge_sort(nums)"
846-
]
847-
},
848-
{
849-
"cell_type": "markdown",
850-
"metadata": {},
851-
"source": [
852-
"### 快速排序（分冶法自顶而下）"
853-
]
854-
},
855-
{
856-
"cell_type": "markdown",
857-
"metadata": {},
858-
"source": [
859-
"平均时间复杂度：O(NlogN)\n",
860-
"最佳时间复杂度：O(NlogN)\n",
861-
"最差时间复杂度：O(N^2)\n",
862-
"空间复杂度：根据实现方式的不同而不同。\n",
863-
"最好的情况是枢纽元选取得当，每次都能均匀的划分序列。 时间复杂度O(nlogn)\n",
864-
"最坏情况是枢纽元为最大或者最小数字，那么所有数都划分到一个序列去了 时间复杂度为O(n^2)\n",
865-
"\n",
866-
"快排由于是原地交换所以没有合并过程 传入的索引是存在的索引（如：0、length-1 等），越界可能导致崩溃"
867-
]
868-
},
869-
{
870-
"cell_type": "code",
871-
"execution_count": null,
872-
"metadata": {},
873-
"outputs": [],
874-
"source": [
875-
"def quick_sort(nums):\n",
876-
" n = len(nums)\n",
877-
"\n",
878-
" def quick(left, right):\n",
879-
" if left >= right:#递归到左和右一样，直接退出\n",
880-
" return nums\n",
881-
" pivot = left\n",
882-
" i = left\n",
883-
" j = right\n",
884-
" while i < j:\n",
885-
" while i < j and nums[j] > nums[pivot]:#从右向左找第一个小于等于x的数\n",
886-
" j -= 1\n",
887-
" while i < j and nums[i] <= nums[pivot]:#从左向右找第一个大于x的数\n",
888-
" i += 1\n",
889-
" nums[i], nums[j] = nums[j], nums[i]#两者交换\n",
890-
" nums[pivot], nums[j] = nums[j], nums[pivot]#把pivot放到停止的位置（之前小于pivot的数已经被挖走，此处是空的）\n",
891-
" quick(left, j - 1)\n",
892-
" quick(j + 1, right)\n",
893-
" return nums\n",
894-
"\n",
895-
" return quick(0, n - 1)"
791+
"### 快速排序（分冶法自顶而下）（见文件sort）"
896792
]
897793
},
898794
{
@@ -920,7 +816,7 @@
920816
" #/\n",
921817
" def dfs(root):\n",
922818
" if root is None:\n",
923-
" return float('-inf')\n",
819+
" return 0\n",
924820
" \n",
925821
" #计算左边分支最大值，左边分支如果为负数还不如不选择\n",
926822
" leftMax = max(0, dfs(root.left))\n",
@@ -958,7 +854,11 @@
958854
"\n",
959855
"代码中使用 maxPath 来记录全局最大路径和。\n",
960856
"\n",
961-
"所要做的就是递归，递归时记录好全局最大和，返回联络最大和。"
857+
"所要做的就是递归，递归时记录好全局最大和，返回联络最大和。\n",
858+
"\n",
859+
"https://leetcode-cn.com/problems/binary-tree-maximum-path-sum/solution/er-cha-shu-zhong-de-zui-da-lu-jing-he-by-ikaruga/\n",
860+
"\n",
861+
"https://leetcode-cn.com/problems/binary-tree-maximum-path-sum/solution/shou-hui-tu-jie-hen-you-ya-de-yi-dao-dfsti-by-hyj8/"
962862
]
963863
},
964864
{

0 commit comments

Comments
 (0)