算法导论-学习笔记与进度

2

算法导论 阅读进度

第一部分 基础知识

第一章 计算中算法的角色 Done

1.1 算法

  • 输入与输出
  • 算法可以解决哪些问题
  • 数据结构
  • 技术
  • 一些比较难的问题

1.2 作为一种技术的算法

  • 效率
  • 算法和其他技术

第二章 算法入门 Done

2.1 插入排序

伪代码如下:

INSERTION_SORT(A)
for j = 2 to length[A]
    do key = A[j]
       i = j-1
       // 将其与已经排好序的数组进行挨个比较 
       while i>0 and A[i] > key
           do A[i+1] = A[i]
              i = i-1
       A[i+1] = key

原理

其实就是在每次进入一个元素key后,将其与已经排好序的序列进行比较,如果key值小于序列的第一个值(默认为从小到大排序),那么就表明该key应该置入这个序列当中,并且将比较过的元素自动向后移动,以腾出空间放置key。最后将key值置入空位中。

现实中就是在接牌时,插入和调整扑克牌顺序的问题了,算法复杂度为O(n^2)

插入排序采用的是增量方法(incremental),采用分治法的合并排序时间复杂度为O(nlgn)

分治法
- 分解
- 解决
- 合并

主要在于合并算法MERGE(A, p, q, r)
伪代码如下:

MERGE(A, p, q, r)
n1 = q-p+1
n2 = r-q
for i = 1 to n1
    do L[i] = A[p+i-1]
for j = 1 to n2
    do R[j] = A[q+j]
L[n1+1] = -oo
R[n2+1] = -oo
i = j = 1
for k = p to r
    do if L[i] <= R[j]
            then A[k] = L[i]
                i = i+1        
        else
            A[k] = R[j]
            j = j+1

原理

首先将输入数组分割,然后在对分割后的数组进行一一比较,如果L的元素小,就将其输出至目的数组A,如果R小,则输出R至A.

此时MERGE-SORT算法就清晰了,如果将一个数组通过递归不断将其分割,最终分割为每个数组只有一个元素,那么使用MERGE时,就能够将此二元素排序,然后对4元素排序,然后是8元素....
伪代码如下:

MERGE-SORT(A, p, r)
if p<r
    then q = (p+r)/2
        MERGE-SORT(A, p ,q)
        MERGE-SORT(A, q+1, r)
        MERGE(A, p , q, r)

冒泡排序
伪代码如下:

BUBBLE-SORT(A)
for i = 1 to length[A]
    do for j = length[A] downto i+1
            do if A[j] < A[j-1]
               then    exchange A[j], A[j-1]

通过不断交换相邻的两个反序元素达到排序的目的,时间复杂度为O(n^2)
1----n-1
2----n-2
3----n-4
....
n-1----1

1+2+3+4+....+n = n(n+1)/2,所以时间复杂度为O(n^2)

第三章 函数的增长 Done

第四章 递归 Done

递归式 T(n) = aT(n/b) + f(n), 其中a>=1, b>1, f(n) 是给定函数

4.1 代换法

  • 猜测解的形式
  • 用数学归纳法找出真正有效的常数

4.2 递归树方法

仔细画出递归树

4.3 主方法

是求解递归式T(n)的食谱方法。
主方法依赖于定理4.1主定理 设a>=1 和 b >1为常数,设f(n)为一函数,T(n)由递归式

T(n) = aT(n/b) + f(n)

对非负整数定义,其中n/b 指上顶或者下底,那么T(n)可能有如下的渐进界
...
主要是针对f(n),a,b等值。

第五章 概率分析与随机化算法

5.1 雇用问题

概率分析,随机算法。
使用概率分布预测输入值的分布,以此来帮助分析算法平均情况行为的。

5.2 指示器随机变量

I(A) = 1,如果A发生的话;0,如果A不发生的话。

5.3 随机算法

无法得到输入分布,考虑使用随机算法。
随机排列数组
许多随机算法通过排列给定的输入数组来使输入随机化。

  • 一个常用方法是为每个数组元素A[i]赋一个随机的优先级P[i],然后按照优先级对数组进行排序,过程PERMUTE-BY-SORT,花费O(nlgn)
  • 原地排列给定的数组,过程RANDOMIZE-IN-PLACE花费O(n)

5.4 进一步使用

  • 1 生日悖论
    一个房间的人数需要达到多少,使得两个人生日相同的机会达到50%?分析所有人生日互不相同的概率,其补就为至少两人生日相同。
    因此 Pr{Bk} = 1(n-1/n)(n-2/n)(n-3/n)....(n-k+1/n)=1(1-1/n)*(1-2/n)...(1-(k-1)/n)
    最后分析得出至少23人在一个房间里,概率就能够为1/2。火星为38个人
  • 2 球与盒子

第二部分 排序和顺序统计学. Done

第六章 堆排序 Done

二叉堆数据结构可以被视为一颗完全二叉树。树的每一层都是被填满的,最后一层可能除外。
父节点

PARENT(i)
    return [i/2]
LEFT(i)
    return 2i
RIGHT(i)
    return 2i+1

有两种:最大堆和最小堆,在这两种堆中,节点内的数组都要满足堆特性,在最大堆中,除了根以外的每个节点,有

A[PARENT(i)] >= A[i]

根元素为最大值。
最小堆刚好相反。

MAX-HEAPIFY. 保持堆的性质,最大堆性质,根或者子根都是树最大元素,O(lgn)
对A[i]的这颗字数执行最大堆化。
算法如下:

MAX-HEAPIFY( A, i )
l = LEFT(A[i])
r = RIGHT(A[i]
If l <= heap-size(A) and A[l] > A[i]
    then largest = l
    else largest = i
If r <= heap-size(A) and A[r] > A[largest]
    then largest = r
If largest != i
    then exchange(A[i], A[largest])
        MAX-HEAPIFY(A, largest)

建堆 Build-MAX-HEAP, 对每一颗非叶子节点树执行最大堆化,直至根元素。
自n/2 处开始递减,循环执行Max-HEAPIFY,运行时间的界为O(n)

BUILD-MAX-HEAP(A)
heap-size[A] = length[A]
for i = length[A]/2 downto 1
    do MAX-HEAPIFY(A, i)

堆排序 HEAPSORT 自叶节点向跟元素递减,交换跟元素和叶节点,接着调用MAX-HEAPIFY, 保持该子树的最大堆性质,即可完成节点自小到大排序,时间复杂度为O(nlgn)
原理

每次都将最大的根元素换至末尾的叶节点,这一操作能够将最大元素调到最后,并且排除出堆,然后再一次构造最大堆,次最大元素又被调节到根元素位置,然后再一次将其换至叶节点,这样,不断循环,就能够将元素在数组中从小到大排列。

HEAPSORT(A)

BUILD_MAX_HEAP(A)
for i = length[A] downto 2
    do exchange(A[1], A[i])
        heap-size[A] = heap-size[A] - 1
        MAX-HEAPIFY(A,1)

最大优先级队列,最小优先级队列的应用如图所示。
请输入图片描述

第七章 快速排序 Done

QUICKSORT(A,p, r)
If p < r
    Then q = PARTITION(A, p, r )
        QUICKSORT(A, p, q-1)
        QUICKSORT(A, q+1, r)

最初调用时,QUICKSORT(A, 1, length(A) )
其中PARTITION(A, q, r )算法如下

x = A[r]
i = p-1
For j = p  to r-1
    Do If A[j] <= x
        Then i += 1
            Exchange(A[i], A[j])
Exchange(A[i+1], A[r])
Return i + 1

分区算法 不断将数组分为四个区:
- 第一区 小于 x的区间 A[p, i]
- 第二区 大于x的区间 A[i+1, j]
- 第三区间 尚未比较的区间 A[j+1, r-1]
- 第四区间 主元 A[r]

每一次运行都是O(n)
总共需要递归调用O(log n),因此算法时间复杂度为O(n log n)

有时我们需要对样本加入一些随机化数据,以便对于所有输入,都能得到较好的平均性能,因此,采用随机选择主元的快速排序随机化版本。
主要是对分区操作进行修改

RAMDOMIZED-PARTITION(A, p, r)
i = random(p, r)
Exchange(i , r)
Return PARTITION(A, p, r)

新的排序算法修改如下:

RANDOMIZED-QUICKSORT(A, p, r )
If p < r
    then q = RANDOMIZED-PARTITION(A, p, r)
        RANDOMIZED-QUICKSORT(A, p, q-1)
        RANDOMIZED-QUICKSORT(A, q+1, r)

第八章 线性时间排序(即时间复杂度为O(n)) Done

合并排序和堆排序在最坏情况下,达到上界O(nlogn),快速排序在平均情况下达到此上界,最坏O(n^2)
比较排序,非比较排序

8.1 排序算法的时间的下界

比较排序可以抽象为决策树模型,比如三个值的比较决策结果又3!= 6
定理8.1 任意一个比较排序的算法在最坏情况下,都需要做O(nlgn)次的比较
推论8.2 堆排序和合并排序都是渐进最优的比较排序算法。

8.2 计数排序**

比较有趣的一个排序算法,使用三个数组空间A,B,C。
统计各个值出现的次数.

C[A[j]] = C[A[j]] +1

可见对于C的空间要求将会比较大,只适用于数值比较小的空间。
这样的排序将会导致各个值A[j]的出现次数按照A[j]值的大小在C中依次由小到大排列。然后计算出C中每个值之前出现多少个值,进而计算出该值所占的位置。

算法如下:

COUNTING-SORT(A, B, k)
for i=0 to k
    do C[i] = 0
// 计算A[i] 各个值出现的次数
for j=1 to lenght[A]
    do C[A[j]] = C[A[j]]+1
// 计算小于或者等于C[i]值出现的次数
for i=1 to k
    do C[i] = C[i]+C[i-1]
// 将A[j]的值按照出现的位置置入B中,并将该值的出现次数减一,使与之相同的值自动排在A[j]的前一个位置
for j = length[A] downto 1
    do B[C[A[j]]] = A[j]
       C[A[j]] = C[A[j]]-1

该算法很绕,但比较稳定,运行时间为O(n)

8.3 基数排序

基数排序是对具有多个关键字域的记录进行排序,比如年月日。

RADIX-SORT(A,d)
for i = 1 to d
    do use a stable sort to sort array A to digit i

可以将一个32位的字视为4个8位的数字,于是就可以将k 缩小至255,数位d变为4.
同样的,利用计数排序作为中间稳定排序的基数排序不是原地排序,占用空间较大。尽管基数排序执行的遍数可能比快速排序少,但每一遍所需的时间要长得多。因此一般还是使用快排,因为快排能够有效的利用硬件缓存,同时也是个原地排序。

8.3 桶排序

输入需要符合均匀分布,即可以以线性时间O(n)运行。计数排序的假设输入由小范围内整数构成,而桶排序假设输入由一个随机过程产生,该过程均匀分布在区间(0,1]
算法
BUCKET-SORT(A)

n = length(A)
for i = 1 to n
    do insert A[i] into list B[nA[i]]
for i = 0 to n-1
    do sort list B[i] with insertion sort
concatenate the lists B[0],B[1],....
B[n-1] together in order

第九章 中位数和顺序统计学 Done

约定
取下中位数
本章讨论从一个由n个不同数值构成的集合中选择第i个顺序统计量的问题。选择问题的定义如下:

输入:一个包含n个不同的数的集合A和一个数i, 1=<i<=n
输出: 元素x属于A,它恰大于A中其他的i-1个元素。

最大值和最小值

比如MINIMUM(A)

min = A[1]
for i = 2 to length[A]
    do if min > A[i]
            min = A[i]
return min

通过n-1比较得出,时间复杂度为O(n)
最大值也是如此。
同时计算最大值和最小值,如使用独立比较需要比较2(n-1)次。
可通过每次输入一对数据,然后将其中大的于最大值比较,小的与最小值比较,每个元素比较三次,但只需运行n/2次,所以总的比较次数是3(n/2)次。

9.2 以期望线性时间做选择

使用RANDOMIZED-SELECT 算法,以第七章快速排序算法为模型,也是对输入数组进行划分,但只处理划分的一边,该边通过与需要选择的位计算而出,期望运行时间为O(n)
RANDOMIZED-SELECT算法利用RADOMIZED-PARTITION程序,返回数组A[p..r]中第i小的元素

RANDOMIZED-SELECT(A, p, r, i)
if p = r 
    then return A[p]
q = RANDOMIZED-PARTITION(A, p, r)
k = q - p + 1
if i = k
    then return A[q]
elseif i < k
    then return RANDOMIZED-SELECT(A, p, q-1, i)
//注意i的位置将会做相应的调整,i始终只是相对位置,而q,r都是指在整个数组中的位置
//因此在比较i和k的位置时,是通过计算k的相对位置来与i比较的。
else return RANDOMIZED-SELECT(A, q+1, r, i-k)

按照我的理解,似乎不需要使用i的相对位置,原始位置应该就可以,感觉上没有限制。

结论,在平均情况下,任何顺序统计量特别是中位数,都可以在线性时间内O(n)得到。

9.3 最坏情况线性时间的选择

最坏情况运行时间为O(n)的SELECT算法。采用快速排序的确定性划分算法PARTITION,并做了相应的修改。
- 将输入数组划分为n/5个组,每组5个
- 寻找n/5个组中的每一组中位数,首先对每组中的元素进行插入排序(插入排序在元素数量较小的情况下有着O(n)的复杂度)然后从排序过的数组中选出中位数。
- 在第二步中选出的中位数,递归调用SELECT选出一个中位数x
- 利用修改过的PARTITION过程,按照中位数的中位数x,对输入数组进行划分,让k比划分地区的元素数目多1,所以x就是第k小元素,并且有n-k个元素在划分的高区。
- 如果i = k ,则返回x,否则,如果i<k, 则在低区递归调用SELECT以找出第i小的元素,如果i>k, 则在高区递归调用寻找第(i-k)个最小元素。

本章结论

本章中选择算法之所以具有线性时间,是因为这些算法并没有进行排序。线程时间的行为并不是因为对输入做假设所得到的结果。在比较模型中,即使是在平均情况下,排序仍然需要O(nlgn)的时间,所以从渐进意义上来看,排序和索引方法的效率是不高的。

第三部分 数据结构

第十章 基本数据结构. Done

第十一章 散列表. Done

第十二章 二叉查找树. Done

第十三章 红黑树. Undone

第八部分 附录:数学基础知识

A. 求和. Done

B. 集合等离散数学结构. Done

  • 集合
  • 关系
  • 函数
  • 自由树
  • 有根树和有序树
  • 二叉树和位置树

C. 计数和概率. Undone

C.1 计数

在有限集合S上构造一个长度为k的串称为K串。直观上,为了在n元集上构造一个k串,有n种方法选择第一个元素,同样地,也有N种方法选择第二个元素,这样一次进行K次,从而K串的数目为nnn*...n = n^k.
最形象的就是车牌号了。

  • 排列

有限集S的排列是S中所有元素的有序序列,且每个元素仅出现一次。一个N元集的集合有n!种排列,第一个元素有n种选择,第二个有n-1种选择,第三个有n-2种选择...
集合S的k排列是S中k个元素的有序排列,且每个元素出现一次。因此N元集合的K排列数目是

n(n-1)(n-2)(n-3)(n-4)...(n-k+1) = n!/(n-k)!

  • 组合

n元集的K组合就是S的k子集,n元集的k组合的数目可以用排列的数目来表示,对每个k组合,它的元素恰好有k!中排列,每个都是n元集的一个不同的k排列。因此,n元集的k组合数目是其k排列的数目除以k!。这个数量为

n!/(k!(n-k)!)

组合与排列的区别是,组合中k元祖是无序的,而排列是有序的,意味着组合的元祖对应着k!种不同的排列元祖。
因此在计算时需要除去每个元祖的其他的有序排列。

  • 二项式系数

  • 二项式界

下界

= n!/k!(n-k)! 展开>= (n/k)^k

再利用斯特林近似式得上界

<= n^k/k! <= (en/k)^k

C.2 概率

条件概率Pr{A|B} 读作在事件B发生的条件下,事件A发生的概率

Pr{A|B} = Pr{A交B}/ Pr{B}
A交B是时间A发生,B也发生的事件,因此可以认为这是B中的一个基本事件,因此该事件占整个B事件的概率就是Pr{A交B}/ Pr{N},也即Pr{A|B}

如果Pr{A交B} = Pr{A} Pr{B},则称连个事件独立。

贝叶斯定理

Pr{A交B} = Pr{B} Pr{A|B} = Pr{A} Pr{B|A}

通过交换律,可得如下贝叶斯定理

Pr{A|B} = Pr{A} Pr{B|A}/Pr{B}

C.3 离散随机变量

随机变量X的概率密度函数

f(x) = Pr{X=x}

随机变量的期望值

E[X] = ∑xPr{X=x}

方差

Var[X] = E[(X-E[X]^2)]
= E[X^2]-E^2[X]

C.4 几何分布与二项分布

几何分布
假设进行一系列的伯努利实验,每次实验成功的概率是P,失败的概率是q=1-p,在取得一次成功前要进行多少次实验?因为在取得一次成功前有k-1次失败,从而有

Pr{X=k} = q^(k-1)p

期望 1/p

二项分布
因为有(n k) 种方法从n次实验中选取k次成功的试验,且每次发生的概率是p^k*q^(n-k)

Pr{X=k} = (n k)p^k*q^(n-k)

期望E[X] = np, 方差 Var[X] = npq
发自我的 iPad

你可能感兴趣的

载入中...