A. 抽象数据类型

一、接口与实现

1. 抽象数据类型(Abstract Data Type) = 数据模型 + 定义在该模型上的一组操作
   · 抽象定义——外部的逻辑特性——操作&语义
   · 一种定义——不考虑时间复杂度——不涉及数据的存储方式
2. 数据结构(Data Structure) = 基于某种特定语言，实现ADT的一整套算法
   · 具体实现——内部的表示与实现——完整的算法
   · 多种实现——与复杂度密切相关——要考虑数据的具体存储机制
3. Application = Interface * Implementation ( 在数据结构的具体实现与实际应用之间，ADT分工与接口制定了统一的规范)

二、从数组到向量

1. 线性数组(linear array)：元素各由编号唯一指代，并可直接访问
2. 向量是数组的抽象与泛化，由一组元素按线性次序封装而成
3. 循秩访问(call-by-rank)：各元素与[0,n)内的秩一一对应
4. 向量ADT接口（search–rank最大且排在最后的元素）
   

三、模板类

1. 构造 + 析构 = 重载
2. 基于复制的构造
   

四、作业

1. Which of the following options is correct:下列说法中正确的是：The same abstract data type may be implemented using multiple data structures. 同一个抽象数据类型可能用多种数据结构实现。
2. On an initially empty vector, what’s the result of executing insert(0, 2), insert(1, 6), put(0, 1), remove(1) and insert(0, 7):在一个初始为空的向量上依次执行：insert(0, 2), insert(1, 6), put(0, 1), remove(1), insert(0, 7) 后的结果是：{7,1}
3. The following code is a variant of the vector copy code with the same semantics. The space should be filled with: 以下代码是向量复制代码的一个变体且语义与其相同，空格处应填入的内容为：–hi
   

B. 可扩容向量

一、静态空间管理

1. 上溢(overflow)：_elem[]不足以存放所有元素
2. 下溢(underflow)：_elem[]中的元素寥寥无几
3. 装填因子(load factor)：λ = _size/_capacity << 50%

二、可扩充向量

1. 容量加倍策略
   
2. 容量递增策略
   T*oldElem = _elem; _elem = New T[_capacity += INCREMENT]
3. 对比
   

三、平均复杂度

1. 平均复杂度(average complexity,期望复杂度)：根据各种操作出现概率的分布，将对应的成本加权平均
   · 各种可能的操作，作为独立事件分别考察
   · 割裂了操作之间的相关性和连贯性
   · 不能准确地评判数据结构和算法的真实性能
2. 分摊复杂度(amortized complexity)：连续实施的足够多次操作，所需总体成本摊还至单次操作
   · 从实际可行的角度，对一系列操作做整体考量
   · 忠实刻画可能出现的操作序列
   · 精准地评判数据结构和算法的真实性能

四、作业

1. On an empty vector with an initial maximum capacity of 10, the load factor after executing insert(0, 2), insert(1, 6), put(0, 1), remove(1) and insert(0, 7) is: 在一个初始最大容量为10的空向量上依次执行：insert(0, 2), insert(1, 6), put(0, 1), remove(1), insert(0, 7) 后的装填因子是：20%
2. Is it possible to replace:是否可以将视频里向量扩容代码中的：for (int i = 0; i < _size; i++) _elem[i] = oldElem[i];in the vector expansion code in the video with: 替代为：memcpy(_elem, oldElem, _size * sizeof(T));
   P.S.This question involves the relevant knowledge of C++（ P.S.本题涉及C++的相关知识）No, because whether the latter can achieve the purpose is related to element type T. 否，因为后者能否达到目的与元素类型T有关。
3. Using the expansion strategy of appending fixed memory space each time, the amortized time complexity of inserting element of vector of size n is: 采用每次追加固定内存空间的扩容策略，规模为n的向量插入元素的分摊时间复杂度为：Θ(n)
4. By using two expansion strategies, one for each additional fixed memory space and one for double up memory space, the amortized time complexity of inserting elements of vector of size n is: 分别采用每次追加固定内存空间和每次内存空间翻倍两种扩容策略，规模为n的向量插入元素的分摊时间复杂度分别为：Θ(n),Θ(1)
5. With regard to the average complexity and the amortized complexity, which of the following statement is wrong: 关于平均复杂度和分摊复杂度，下列说法中错误的是：Amortized complexity results in lower than average complexity 分摊复杂度得到的结果比平均复杂度低

C. 无序向量

一、基本操作

• 元素访问（重载下标操作符"[]"）
  
• 插入（先判断是否需扩容，执行上自后向前）
• 区间删除（自前向后进行前移，若有必要则缩容）
• 单元素删除：O(n²)

二、查找

1. 无序向量(判等器)：T为可判等的基本数据类型，或已重载的操作符"==“或”!="
2. 有序向量(比较器)：T为可比较的基本数据类型，或已重载的操作符"<“或”>"
3. 顺序查找：输入敏感(input-sensitive)：最好O(1)，最差O(n)

三、去重

1. 唯一化：算法 (应用案例)网络搜索的局部结果经过去重操作，汇总为最终报告
2. 唯一化：正确性
   · 不变性：在当前元素V[i]的前缀V[0,I]中，各元素彼此互异
   · 单调性：随着while迭代，(前缀)单调非降，增至_size；(后缀)单调下降，减至0
3. 唯一化：复杂度O(ⁿ)
4. Deduplicate()
   

四、遍历

1. 函数指针，只读局部性修改
   
2. 函数对象，全局性修改更便捷
   
3. 实例

五、作业

1. What is the meaning of the return value of T & Vector::operator[](Rank r) { return _elem[r]; }? T & Vector::operator[](Rank r) { return _elem[r]; } 中的返回值T&是什么意义？This is a reference to the type T because its return value can be used as an left value 这是类型T的引用，使用它是因为返回值可以作为左值
2. What happens if the FOR loop in the insert() function changes to the following form？for (int i = r; i < _size; i++) _elem[i + 1] = _elem[i]; Overwrite all elements in the original vector with rank greater than r 会覆盖原向量中秩大于r的所有元素
3. Why the suffix of the deleted element is moved from front to back in the interval deletion algorithm remove(lo, hi)? 为什么区间删除算法remove(lo, hi)中要从前向后移动被删除元素的后缀？Otherwise it may cover some elements 否则可能会覆盖部分元素
4. For the deduplicate() algorithm, the worst-case time complexity for the vector scale n is: 对于deduplicate()算法，向量规模为n时的最坏时间复杂度为： Θ(n²)
5. As a function object class XXX, which of the following member functions must be explicitly defined: 作为一个函数对象的类XXX，它必须显式定义以下哪个成员函数：operator()()
   P.S. 函数对象是：如果一个类将()运算符重载为成员函数，这个类就称为函数对象类，这个类的对象就是函数对象。函数对象是一个对象，但是使用的形式看起来像函数调用，实际上也执行了函数调用，因而得名。 对于函数对象来说，()是用于执行函数调用的操作符,也就是说必须重载（）运算符

D1. 有序向量:唯一化

一、有序性

1. 在有序/无序序列中，任何/总有一对相邻元素顺序/逆序
2. 相邻逆序对的数目，在一定程度上度量向量的紊乱程度

二、低效版

1. 唯一化：在有序向量中，重复的元素必然相互紧邻构成一个区间，每一个区间只需保留单个元素即可
2. 复杂度：O(n²)
3. 低效根源：同一元素可作为被删除元素的后继多次前移

三、高效版

1. 实现：将同一元素作为一个区间，不同元素覆盖在其第一个元素后
2. 复杂度：O(n)
   

四、作业

1. The return value of the disordered() algorithm is: disordered()算法的返回值是：The number of adjacent inversion 相邻逆序对个数
2. Repeating elements in an ordered vector 有序向量中的重复元素 All of them are adjacent distribution 必定全部紧邻分布
3. For vectors of size n, the worst-case time complexity of the inefficient version of uniquify() is: 对于规模为n的向量，低效版uniquify()的最坏时间复杂度为：Θ(n²)
4. Why doesn’t the algorithm need to call remove() to delete an element? 为什么该算法中不需要调用remove()进行元素删除？Duplicate elements are ignored directly 重复元素被直接忽略了
5. For vectors of size n, the worst-case time complexity of the efficient version of uniquify() is: 对于规模为n的向量，高效版uniquify()的最坏时间复杂度为：Θ(n)

D2. 有序向量:二分查找(A)

一、概述

1. 可能情况：目标元素不存在，存在多个元素
2. 语义约定：在有序区间V[lo,hi)中，确定不大于目标元素e的最后一个元素（秩）
   · 若 -∞ < e < V[lo]，则返回lo-1（左侧哨兵）
   · 若 V[hi-1] < e < +∞，则返回hi-1（末元素 = 右侧哨兵左邻）

二、原理

以任一元素 S[mi] 为界都可将待查找区间 [lo,hi) 分为三部分，且 S[lo,hi) <= S[mi] <= S(mi,hi)，因此只需任取x = S[mi]

三、实现

1. 代码
   
2. 复杂度：线性递归 T(n) = T(n/2) + O(1) = O(nlogn)
3. 递归跟踪：轴点总能取到中点，递归深度O(nlogn)，各递归实例仅耗时O(1)
4. 成功、失败时的平均查找长度均为O(1.5logn)

四、作业

1. For a vector of size n, the return value of find() on a search failure is: 对于规模为n的向量，查找失败时find()的返回值是：-1
2. Insert the element e in the ordered vector V and keep it in order, which of the following code is correct: 在有序向量V中插入元素e并使之保持有序，下列代码正确的是:V.insert(V.search(e) + 1, e);
3. In binsearch(e, lo, hi) version A, if V[mi] < e, then the next search range is: 在binsearch(e, lo, hi)版本A中，若V[mi] < e，则下一步的查找范围是：V(mi, hi)
4. Which of the following expressions is equivalent to Rank mi = (lo + hi) >> 1 ? (lo and hi are non-negative) Rank mi = (lo + hi) >> 1 等效于下列哪个表达式?（lo和hi非负）Rank mi = (lo + hi) / 2
5. V={2, 3, 5, 7, 11, 13, 17}. How many comparisons V.search(16, 0, 7) need to make? V={2, 3, 5, 7, 11, 13, 17}。V.search(16, 0, 7)需要进行多少次比较？5
6. V1={2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61}
   V2={1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18}
   The search length of searching 43 in V1 is x, then the search length of searching 14 in V2 is: 在V1中查找43的查找长度是x，则在V2中查找14的查找长度为： X（X = 7）

D3. 有序向量:Fib查找

一、思路与原理

1. 问题：二分查找转向左、右分支前的关键码比较次数不等，而递归深度却相同
2. 思路：通过递归深度的不均衡对转向成本的不均衡做补偿，平均查找长度应能进一步缩短

二、实现

1. 代码
   
2. 注意点：
   

三、作业

1. What is the difference between the fibSearch() algorithm and binSearch() algorithm? fibSearch()算法与binSearch()有什么区别？ There are different ways to choose the axis point mi 二者选取轴点mi的方式不同
2. V={1, 2, 3, 4, 5, 6, 7}, using Fibonacci to find element 1 in V, the element selected as the pivot point mi is:V={1, 2, 3, 4, 5, 6, 7}，在V中用Fibonacci查找元素1，被选取为轴点mi的元素依次是：5,3,2,1
3. Why is the search process for binSearch() version A not balanced? 为什么说binSearch()版本A的查找过程并不平衡?Because the number of comparisons required for the left and right branches is not equal 因为向左、向右两个分支所需要的比较次数不相等

D4-5. 有序向量:二分查找(B/C)

一、版本B

1. 改进思路：将左右分支转向代价不平衡的问题，用划分2个分支方向解决
2. mi取作中点：e < x,则深入左侧的[lo,mi)；x <= e,则深入右侧的[mi,hi)
3. 相对于版本A，最好（怀）情况更坏（好），整体性能更稳定
4. 仍存在的问题及解决方案：目标元素不存在、存在多个元素
   

二、版本C

• 在算法执行过程中的任意时刻
  1. A[lo-1]：总是(截止当前已确认的)不大于e的最大者(m)
  2. A[hi]：总是(截止当前已确认的)大于e的最小者(M)
• 当算法终止时，A[lo-1] = A[hi-1]即是（全局）不大于e的最大者
• 代码实现
  

三、作业

1. For a vector of size n, the optimal time complexity for binary search versions A and B is:对于规模为n的向量，二分查找版本A和B的最优时间复杂度分别为：Θ(1)，Θ(log₂n)
2. For the search() interface, what we are going to return when there is more than one target element in the vector: 对于search()接口，我们约定当向量中存在多个目标元素时返回其中：Rank maximun秩最大者
3. For binary search version C, what is the next search range when e<V[mi] is not established: 对于二分查找版本C，当e<V[mi]不成立时下一步的查找范围是：V(mi, hi)
4. For binary search version C, when the length of the search interval is reduced to 0, V[lo] is: 对于二分查找版本C，当查找区间的长度缩小为0时，V[lo]是：min{ 0 ≤ r < n | e < V[r] }

D6. 插值查找(Interpolation Search)

一、原理与算法

1. 适用情况：已知有序向量中各元素随机分布的规律（eg.独立且均匀的随机分布）
2. 轴点mi的选取
   

二、性能

1. 最坏：O(n)
2. 平均：每经一次比较，待查找区间宽度由n缩至√n，意味着有效字长logn减半
   · 插值查找 = 在字长意义上的折半查找
   · 二分查找 = 在字长意义上的顺序查找

三、综合评价

• 缺点：
  · 须引入乘法、除法运算
  · 易受小扰动的干扰和“蒙骗”
• 实际可行方法：
  · 大规模：插值查找
  · 中规模：二分查找(折半查找)
  · 小规模：顺序查找

四、作业

1. If the distribution of elements in an (ordered) vector satisfies an independent uniform distribution (before sorting), the average time complexity of the interpolation search is:如果（有序）向量中元素的分布满足独立均匀分布（排序前），插值查找的平均时间复杂度为：O(log logn)
2. Searching for search elements 7 with interpolation in the vector V={2, 3, 5, 7, 11, 13, 17, 19, 23}在向量V={2, 3, 5, 7, 11, 13, 17, 19, 23}中用插值查找搜索元素7。Guess the pivot point mi 猜测的轴点mi 1 （ 0 + (8-0) * (7-2) / (23-2) 取整）

E. 起泡排序

复杂度：Ω(nlogn) – Θ(n²)

一、排序算法

1. 起泡排序：bubbleSort
2. 选择排序：selectionSort
3. 归并排序：mergeSort
4. 堆排序：heapSort
5. 快速排序：quickSort
6. 希尔排序：shellSort

二、三个版本

• 版本：基本版、提前终止版、跳跃版
  
• 正确性
  1. Loop Invariant(循环不变式)：经k趟扫描交换后，最大的k个元素必然到位
  2. Convergence(汇集)：经k趟扫描交换后，问题规模缩减至n-k
  3. Correctness(Correctness)：经k趟扫描后，算法必然终止，且能给出正确解答
• 综合评价
  1. 时间效率：最好O(1)，最坏O(n²)
  2. 算法稳定性：重复元素在输入、输出序列中的相对次序保持不变
  · 经分别与其他元素的交换，二者相互接近至相邻
  · 在后续扫描交换中，二者因逆序二交换位置

三、作业

1. V={7, 2, 3, 11, 17, 5, 19, 13} After two scan exchange of V, V[6] = V={7, 2, 3, 11, 17, 5, 19, 13}，对V进行两次扫描交换后V[6] = 17 （两次扫描倒数2个数字归位）
2. Which situation will the improved blistering order will end prematurely ? 经改进的起泡排序在什么情况下会提前结束？The number of scan conversions completed = The number of scan switching parameters for the actual element exchange + 1 完成的扫描交换趟数 = 实际发生元素交换的扫描交换趟数 + 1
3. Try the following algorithm to sort V={19, 17, 23}: 试用以下算法对V={19, 17, 23}排序：
   ①Sort by units at first 1. 先按个位排序
   ②On the basis of the previous step, sort again by tens 2. 在上一步基础上，再按十位排序
   Is this algorithm correct? 这个算法的是否正确？
   If the sorting algorithm used in step 2 is stable, then correct 若第2步用的排序算法是稳定的，则正确
   解析：If step 2 is not stable, the possible situation is: {19, 17, 23} -> {23, 17, 19} -> {19, 17, 23}。若第2步不稳定，可能的情况是：{19, 17, 23} -> {23, 17, 19} -> {19, 17, 23}。
   The above algorithm is called “radix sort” and is applicable to the case where the sorted element can be divided into several domains. Its correctness depends on the stability when sorting each domain separately.以上算法称为“基数排序（radix sort）“，适用于被排序元素可分为若干个域的情况，它的正确性要依赖于对每个域分别排序时的稳定性。

F. 归并排序

一、原理

1. 分而治之，向量与列表通用
2. 方法：
   · 序列一分为二O(1)
   · 子序列递归排序 2*T(n/2)
   · 合并有序子序列 O(n)
3. 运行成本：O(nlogn)

二、二路归并2-way merge

1. 有序序列，合二为一，保持有序：S[lo,hi) = S[lo,mi) + S[mi,hi)
   
2. 实现
   
3. 运行时间
   · 最初：j = 0; k = 0
   · 最终：j = lb; k = lc
   · 累计：j + k = n
4. 最坏情况：O(nlogn)

三、综合评价

• 优点：
  1. 性能最优的排序算法：最坏情况下O(nlogn)
  2. 完全顺序访问，不需随机读写——尤其适用于类别之类的序列、磁带之类的设备
  3. 保证稳定——出现雷同元素时，左侧子序列优先
  4. 扩展性极佳，适宜外部排序——海量网页搜索结果的归并
  5. 易于并行化
• 缺点：
  1. 需要对等规模的辅助空间
  2. 即使输入完全(或接近)有序，仍需Ω(nlogn)时间

四、作业

1. What is the solution to the recurrence formula T(n) = 2T(n/2) + O(n)? Which of the O(n) items represent? 归并排序时间复杂度的递推公式T(n) = 2T(n/2) + O(n)的解是什么？其中O(n)项代表什么？O(nlog₂n), time for merging two sorted subvectors O(nlog₂n), 归并两个已排序子向量的时间
2. The two-way merger of {2, 5, 7} and {3, 11, 13} is performed by comparing: 对{2, 5, 7}和{3, 11, 13}进行二路归并，执行的元素比较依次是：2 and 3, 5 and 3, 5 and 11, 7 and 11 2与3、5与3、5与11、7与11
3. For vectors of size n, the optimal and worst-case time complexity for merge sorting is: 对于规模为n的向量，归并排序的最优、最坏时间复杂度分别为：Θ(nlog₂n)，Θ(nlog₂n)

G. 位图/Bitmap

一、结构

1. 适用于有限整数集
2. 结构
   
3. 实现：O(1)

二、应用

1. 小集合+大数据
2. 质数筛选算法（埃拉托色尼Eratosthenes筛选法）

三、快速初始化

1. Bitmap构造仍需O(n)
2. 结构：校验环Hopcroft，1974

向量-测验

1. By using two expansion strategies, one for each additional fixed memory space and one for double up memory space, the amortized time complexity of inserting elements of vector of size n is: 分别采用每次追加固定内存空间和每次内存空间翻倍两种扩容策略，规模为n的向量插入元素的分摊时间复杂度分别为：Θ(n),Θ(1)
2. Insert the element e in the ordered vector V and keep it in order, which of the following code is correct: 在有序向量V中插入元素e并使之保持有序，下列代码正确的是:V.insert(V.search(e) + 1, e);
3. The binary search for “version C” is extracted as follows:二分查找“版本C”摘录如下：The vector V={2, 3, 5, 7, 11, 13, 17, 19} is used to find the target element 16 in V. The elements that have been compared with the target element in the whole process are:向量V={2, 3, 5, 7, 11, 13, 17, 19}，在V中使用它查找目标元素16，整个过程中与目标元素发生过比较的元素依次为：11, 17, 13
   
4. The binary search for “version C” is extracted as follows:二分查找“版本C”摘录如下：When there are multiple elements to be searched in the array A, the return value of the function:当数组A中有多个待查找元素e时，函数的返回值为：Return the element whose rank is biggest返回秩最大者
   
5. The following function is a recursive version of the binary search:以下函数是二分查找的递归版：For a vector of size n, the time and space complexity of the recursive version and the iterated version learned in class are: 对于规模为n的向量，该递归版的时间、空间复杂度和课堂上所学的迭代版的时间、空间复杂度分别是：O(log₂n)，O(log₂n)；O(log₂n)，O(1)
   
   【解】The Implementation process of the recursive version is similar to the iterative version, with the same time complexity, but the space complexity of the recursive version is equal to the maximum recursion depth, which is Θ(log₂n), and the iteration version uses only constant unit aids space. 该递归版与迭代版执行流程相似，时间复杂度相同，但是递归版的空间复杂度等于最大递归深度，在此处即Θ(log₂n)，而迭代版只用了常数单位的辅助空间
6. The vector V={1, 2, 3, 4, 5, 6, 7}, uses the Fibonacci search to find the target element 1 in V, the elements selected as the pivot mi are: 向量V={1, 2, 3, 4, 5, 6, 7}，在V中用斐波那契查找查找目标元素1，被选取为轴点mi的元素依次是：5,3,2,1
7. The two-way merger of {2, 5, 7} and {3, 11, 13} is performed by comparing: 对{2, 5, 7}和{3, 11, 13}进行二路归并，执行的元素比较依次是：2 and 3, 5 and 3, 5 and 11, 7and 11 2与3、5与3、5与11、7与11
8. In any scanning exchange of bubbling ordering, if the last exchange is to swap elements X > Y for Y < X, then: 在起泡排序的任何一趟扫描交换过程中，若最后一次交换是将元素X > Y交换为Y < X，则此后：X must be in place while Y is not necessarily X必然就位，而Y未必
9. On an initially empty vector, what’s the answer after executing: insert(0, 2), insert(1, 6), put(0, 1), remove(1), insert(0, 7) 在一个初始为空的向量上依次执行：insert(0, 2), insert(1, 6), put(0, 1), remove(1), insert(0, 7) 后的结果是：{7, 1}
10. The following code implements interval deletion of vectors by continuously deleting individual elements: 以下代码通过不断删除单个元素实现向量的区间删除：The overloaded function remove(Rank r) completes the operation of deleting a single element, and its time complexity is proportional to the number of succeeding elements of the deleted element. For vectors of size n, the worst-case complexity of this interval deletion algorithm is:其中重载函数remove(Rank r)完成删除单个元素的操作，其时间复杂度正比于被删除元素的后继个数。 对于规模为n的向量，该区间删除算法的最坏时间复杂度为：O(n²)
    【解】The worst case is to delete the entire vector. Every deletion of an element requires its successor to be moved. Therefore, the total time complexity is (n-1)+(n-2)+…+1=O(n²) 最坏情况是删除整个向量，每删除一个元素，它的后继都需要被移动，故总的时间复杂度为(n-1)+(n-2)+…+1=O(n²)

【笔记】第2章 向量相关推荐

1. 机器学习理论《统计学习方法》学习笔记：第二章 感知机

   <统计学习方法>学习笔记:第二章 感知机 2 感知机 2.1 感知机模型 2.2 感知机学习策略 2.2.1 数据的线性可分性 2.2.2 感知机学习策略 2.3 感知机学习算法 2.3. ...

2. 吴恩达机器学习学习笔记第七章：逻辑回归

   分类Classification分为正类和负类 (规定谁是正谁是负无所谓) 吴恩达老师举例几个例子:判断邮箱是否是垃圾邮箱 一个在线交易是否是诈骗 一个肿瘤是良性的还是恶性 如果我们用之前学习的lin ...

3. Machine Learning in Action 读书笔记---第5章 Logistic回归

   Machine Learning in Action 读书笔记 第5章 Logistic回归 文章目录 Machine Learning in Action 读书笔记 一.Logistic回归 1.L ...

4. Machine Learning with Python Cookbook 学习笔记 第8章

   Chapter 8. Handling Images 前言 本笔记是针对人工智能典型算法的课程中Machine Learning with Python Cookbook的学习笔记 学习的实战代码都放 ...

5. 计算机网络（第7版）谢希仁著 学习笔记 第四章网络层

   计算机网络(第7版)谢希仁著 学习笔记 第四章网络层 第四章 网络层 4.3划分子网和构造超网 p134 4.3.1划分子网 4.3.2使用子网时分组的转发 4.3.3无分类编址CIDR(构建超网) ...

6. 李弘毅机器学习笔记：第一章

   李弘毅机器学习笔记:第一章 机器学习介绍 机器学习相关的技术 监督学习 半监督学习 迁移学习 无监督学习 监督学习中的结构化学习 强化学习 小贴士 机器学习介绍 这门课,我们预期可以学到什么呢?我想多 ...

7. Machine Learning in Action 读书笔记---第4章 基于概率论的分类方法：朴素贝叶斯

   Machine Learning in Action 读书笔记 第4章 基于概率论的分类方法:朴素贝叶斯 文章目录 Machine Learning in Action 读书笔记 一.基于贝叶斯决策理 ...

8. 『RNN 监督序列标注』笔记-第一/二章 监督序列标注

   『RNN 监督序列标注』笔记-第一/二章 监督序列标注 监督序列标注(Supervised Sequence Labeling)与传统的监督模式分类(supervised pattern classi ...

9. Python快速编程入门#学习笔记03# |第二章 ：Python基础（代码格式、标识符关键字、变量和数据类型、数字类型以及运算符）

   全文目录 ==先导知识== 学习目标: 2.1 代码格式 2.1.1 注释 2.1.2 缩进 2.1.3 语句换行 2.2 标识符和关键字 2.2.1 标识符 2.2.2 关键字 2.3 变量和数据类 ...

10. Machine Learning with Python Cookbook 学习笔记 第9章

    Chapter 9. Dimensionality Reduction Using Feature Extraction 前言 本笔记是针对人工智能典型算法的课程中Machine Learning w ...

最新文章

1. Haar Adaboost 视频车辆检测代码和样本
2. ios:CGContextRef 渲染中文问题
3. jquery基础总结
4. hdu 5340(manacher+枚举)
5. mysql在cmd命令行下的相关操作
6. Java读取指定目录下的所有文件名
7. python3 Xml操作
8. github 和git_Google编码文档：Git和GitHub
9. jvm面试 -- 谈谈ClassLoader ，ClassLoader的双亲委派机制 ， loadClass和forName的区别
10. 3风扇声音怎么调小_美的风扇价格表
11. 第三章EF的基本使用 EF数据实体模型的更新
12. JavaScript 函数 对象 数组
13. 3-4 掘金小册学习
14. c语言背包问题非递归算法,数据结构基础 背包问题（一） 之 非递归解
15. echarts没有数据时显示暂无数据
16. 哈夫曼编码C++实现
17. 组队学习-数据采集-八爪鱼实操＆使用感想
18. AlertManager实现webhook告警（使用Postman测试）
19. 电脑重装系统后黑屏怎么解决
20. revit 二次开发 链接CAD文件读取

热门文章

1. 数据结构-六度空间（模拟六度分隔理论）
2. 选择正规的资质好的期货公司开户
3. 01-Sass 环境搭建与基本语法
4. 香港服务器哪家好?香港机房前十排名
5. 发卡行 收单行 收单
6. img图片在父元素中居中的方法
7. 谷歌学术搜索技巧，命令搜索
8. office高级应用与python综合案例教程_《office高级应用案例教程.ppt
9. 关于赛马的问题，25匹赛出前3名或者前5名
10. Sharding-JDBC分布式事务总结（四）之BASE事务（Seat框架中——AT模式的介绍以及理解）