数据结构(c++)学习笔记--词典

文章目录

  • 一、散列
    • 1.循对象访问
    • 2.原理
    • 3.冲突
  • 二、散列函数
    • 1.基本
    • 2.随机数
    • 3.hashCode与多项式法
  • 三、排解冲突
    • 1.开放散列
    • 2.封闭散列
    • 3.懒惰删除
    • 4.重散列(Rehashing)
    • 5.平方试探
    • 6.双向平方试探
    • 7.双散列(Double Hashing)
  • 四、桶排序
    • 1.算法
    • 2.最大缝隙
  • 五、基数排序
    • 1.算法与实现
    • 2.整数排序
  • 六、计数排序
    • 1.算法
    • 2.实例


一、散列

1.循对象访问

1.1 联合数组:更直接、更有效的访问

  • 根据数据元素的取值,直接访问
    • style[“关羽”] = “云长”
    • style[“张飞”] = “翼德”
    • style[“赵云”] = “子龙”
    • style[“马超”] = “孟起”
  • 下标不再是整数,甚至没有大小次序 ——更为直观、便捷

1.2 词条(entry)~ 映射/词典(Map/Dictionary)

  • entry = (key, value)
  • Map/Dictionary:词条的集合
    • 关键码禁止/允许雷同
    • get(key) put(key, value) remove(key)
  • 关键码未必可定义大小,元素类型较BST更多样
  • 查找对象不限于最大/最小词条,接口功能较PQ更强大

数据结构(c++)学习笔记--词典_第1张图片

1.3 词典

template <typename K, typename V> //key、value 
struct Dictionary { 
    virtual int size() = 0; 
    virtual bool put( K, V ) = 0; 
    virtual V* get( K ) = 0; 
    virtual bool remove( K ) = 0; 
};
  • 词典中的词条只需支持判等/比对操作

2.原理

2.1 电话:号码 ~ 人

数据结构(c++)学习笔记--词典_第2张图片

2.2 电话簿

  • 需求: 为一所学校制作电话簿
    • 号码 --> 教员、学生、员工、办公室
  • 蛮力: 用户记录 ~ 数组Rank ~ 电话号码 (O(1)效率)
  • 可能的电话 = R= 10^8 = 100M ,实有的电话 = N= 25,000 = 25K
  • 问题:
    • 空间 = O(R/N)= O(100M + 25K)
    • 效率 = 25K / 100M = 0.025%
      数据结构(c++)学习笔记--词典_第3张图片

2.3 散列表 / 散列函数

  • 桶(bucket):直接存放或间接指向一个词条

  • Bucket array ~ Hashtable(哈希表)

    • 容量:M
    • 满足: N < M < < R NN<M<<R
    • 空间:O(N+M)=O(N)
  • 定址/杂凑/散列

    • 根据词条的key(未必可比较)
    • “直接”确定散列表入口(无论表有多长)
  • 散列函数: hash():key->&entry

  • “直接”:expected-O(1)≠O(1)

数据结构(c++)学习笔记--词典_第4张图片

2.4 实例

数据结构(c++)学习笔记--词典_第5张图片

3.冲突

3.1 同义词(synonym)

k e y 1 ≠ k e y 2 key_1≠key_2 key1=key2 but h a s h ( k e y 1 ) = h a s h ( k e y 2 ) hash(key_1)=hash(key_2) hash(key1)=hash(key2)

3.2 装填因子 vs. 冲突

  • load factor:λ=N/M
  • λ越大/小
    • 空间利用率越高/低
    • 冲突的情况越严重/轻微
  • 通过降低λ,冲突程度将会有所改善,但只要数据集在动态变化,就无法彻底杜绝

数据结构(c++)学习笔记--词典_第6张图片

3.3 完美散列

  • 在某些条件下,的确可以实现单射(injection)式散列

  • 数据集已知且固定时,可实现完美散列(perfect hashing)

    • 采用两级散列模式

    • 仅需O(n)空间

    • 关键码之间互不冲突

    • 最坏情况下的查找时间也不过O(1)

  • 不过在一般情况下,完美散列可期不可求

3.4 生日悖论

  • 将在座同学(对应的词条)按生日(月/日)做散列存储
    • 散列表长M = 365,装填因子 = 在场人数N / 365
  • 冲突(至少有两位同学生日相同)的可能性P365(n)
    • P365(1) = 0, P365(2) = 1/365, …, P365(22) = 47.6%, P365(23) = 50.7%, …
  • 100人的集会:1 - p365(100) = 0.000,031%
    • 自7岁起,不吃不喝、无休无息,每小时参加四次
    • 到100岁,才有可能期望遇到一次无冲突的集会
  • 因此,在装填因子确定之后,散列策略的选取将至关重要,散列函数的设计也很有讲究

3.5 两项基本任务

  • 首先(下一节):精心设计散列表及散列函数,尽可能降低冲突的概率
  • 同时(再下节):制定可行的预案,以便在发生冲突时,能够尽快予以排解

数据结构(c++)学习笔记--词典_第7张图片

二、散列函数

1.基本

1.1 评价标准 + 设计原则

  • 确定(determinism):同一关键码总是被映射至同一地址

  • 快速(efficiency):expected-O(1)

  • 满射(surjection):尽可能充分地利用整个散列空间

  • 均匀(uniformity):关键码映射到散列表各位置的概率尽量接近,有效避免聚集(clustering)现象

1.2 除余法

  • $hash(key)=key % M $

  • 据说M为素数时,数据对散列表的覆盖最充分,分布最均匀 其实对于理想随机的序列,表长是否素数,无关紧要

  • 序列的Kolmogorov复杂度:生成该序列的算法,最短可用多少行代码实现?

    • 算术级数: 7 12 17 22 27 32 37 42 47 … //单调性/线性:从7开始,步长为5
    • 循环级数: 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 … //周期性:12345不断循环
    • 英文:data structures and algorithms … //局部性:频率、关联、词根、…
  • 实际应用中的数据序列远非理想随机,上述规律性普遍存在

  • 蝉的哲学:经长期自然选择,生命周期“取”作素数

1.3 MAD法

  • 除余法的缺陷
    • 不动点:无论表长M取值如何,总有:hash(0)≡0
    • 相关性:[0,R)的关键码尽管系平均分配至M个桶;但相邻关键码的散列地址也必相邻

nfd46.png

  • Multiply - Add - Divide
    • h a s h ( k e y ) = ( a ∗ k e y + b ) % M , M 为素数, a > 0 , b > 0 ,且 a % M ≠ 0 hash(key) = (a * key + b) \% M,M 为素数,a>0,b>0,且a \% M ≠ 0 hash(key)=(akey+b)%MM为素数,a>0b>0,且a%M=0

1.4 更多散列函数

  • 数字分析(selecting digits) :抽取key中的某几位,构成地址

    • 比如,取十进制表示的奇数位
  • 平方取中(mid-square) :取 k e y 2 key^2 key2的中间若干位,构成地址

    • h a s h ( 123 ) = m i d d l e ( 123 ∗ 123 ) = 1 512 ‾ 9 = 512 hash(123)=middle(123 * 123)=1 \underline{512} 9=512 hash(123)=middle(123123)=15129=512
  • 折叠法(folding) :将key分割成等宽的若干段,取其总和作为地址

    • hash( 123 456 789 ) = 123 + 456 + 789 = 1368 //自左向右
    • hash( 123 456 789 ) = 123 + 654 + 789 = 1566 //往复折返
  • 位异或法(XOR) :将key分割成等宽的二进制段,经异或运算得到地址

    • hash( 110 011 011 b ) = 110 ^ 011 ^ 011 = 110b //自左向右
    • hash( 110 011 011 b ) = 110 ^ 110 ^ 011 = 011b //往复折返
  • 总之,越是随机,越是没有规律,越好

2.随机数

2.1 (伪)随机数法

  • 循环: rand( x + 1 ) = [ a * rand( x ) ] % M //M素数,a % M ≠ 0

    • a = 7 5 = 16 , 807 = 10000011010011 1 b a = 7^5 = 16,807 = 100000110100111_b a=75=16,807=100000110100111b
    • M = 2 31 – 1 = 2 , 147 , 483 , 647 = 0111111111111111111111111111111 1 b M = 2^{31} – 1 = 2,147,483,647 = 01111111 11111111 11111111 11111111_b M=231–1=2,147,483,647=01111111111111111111111111111111b
  • 径取:hash(key) = rand(key) = [ r a n d ( 0 ) ∗ a k e y rand(0) * a^{key} rand(0)akey] % M

  • 种子:rand(0) = ?

  • 把难题推给伪随机数发生器,但是(伪)随机数发生器的实现,因具体平台、不同历史版本而异,创建的散列表可移植性差——故需慎用此法

unsigned long int next = 1; //sizeof(long int) = 8 
    void srand(unsigned int seed) { next = seed; } //sizeof(int) = 4 or 8 
    int rand(void) { //1103515245 = 3^5 * 5 * 7 * 129749 
        next = next * 1103515245 + 12345; 
        return (unsigned int)(next/65536) % 32768;
} 

int rand() { int uninitialized; return uninitialized; } 
char* rand( t_size n ) { return ( char* ) malloc( n ); }

nflG8.png

2.2 就地随机置乱:任给一个数组A[0, n),理想地将其中元素的次序随机打乱

void shuffle( int A[], int n ) { 
    for ( ; 1 < n; --n ) //自后向前,依次将各元素 
    swap( A[ rand() % n ], A[ n - 1 ] ); //与随机选取的某一前驱(含自身)交换 
} //20! < 2^64 < 21!

nfrHU.png

3.hashCode与多项式法

3.1 任意类型->整数型

  • h a s h C o d e ( “ x n − 1 . . . x 2 x 1 x 0 " ) = x n − 1 ⋅ a n − 1 + . . . + x 2 ⋅ a 2 + x 1 ⋅ a 1 + x 0 = ( . . . ( ( x n − 1 ⋅ a + x n − 2 ) ⋅ a ) + . . . + x 1 ) ⋅ a + x 0 \begin{aligned} hashCode(“x_{n-1}...x_2x_1x_0")&=x_{n-1}·a^{n-1}+...+x_2·a^2+x_1·a^1+x_0 \\ &=(...((x_{n-1}·a+x_n-2)·a)+...+x_1)·a+x_0 \\ \end{aligned} hashCode(xn1...x2x1x0")=xn1an1+...+x2a2+x1a1+x0=(...((xn1a+xn2)a)+...+x1)a+x0

3.2 冲突 ~ 巧合

  • h a s h C o d e ( S ) = ∑ c ∈ S c o d e ( u p p e r ( c ) ) hashCode(S)=\sum_{c∈S}code(upper(c)) hashCode(S)=cScode(upper(c))

    • h a s h C o d e ( “ h a s h ” ) = 8 + 1 + 19 + 8 = 36 hashCode(“hash”)=8+1+19+8=36 hashCode(hash)=8+1+19+8=36
  • 字符相对次序信息丢失,将引发大量冲突

    • I am Lord Voldemort
    • Tom Marvolo Riddle
  • 即便字符不同、数目不等

    • He’s Harry Potter

三、排解冲突

1.开放散列

1.1 多槽位(Multiple Slots)

  • Multiple Slots

    • 桶单元细分成若干槽位
    • 存放(与同一单元)冲突的词条
  • 只要槽位数目不太多 依然可以保证O(1)的时间效率

数据结构(c++)学习笔记--词典_第8张图片

  • 需要细分到什么程度
    • 过细,空间浪费;反过来
    • 无论多细,极端情况下仍可能不够

1.2 公共溢出区(Overflow Area)

  • 单独开辟一块连续空间 发生冲突的词条,顺序存入此区域
  • 结构简单,算法易于实现
  • 但是,不冲突则已,一旦发生冲突,最坏情况下,处理冲突词条所需的时间将 正比于溢出区的规模

数据结构(c++)学习笔记--词典_第9张图片

1.3 独立链 (Linked-List Chaining / Separate Chaining)

  • 每个桶拥有一个列表,存放对应的一组同义词
  • 优点
    • 无需为每个桶预备多个槽位
    • 任意多次的冲突都可解决
    • 删除操作实现简单、统一
  • 但是,指针本身占用空间,节点的动态分配和回收需耗时间 更重要的是空间未必连续分布,系统缓存很难生效

数据结构(c++)学习笔记--词典_第10张图片

2.封闭散列

2.1 开放定址

  • 闭散列方法(Closed Hashing),必然对应于开放定址(Open Addressing)

    • 只要有必要,任何散列桶都可以接纳任何词条
  • 检测序列(Probe Sequence/Chain):为每个词条,都需事先约定若干备用桶,优先级逐次下降

  • 查找算法:沿试探链,逐个转向下一桶单元,直到命中成功,或者抵达一个空桶而失败

2.2 线性试探

  • Linear Probing

    • 一旦冲突,则试探后一紧邻的桶
    • 直到命中(成功),或抵达空桶(失败)
  • [ hash( key ) + 1 ] % M->[ hash( key ) + 2 ] % M->[ hash( key ) + 3 ] % M->[ hash( key ) + 4 ] % M

nfbrl.png

  • 在散列表内部解决冲突,无需附加的指针、链表或溢出区等,整体结构保持简洁

  • 只要还有空桶,迟早会找到

  • 新增非同义词之间的冲突

  • 数据堆积(clustering)现象严重

  • 好在,试探链连续,数据局部性良好

  • 通过装填因子,冲突与堆积都可有效控制

2.3 插入+删除

数据结构(c++)学习笔记--词典_第11张图片

  • 插入:新词条若尚不存在,则存入试探终止处的空桶
  • 试探链:可能因而彼此串接、重叠!
  • 删除:经过它的试探链都将因此断裂,导致后续词条丢失——明明存在,却访问不到

3.懒惰删除

3.1 Lazy Removal:故居 ~ 空宅

  • Bitmap* removed 用Bitmap懒惰地标记被删除的桶
  • int L 被标记桶的数目

数据结构(c++)学习笔记--词典_第12张图片

  • 仅做标记,不对试探链做更多调整——此后,带标记的桶,角色因具体的操作而异
    • 查找词条时,被视作“必不匹配的非空桶”,试探链在此得以延续
    • 插入词条时,被视作“必然匹配的空闲桶”,可以用来存放新词条

3.2 两种算法

template<typename K,typename V> int Hashtable::probe4Hit(const K& k) { 
    int r = hashCode(k) % M; //按除余法确定试探链起点 
    while ( ( ht[r] && (k != ht[r]->key) ) || removed->test(r) ) 
        r = ( r + 1 ) % M; //线性试探(跳过带懒惰删除标记的桶) 
    return r; //调用者根据ht[r]是否为空及其内容,即可判断查找是否成功 
} 

template<typename K,typename V> int Hashtable::probe4Free(const K& k) { 
    int r = hashCode(k) % M; //按除余法确定试探链起点 
    while ( ht[r] ) r = (r + 1) % M; //线性试探,直到空桶(无论是否带有懒惰删除标记) 
    return r; //只要有空桶,线性试探迟早能找到
}

4.重散列(Rehashing)

template<typename K,typename V> //随着装填因子增大,冲突概率、排解难度都将激增 
void Hashtable::rehash() { //此时,不如“集体搬迁”至一个更大的散列表 
    int oldM = M; Entry** oldHt = ht; 
    ht = new Entry*[ M = primeNLT( 4 * N ) ]; N = 0; //新表“扩”容 
    memset( ht, 0, sizeof( Entry* ) * M ); //初始化各桶 
    release( removed ); removed = new Bitmap(M); L = 0; //懒惰删除标记 
    for ( int i = 0; i < oldM; i++ ) //扫描原表 
        if ( oldHt[i] ) //将每个非空桶中的词条 
            put( oldHt[i]->key, oldHt[i]->value ); //转入新表 
    release( oldHt ); //释放——因所有词条均已转移,故只需释放桶数组本身 
}

template<typename K,typename V> bool Hashtable::put( K k, V v ) { 
    if ( ht[ probe4Hit( k ) ] ) return false; //雷同元素不必重复插入 
    int r = probe4Free( k ); //为新词条找个空桶(只要装填因子控制得当,必然成功) 
    ht[ r ] = new Entry( k, v ); ++N; //插入 
    if ( removed->test( r ) ) { removed->clear( r ); --L; } //懒惰删除标记 
    if ( (N + L)*2 > M ) rehash(); //若装填因子高于50%,重散列 
    return true; 插入
}

template<typename K,typename V> bool Hashtable::remove( K k ) { 
    int r = probe4Hit( k ); if ( !ht[r] ) return false; //确认目标词条确实存在 
    release( ht[r] ); ht[r] = NULL; --N; //清除目标词条 
    removed->set(r); ++L; //更新标记、计数器 
    if ( 3*N < L ) rehash(); //若懒惰删除标记过多,重散列 
    return true; 
}

5.平方试探

5.1 平方试探(Quadratic Probing)

  • Quadratic Probing:以平方数为距离,确定下一试探桶单元

    • [ h a s h ( k e y ) + 1 2 ] % M [ hash(key) + 1^2 ] \% M [hash(key)+12]%M
    • [ h a s h ( k e y ) + 2 2 ] % M [ hash(key) + 2^2 ] \% M [hash(key)+22]%M
  • 数据聚集现象有所缓解

    • 试探链上,各桶间距线性递增
    • 一旦冲突,可“聪明”地跳离是非之地
  • 对于大散列表,I/O操作有所增加

nfnrm.png

5.2 素数表长时,只要λ<0.5就一定能够找出;否则,不见得

  • { 0 , 1 , 2 , 3 , 4 , 5 , . . . } 2 % 12 = { 0 , 1 , 4 , 9 } \{ 0, 1, 2, 3, 4, 5, ... \}^2 \% 12 = \{ 0, 1, 4, 9 \} {0,1,2,3,4,5,...}2%12={0,1,4,9}
    • M若为合数: n 2 % M n^2\%M n2%M可能的取值可能少于 ⌈ M / 2 ⌉ \lceil M/2 \rceil M/2种——此时,只要对应的桶均非空

数据结构(c++)学习笔记--词典_第13张图片

  • { 0 , 1 , 2 , 3 , 4 , 5 , . . . } 2 % 11 = { 0 , 1 , 4 , 9 , 5 , 3 } \{ 0, 1, 2, 3, 4, 5, ... \}^2 \% 11 = \{ 0, 1, 4, 9,5,3 \} {0,1,2,3,4,5,...}2%11={0,1,4,9,5,3}
    • 若M为素数, n 2 % M n^2\%M n2%M恰有 ⌈ M / 2 ⌉ \lceil M/2 \rceil M/2种取值,且由试探链的前 ⌈ M / 2 ⌉ \lceil M/2 \rceil M/2项取遍

5.3 每一条试探链,都有足够长的无重前缀

  • 反证:假设存在 0 ≤ a ≤ b < ⌈ M / 2 ⌉ 0≤a≤b<\lceil M/2 \rceil 0ab<M/2,使得沿着试探链,第a项和第b项彼此冲突
  • 于是: a 2 a^2 a2和%b^2%自然关于M同余,亦即
    • a 2 ≡ b 2 ( m o d M ) a^2\equiv b^2(mod M) a2b2(modM)
    • b 2 − a 2 = ( b + a ) ( b − a ) ≡ 0 ( m o d M ) b^2-a^2=(b+a)(b-a)\equiv 0(mod M) b2a2=(b+a)(ba)0(modM)
  • 然而, 0 < b − a ≤ b + a < ⌈ M / 2 ⌉ + ( ⌈ M / 2 ⌉ + 1 ) ≤ ⌈ M / 2 ⌉ + ⌈ M / 2 ⌉ = M 00<bab+a<M/2+(⌈M/2+1)M/2+M/2=M
    • 无论b-a还是b+a都不可能整除M

6.双向平方试探

6.1 策略:交替地沿两个方向试探,均按平方确定距离

  • [ h a s h ( k e y ) + 1 2 ] % M [ hash(key) + 1^2 ] \% M [hash(key)+12]%M [ h a s h ( k e y ) + 2 2 ] % M [ hash(key) + 2^2 ] \% M [hash(key)+22]%M
  • [ h a s h ( k e y ) − 1 2 ] % M [ hash(key) - 1^2 ] \% M [hash(key)12]%M [ h a s h ( k e y ) − 2 2 ] % M [ hash(key) - 2^2 ] \% M [hash(key)22]%M

数据结构(c++)学习笔记--词典_第14张图片

6.2 子试探链

  • 正向和反向的子试探链,各自包含 ⌈ M / 2 ⌉ \lceil M/2 \rceil M/2个互异的桶
    • ⌊ M / 2 ⌋ , . . . , − 3 , − 2 , − 1 ‾ , 0 , 1 , 2 , 3 , . . . , ⌊ M / 2 ⌋ ‾ \underline{\lfloor M/2 \rfloor,...,-3,-2,-1},0,\underline{1,2,3,...,\lfloor M/2 \rfloor} M/2,...,3,2,1,0,1,2,3,...,M/2

6.3 4k+3

  • 表长取作素数M=4k+3,即必然可以保证试探链的前M项均互异

数据结构(c++)学习笔记--词典_第15张图片

6.4 费马二平方定理(Two-Square Theorem of Fermat)

  • 任一素数p可表示为一对整数的平方和,当且仅当 p ≡ 1 ( m o d M ) p\equiv 1(mod M) p1(modM)

  • 只要注意到: ( u 2 + v 2 ) ( s 2 + t 2 ) = ( u s + v t ) 2 + ( u t − v s ) 2 = ( u s − v t ) 2 + ( u t + v s ) 2 (u^2+v^2)(s^2+t^2)=(us+vt)^2+(ut-vs)^2=(us-vt)^2+(ut+vs)^2 (u2+v2)(s2+t2)=(us+vt)2+(utvs)2=(usvt)2+(ut+vs)2

  • 就不难推知:自然数n可表示为一对整数的平方和,当(且仅当)它的每一 M=4k+3类的素因子均为偶数次方

7.双散列(Double Hashing)

  • 预先约定第二散列函数: h a s h 2 ( k e y , i ) hash_2(key,i) hash2(key,i)

  • 冲突时,由其确定偏移增量,确定下一试探位置: [ h a s h ( k e y ) + ∑ i = 1 k h a s h 2 ( k e y , i ) ] % M [hash(key)+\sum_{i=1}^{k}hash_2(key,i)]\%M [hash(key)+i=1khash2(key,i)]%M

  • 线性试探: h a s h 2 ( k e y , i ) ≡ 1 hash_2(key,i) \equiv 1 hash2(key,i)1

  • 平方试探: h a s h 2 ( k e y , i ) = 2 i − 1 hash_2(key,i)=2i-1 hash2(key,i)=2i1

  • 更一般地,偏移增量同时还与key相关

数据结构(c++)学习笔记--词典_第16张图片

四、桶排序

1.算法

1.1 简单情况

  • 对[0,m)内的n(
  • 空间 = O(m),时间 = O(n)

数据结构(c++)学习笔记--词典_第17张图片

1.2 一般情况

  • 若允许重复 (可能m << n)
  • 依然使用散列表
    • 每一组同义词各成一个链表
  • 空间 = O(m + n),时间 = O(n)

数据结构(c++)学习笔记--词典_第18张图片

2.最大缝隙

2.1 最大缝隙(MaxGap)

nfpP6.png

  • 任意n个互异点均将实轴分为n-1段有界区间,其中的哪一段最长
  • 如果不追求效率,显而易见的方法莫过于
    • 对所有点排序 //Ω(nlogn)
    • 依次计算各相邻点对的间距,保留最大者 //Θ(n)
  • 采用分桶策略,可改进至O(n)时间

2.2 线性算符

数据结构(c++)学习笔记--词典_第19张图片

  • 找到最左点、最右点 O(n) //一趟线性扫描

  • 将有效范围均匀地划分为n-1段(n个桶) O(n) //相当于散列表

  • 通过散列,将各点归入对应的桶 O(n) //模余法

  • 在各桶中,动态记录最左点、最右点 O(n) //可能相同甚至没有

  • 算出相邻(非空)桶之间的“距离” O(n) //一趟遍历足矣

  • 最大的距离即MaxGap O(n) //画家算法

2.3 正确性

  • MaxGap至少跨越两个桶,等价地,MaxGap不可能局限于某一个桶内

五、基数排序

1.算法与实现

1.1 词典序

  • 有时,关键码由多个域组成: k d , k t − 1 , . . . , k 1 k_d , k_{t-1} , ... , k_1 kd,kt1,...,k1
  • 若将各域视作字母,则关键码即单词——按词典的方式排序(lexicographic order)

1.2 算法:自 k 1 k_1 k1 k t k_t kt(低位优先),依次以各域为序做一趟桶排序

数据结构(c++)学习笔记--词典_第20张图片

1.3 正确性

  • 归纳假设:前i趟排序后,所有词条关于低i位有序 (第1趟显然)
  • 假设前i-1趟均成立,现考查第i趟排序之后的时刻
  • 无非两种情况
    • 凡第i位不同的词条,即便此前曾是逆序,现在亦必已转为有序
    • 凡第i位相同的词条,得益于桶排序的稳定性,必保持原有次序

1.4 时间成本

时间成本 = 各趟桶排序所需时间之和 = n + 2 m 1 + n + 2 m 2 + . . . + n + 2 m d / / m 为各域 k 的取值范围 = O ( d ∗ ( n + m ) ) / / m = m a x { m 1 , . . . , m d } \begin{aligned} 时间成本&=各趟桶排序所需时间之和 \\ &=n + 2m_1 + n + 2m_2 + ... + n + 2m_d //m 为各域 k 的取值范围\\ &=O( d * (n + m) ) //m = max\{ m_1, ..., m_d \}\\ \end{aligned} 时间成本=各趟桶排序所需时间之和=n+2m1+n+2m2+...+n+2md//m为各域k的取值范围=O(d(n+m))//m=max{m1,...,md}

  • 当m = O(n)且d可视作常数时,O(n)
  • 在一些特定场合,Radixsort非常高效

1.5 实现(以二进制无符号整数为例)

typedef unsigned int U; //约定:类型T或就是U;或可转换为U,并依此定序 

template<typename T> void List<T>::radixSort( ListNodePosi p, int n ) { 
    ListNodePosi<T> head = p->pred; ListNodePosi<T> tail = p; 
    for ( int i = 0; i < n; i++ ) tail = tail->succ; //待排序区间为(head, tail) 
    for ( U radixBit = 0x1; radixBit && (p = head); radixBit <<= 1 ) //以下反复地 
        for ( int i = 0; i < n; i++ ) //根据当前基数位,将所有节点 
            radixBit & U (p->succ->data) ? //分拣为前缀(0)与后缀(1) 
                insert( remove( p->succ ), tail ) : p = p->succ; 
} //为避免remove()、insert()的低效率,可拓展List::move(p,tail)接口,将节点p直接移至tail之前

1.6 实例

数据结构(c++)学习笔记--词典_第21张图片

2.整数排序

2.1 常对数密度的整数集

  • 设d>1为常数

  • 考查取自 [ 0 , n d ) [0,n^d) [0,nd)内的n个整数

    • 常规密度 = n / n d = 1 / n d − 1 → 0 =n/n^d=1/n^{d-1}\rightarrow0 =n/nd=1/nd10
    • 对数密度 = ln ⁡ n / ln ⁡ n d = 1 / d = O ( 1 ) =\ln n/\ln n^d=1/d=O(1) =lnn/lnnd=1/d=O(1)
  • 亦即,这类整数集的对数密度不超过常数

  • 若取d=4,则即便是64位整数,也只需 n > ( 2 64 ) 1 / 4 = 2 16 = 65 , 356 n>(2^{64})^{1/4}=2^{16}=65,356 n>(264)1/4=216=65,356

2.2 线性排序算法

  • 预处理:将所有元素转换为n进制形式: x = ( x d , . . . , x 3 , x 2 , x 1 ) x=(x_d,...,x_3,x_2,x_1) x=(xd,...,x3,x2,x1)

nlhQ1.png

  • 于是,每个元素均转化为d个域,故可直接套用Radixsort算法
  • 排序时间=d·(n+n)=P(n)
  • 原因在于:
    • 整数取值范围有限制
    • 不再是基于比较的计算模式

六、计数排序

1.算法

  • 以纸牌排序为例(n>>m=4),假设已按点数排序,以下对花色排序
    数据结构(c++)学习笔记--词典_第22张图片
  • (1)经过分桶,统计出各种花色的数量 //O(n)
  • (2)自前向后扫描各桶,依次累加 (cumulative sum, O(m)), 即可确定各套花色所处的秩区间:[0, 3) + [3, 5) + [5, 9) + [9, 11)

数据结构(c++)学习笔记--词典_第23张图片

  • (3)自后向前扫描每一张牌 (O(n)), 对应桶的计数减一,即是其在最终有序序列中对应的秩

2.实例

数据结构(c++)学习笔记--词典_第24张图片
数据结构(c++)学习笔记--词典_第25张图片
数据结构(c++)学习笔记--词典_第26张图片

数据结构(c++)学习笔记--词典_第27张图片
数据结构(c++)学习笔记--词典_第28张图片
数据结构(c++)学习笔记--词典_第29张图片
数据结构(c++)学习笔记--词典_第30张图片

你可能感兴趣的:(数据结构(c++)学习笔记,数据结构,c++,学习)