算法复杂度攻击
1. Hashing
我们经常使用这样的字符串的Hash函数：
// 随手写的，未严格测试
unsigned long Hash(char* str)
{
assert(NULL != str);
unsigned long hash_val = 0xDEEDBEEFul; // hash seed
unsigned char* p = (unsigned char*)str;
while (*p != '/0') {
hash_val = 37 * hash_val + *p;
++p;
}
return hash_val;
}
《程序设计实践》第3章的Markov Chain的实现就使用了几乎一摸一样的Hash函数。这个函数的优点是速度快，英文单词的Hash值的分布也不错。但是，它太简单，容易受到攻击。攻击一般有两种方案：1) 构造一个输入序列，让序列中的每个字符串彼此不同，但Hash值相同；2) 构造一个输入序列，序列中每个字符串彼此不同，Hash值也不一定相同，但是这些Hash值对所用Hash Table的buckets数目同余（即hash_val % bucket_size 相等）。这样就能让Hash Table退化为链表。从而大大增加查找时间。(http://www.cs.rice.edu/~scrosby/hash/)
要解决这个问题，需要用复杂得多的Hash函数(MD5、SHA-1)，让攻击者(几乎)无法构造出Hash值相同的序列。
2. Regular Expressions
Regular Expression Engine 一般有三种：DFA (Deterministic Finite Automaton)、traditional NFA (Nondeterministic Finite Automaton)、POSIX NFA。这三种engines的功能一个比一个强，速度一个比一个慢。(http://msdn.microsoft.com/library/en-us/cpguide/html/cpconmatchingbehavior.asp) (http://www.oreilly.com/catalog/regex/chapter/ch04.html)
DFA 速度最快，可以保证线性时间(?)。NFA需要使用backtracking(回溯)技术，以支持backreference(向前引用)，通常NFA是线性时间，但是其最坏情况是指数时间！
举例来说，表达式 (x+x+)+y 可以匹配 xxx...xxxy 但不能匹配 xxx...xxxx。在某个版本的Python中，这个表达式的匹配是指数时间。(http://mail.python.org/pipermail/python-dev/2003-May/035916.html)
3. Quicksort
Quicksort的平均运行时间是O(N log N)，但可能退化为 O(N^2)，这是数据结构课程的必讲内容。C library 的 qsort 就不能保证一定是“快速”排序。(http://www.cs.dartmouth.edu/~doug/mdmspe.pdf)。C++ library 的 sort() 在改造之前，也可能退化为 O(N^2) 的龟速排序。SGI STL 的 sort() 使用了 a new, hybrid sorting algorithm, introsort (for introspective sort), that behaves almost exactly like median-of-3 quicksort for most inputs (and is just as fast) but which is capable of detecting when partitioning is tending toward quadratic behavior. By switching to heapsort in those situations, introsort achieves the same O(N logN) time bound as heapsort but is almost always faster than just using heapsort in the first place. (http://www.cs.rpi.edu/~musser/gp/algorithms.html) 。该排序算法的分析见 (http://www.cs.rpi.edu/~musser/gp/introsort.ps)
1. Hashing
我们经常使用这样的字符串的Hash函数：
// 随手写的，未严格测试
unsigned long Hash(char* str)
{
assert(NULL != str);
unsigned long hash_val = 0xDEEDBEEFul; // hash seed
unsigned char* p = (unsigned char*)str;
while (*p != '/0') {
hash_val = 37 * hash_val + *p;
++p;
}
return hash_val;
}
《程序设计实践》第3章的Markov Chain的实现就使用了几乎一摸一样的Hash函数。这个函数的优点是速度快，英文单词的Hash值的分布也不错。但是，它太简单，容易受到攻击。攻击一般有两种方案：1) 构造一个输入序列，让序列中的每个字符串彼此不同，但Hash值相同；2) 构造一个输入序列，序列中每个字符串彼此不同，Hash值也不一定相同，但是这些Hash值对所用Hash Table的buckets数目同余（即hash_val % bucket_size 相等）。这样就能让Hash Table退化为链表。从而大大增加查找时间。(http://www.cs.rice.edu/~scrosby/hash/)
要解决这个问题，需要用复杂得多的Hash函数(MD5、SHA-1)，让攻击者(几乎)无法构造出Hash值相同的序列。
2. Regular Expressions
Regular Expression Engine 一般有三种：DFA (Deterministic Finite Automaton)、traditional NFA (Nondeterministic Finite Automaton)、POSIX NFA。这三种engines的功能一个比一个强，速度一个比一个慢。(http://msdn.microsoft.com/library/en-us/cpguide/html/cpconmatchingbehavior.asp) (http://www.oreilly.com/catalog/regex/chapter/ch04.html)
DFA 速度最快，可以保证线性时间(?)。NFA需要使用backtracking(回溯)技术，以支持backreference(向前引用)，通常NFA是线性时间，但是其最坏情况是指数时间！
举例来说，表达式 (x+x+)+y 可以匹配 xxx...xxxy 但不能匹配 xxx...xxxx。在某个版本的Python中，这个表达式的匹配是指数时间。(http://mail.python.org/pipermail/python-dev/2003-May/035916.html)
3. Quicksort
Quicksort的平均运行时间是O(N log N)，但可能退化为 O(N^2)，这是数据结构课程的必讲内容。C library 的 qsort 就不能保证一定是“快速”排序。(http://www.cs.dartmouth.edu/~doug/mdmspe.pdf)。C++ library 的 sort() 在改造之前，也可能退化为 O(N^2) 的龟速排序。SGI STL 的 sort() 使用了 a new, hybrid sorting algorithm, introsort (for introspective sort), that behaves almost exactly like median-of-3 quicksort for most inputs (and is just as fast) but which is capable of detecting when partitioning is tending toward quadratic behavior. By switching to heapsort in those situations, introsort achieves the same O(N logN) time bound as heapsort but is almost always faster than just using heapsort in the first place. (http://www.cs.rpi.edu/~musser/gp/algorithms.html) 。该排序算法的分析见 (http://www.cs.rpi.edu/~musser/gp/introsort.ps)
1. Hashing
我们经常使用这样的字符串的Hash函数：
// 随手写的，未严格测试
unsigned long Hash(char* str)
{
assert(NULL != str);
unsigned long hash_val = 0xDEEDBEEFul; // hash seed
unsigned char* p = (unsigned char*)str;
while (*p != '/0') {
hash_val = 37 * hash_val + *p;
++p;
}
return hash_val;
}
《程序设计实践》第3章的Markov Chain的实现就使用了几乎一摸一样的Hash函数。这个函数的优点是速度快，英文单词的Hash值的分布也不错。但是，它太简单，容易受到攻击。攻击一般有两种方案：1) 构造一个输入序列，让序列中的每个字符串彼此不同，但Hash值相同；2) 构造一个输入序列，序列中每个字符串彼此不同，Hash值也不一定相同，但是这些Hash值对所用Hash Table的buckets数目同余（即hash_val % bucket_size 相等）。这样就能让Hash Table退化为链表。从而大大增加查找时间。(http://www.cs.rice.edu/~scrosby/hash/)
要解决这个问题，需要用复杂得多的Hash函数(MD5、SHA-1)，让攻击者(几乎)无法构造出Hash值相同的序列。
2. Regular Expressions
Regular Expression Engine 一般有三种：DFA (Deterministic Finite Automaton)、traditional NFA (Nondeterministic Finite Automaton)、POSIX NFA。这三种engines的功能一个比一个强，速度一个比一个慢。(http://msdn.microsoft.com/library/en-us/cpguide/html/cpconmatchingbehavior.asp) (http://www.oreilly.com/catalog/regex/chapter/ch04.html)
DFA 速度最快，可以保证线性时间(?)。NFA需要使用backtracking(回溯)技术，以支持backreference(向前引用)，通常NFA是线性时间，但是其最坏情况是指数时间！
举例来说，表达式 (x+x+)+y 可以匹配 xxx...xxxy 但不能匹配 xxx...xxxx。在某个版本的Python中，这个表达式的匹配是指数时间。(http://mail.python.org/pipermail/python-dev/2003-May/035916.html)
3. Quicksort
Quicksort的平均运行时间是O(N log N)，但可能退化为 O(N^2)，这是数据结构课程的必讲内容。C library 的 qsort 就不能保证一定是“快速”排序。(http://www.cs.dartmouth.edu/~doug/mdmspe.pdf)。C++ library 的 sort() 在改造之前，也可能退化为 O(N^2) 的龟速排序。SGI STL 的 sort() 使用了 a new, hybrid sorting algorithm, introsort (for introspective sort), that behaves almost exactly like median-of-3 quicksort for most inputs (and is just as fast) but which is capable of detecting when partitioning is tending toward quadratic behavior. By switching to heapsort in those situations, introsort achieves the same O(N logN) time bound as heapsort but is almost always faster than just using heapsort in the first place. (http://www.cs.rpi.edu/~musser/gp/algorithms.html) 。该排序算法的分析见 (http://www.cs.rpi.edu/~musser/gp/introsort.ps)
1. Hashing
我们经常使用这样的字符串的Hash函数：
// 随手写的，未严格测试
unsigned long Hash(char* str)
{
assert(NULL != str);
unsigned long hash_val = 0xDEEDBEEFul; // hash seed
unsigned char* p = (unsigned char*)str;
while (*p != '/0') {
hash_val = 37 * hash_val + *p;
++p;
}
return hash_val;
}
《程序设计实践》第3章的Markov Chain的实现就使用了几乎一摸一样的Hash函数。这个函数的优点是速度快，英文单词的Hash值的分布也不错。但是，它太简单，容易受到攻击。攻击一般有两种方案：1) 构造一个输入序列，让序列中的每个字符串彼此不同，但Hash值相同；2) 构造一个输入序列，序列中每个字符串彼此不同，Hash值也不一定相同，但是这些Hash值对所用Hash Table的buckets数目同余（即hash_val % bucket_size 相等）。这样就能让Hash Table退化为链表。从而大大增加查找时间。(http://www.cs.rice.edu/~scrosby/hash/)
要解决这个问题，需要用复杂得多的Hash函数(MD5、SHA-1)，让攻击者(几乎)无法构造出Hash值相同的序列。
2. Regular Expressions
Regular Expression Engine 一般有三种：DFA (Deterministic Finite Automaton)、traditional NFA (Nondeterministic Finite Automaton)、POSIX NFA。这三种engines的功能一个比一个强，速度一个比一个慢。(http://msdn.microsoft.com/library/en-us/cpguide/html/cpconmatchingbehavior.asp) (http://www.oreilly.com/catalog/regex/chapter/ch04.html)
DFA 速度最快，可以保证线性时间(?)。NFA需要使用backtracking(回溯)技术，以支持backreference(向前引用)，通常NFA是线性时间，但是其最坏情况是指数时间！
举例来说，表达式 (x+x+)+y 可以匹配 xxx...xxxy 但不能匹配 xxx...xxxx。在某个版本的Python中，这个表达式的匹配是指数时间。(http://mail.python.org/pipermail/python-dev/2003-May/035916.html)
3. Quicksort
Quicksort的平均运行时间是O(N log N)，但可能退化为 O(N^2)，这是数据结构课程的必讲内容。C library 的 qsort 就不能保证一定是“快速”排序。(http://www.cs.dartmouth.edu/~doug/mdmspe.pdf)。C++ library 的 sort() 在改造之前，也可能退化为 O(N^2) 的龟速排序。SGI STL 的 sort() 使用了 a new, hybrid sorting algorithm, introsort (for introspective sort), that behaves almost exactly like median-of-3 quicksort for most inputs (and is just as fast) but which is capable of detecting when partitioning is tending toward quadratic behavior. By switching to heapsort in those situations, introsort achieves the same O(N logN) time bound as heapsort but is almost always faster than just using heapsort in the first place. (http://www.cs.rpi.edu/~musser/gp/algorithms.html) 。该排序算法的分析见 (http://www.cs.rpi.edu/~musser/gp/introsort.ps)
1. Hashing
我们经常使用这样的字符串的Hash函数：
// 随手写的，未严格测试
unsigned long Hash(char* str)
{
assert(NULL != str);
unsigned long hash_val = 0xDEEDBEEFul; // hash seed
unsigned char* p = (unsigned char*)str;
while (*p != '/0') {
hash_val = 37 * hash_val + *p;
++p;
}
return hash_val;
}
《程序设计实践》第3章的Markov Chain的实现就使用了几乎一摸一样的Hash函数。这个函数的优点是速度快，英文单词的Hash值的分布也不错。但是，它太简单，容易受到攻击。攻击一般有两种方案：1) 构造一个输入序列，让序列中的每个字符串彼此不同，但Hash值相同；2) 构造一个输入序列，序列中每个字符串彼此不同，Hash值也不一定相同，但是这些Hash值对所用Hash Table的buckets数目同余（即hash_val % bucket_size 相等）。这样就能让Hash Table退化为链表。从而大大增加查找时间。(http://www.cs.rice.edu/~scrosby/hash/)
要解决这个问题，需要用复杂得多的Hash函数(MD5、SHA-1)，让攻击者(几乎)无法构造出Hash值相同的序列。
2. Regular Expressions
Regular Expression Engine 一般有三种：DFA (Deterministic Finite Automaton)、traditional NFA (Nondeterministic Finite Automaton)、POSIX NFA。这三种engines的功能一个比一个强，速度一个比一个慢。(http://msdn.microsoft.com/library/en-us/cpguide/html/cpconmatchingbehavior.asp) (http://www.oreilly.com/catalog/regex/chapter/ch04.html)
DFA 速度最快，可以保证线性时间(?)。NFA需要使用backtracking(回溯)技术，以支持backreference(向前引用)，通常NFA是线性时间，但是其最坏情况是指数时间！
举例来说，表达式 (x+x+)+y 可以匹配 xxx...xxxy 但不能匹配 xxx...xxxx。在某个版本的Python中，这个表达式的匹配是指数时间。(http://mail.python.org/pipermail/python-dev/2003-May/035916.html)
3. Quicksort
Quicksort的平均运行时间是O(N log N)，但可能退化为 O(N^2)，这是数据结构课程的必讲内容。C library 的 qsort 就不能保证一定是“快速”排序。(http://www.cs.dartmouth.edu/~doug/mdmspe.pdf)。C++ library 的 sort() 在改造之前，也可能退化为 O(N^2) 的龟速排序。SGI STL 的 sort() 使用了 a new, hybrid sorting algorithm, introsort (for introspective sort), that behaves almost exactly like median-of-3 quicksort for most inputs (and is just as fast) but which is capable of detecting when partitioning is tending toward quadratic behavior. By switching to heapsort in those situations, introsort achieves the same O(N logN) time bound as heapsort but is almost always faster than just using heapsort in the first place. (http://www.cs.rpi.edu/~musser/gp/algorithms.html) 。该排序算法的分析见 (http://www.cs.rpi.edu/~musser/gp/introsort.ps)
1. Hashing
我们经常使用这样的字符串的Hash函数：
// 随手写的，未严格测试
unsigned long Hash(char* str)
{
assert(NULL != str);
unsigned long hash_val = 0xDEEDBEEFul; // hash seed
unsigned char* p = (unsigned char*)str;
while (*p != '/0') {
hash_val = 37 * hash_val + *p;
++p;
}
return hash_val;
}
《程序设计实践》第3章的Markov Chain的实现就使用了几乎一摸一样的Hash函数。这个函数的优点是速度快，英文单词的Hash值的分布也不错。但是，它太简单，容易受到攻击。攻击一般有两种方案：1) 构造一个输入序列，让序列中的每个字符串彼此不同，但Hash值相同；2) 构造一个输入序列，序列中每个字符串彼此不同，Hash值也不一定相同，但是这些Hash值对所用Hash Table的buckets数目同余（即hash_val % bucket_size 相等）。这样就能让Hash Table退化为链表。从而大大增加查找时间。(http://www.cs.rice.edu/~scrosby/hash/)
要解决这个问题，需要用复杂得多的Hash函数(MD5、SHA-1)，让攻击者(几乎)无法构造出Hash值相同的序列。
2. Regular Expressions
Regular Expression Engine 一般有三种：DFA (Deterministic Finite Automaton)、traditional NFA (Nondeterministic Finite Automaton)、POSIX NFA。这三种engines的功能一个比一个强，速度一个比一个慢。(http://msdn.microsoft.com/library/en-us/cpguide/html/cpconmatchingbehavior.asp) (http://www.oreilly.com/catalog/regex/chapter/ch04.html)
DFA 速度最快，可以保证线性时间(?)。NFA需要使用backtracking(回溯)技术，以支持backreference(向前引用)，通常NFA是线性时间，但是其最坏情况是指数时间！
举例来说，表达式 (x+x+)+y 可以匹配 xxx...xxxy 但不能匹配 xxx...xxxx。在某个版本的Python中，这个表达式的匹配是指数时间。(http://mail.python.org/pipermail/python-dev/2003-May/035916.html)
3. Quicksort
Quicksort的平均运行时间是O(N log N)，但可能退化为 O(N^2)，这是数据结构课程的必讲内容。C library 的 qsort 就不能保证一定是“快速”排序。(http://www.cs.dartmouth.edu/~doug/mdmspe.pdf)。C++ library 的 sort() 在改造之前，也可能退化为 O(N^2) 的龟速排序。SGI STL 的 sort() 使用了 a new, hybrid sorting algorithm, introsort (for introspective sort), that behaves almost exactly like median-of-3 quicksort for most inputs (and is just as fast) but which is capable of detecting when partitioning is tending toward quadratic behavior. By switching to heapsort in those situations, introsort achieves the same O(N logN) time bound as heapsort but is almost always faster than just using heapsort in the first place. (http://www.cs.rpi.edu/~musser/gp/algorithms.html) 。该排序算法的分析见 (http://www.cs.rpi.edu/~musser/gp/introsort.ps)
1. Hashing
我们经常使用这样的字符串的Hash函数：
// 随手写的，未严格测试
unsigned long Hash(char* str)
{
assert(NULL != str);
unsigned long hash_val = 0xDEEDBEEFul; // hash seed
unsigned char* p = (unsigned char*)str;
while (*p != '/0') {
hash_val = 37 * hash_val + *p;
++p;
}
return hash_val;
}
《程序设计实践》第3章的Markov Chain的实现就使用了几乎一摸一样的Hash函数。这个函数的优点是速度快，英文单词的Hash值的分布也不错。但是，它太简单，容易受到攻击。攻击一般有两种方案：1) 构造一个输入序列，让序列中的每个字符串彼此不同，但Hash值相同；2) 构造一个输入序列，序列中每个字符串彼此不同，Hash值也不一定相同，但是这些Hash值对所用Hash Table的buckets数目同余（即hash_val % bucket_size 相等）。这样就能让Hash Table退化为链表。从而大大增加查找时间。(http://www.cs.rice.edu/~scrosby/hash/)
要解决这个问题，需要用复杂得多的Hash函数(MD5、SHA-1)，让攻击者(几乎)无法构造出Hash值相同的序列。
2. Regular Expressions
Regular Expression Engine 一般有三种：DFA (Deterministic Finite Automaton)、traditional NFA (Nondeterministic Finite Automaton)、POSIX NFA。这三种engines的功能一个比一个强，速度一个比一个慢。(http://msdn.microsoft.com/library/en-us/cpguide/html/cpconmatchingbehavior.asp) (http://www.oreilly.com/catalog/regex/chapter/ch04.html)
DFA 速度最快，可以保证线性时间(?)。NFA需要使用backtracking(回溯)技术，以支持backreference(向前引用)，通常NFA是线性时间，但是其最坏情况是指数时间！
举例来说，表达式 (x+x+)+y 可以匹配 xxx...xxxy 但不能匹配 xxx...xxxx。在某个版本的Python中，这个表达式的匹配是指数时间。(http://mail.python.org/pipermail/python-dev/2003-May/035916.html)
3. Quicksort
Quicksort的平均运行时间是O(N log N)，但可能退化为 O(N^2)，这是数据结构课程的必讲内容。C library 的 qsort 就不能保证一定是“快速”排序。(http://www.cs.dartmouth.edu/~doug/mdmspe.pdf)。C++ library 的 sort() 在改造之前，也可能退化为 O(N^2) 的龟速排序。SGI STL 的 sort() 使用了 a new, hybrid sorting algorithm, introsort (for introspective sort), that behaves almost exactly like median-of-3 quicksort for most inputs (and is just as fast) but which is capable of detecting when partitioning is tending toward quadratic behavior. By switching to heapsort in those situations, introsort achieves the same O(N logN) time bound as heapsort but is almost always faster than just using heapsort in the first place. (http://www.cs.rpi.edu/~musser/gp/algorithms.html) 。该排序算法的分析见 (http://www.cs.rpi.edu/~musser/gp/introsort.ps)
1. Hashing
我们经常使用这样的字符串的Hash函数：
// 随手写的，未严格测试
unsigned long Hash(char* str)
{
assert(NULL != str);
unsigned long hash_val = 0xDEEDBEEFul; // hash seed
unsigned char* p = (unsigned char*)str;
while (*p != '/0') {
hash_val = 37 * hash_val + *p;
++p;
}
return hash_val;
}
《程序设计实践》第3章的Markov Chain的实现就使用了几乎一摸一样的Hash函数。这个函数的优点是速度快，英文单词的Hash值的分布也不错。但是，它太简单，容易受到攻击。攻击一般有两种方案：1) 构造一个输入序列，让序列中的每个字符串彼此不同，但Hash值相同；2) 构造一个输入序列，序列中每个字符串彼此不同，Hash值也不一定相同，但是这些Hash值对所用Hash Table的buckets数目同余（即hash_val % bucket_size 相等）。这样就能让Hash Table退化为链表。从而大大增加查找时间。(http://www.cs.rice.edu/~scrosby/hash/)
要解决这个问题，需要用复杂得多的Hash函数(MD5、SHA-1)，让攻击者(几乎)无法构造出Hash值相同的序列。
2. Regular Expressions
Regular Expression Engine 一般有三种：DFA (Deterministic Finite Automaton)、traditional NFA (Nondeterministic Finite Automaton)、POSIX NFA。这三种engines的功能一个比一个强，速度一个比一个慢。(http://msdn.microsoft.com/library/en-us/cpguide/html/cpconmatchingbehavior.asp) (http://www.oreilly.com/catalog/regex/chapter/ch04.html)
DFA 速度最快，可以保证线性时间(?)。NFA需要使用backtracking(回溯)技术，以支持backreference(向前引用)，通常NFA是线性时间，但是其最坏情况是指数时间！
举例来说，表达式 (x+x+)+y 可以匹配 xxx...xxxy 但不能匹配 xxx...xxxx。在某个版本的Python中，这个表达式的匹配是指数时间。(http://mail.python.org/pipermail/python-dev/2003-May/035916.html)
3. Quicksort
Quicksort的平均运行时间是O(N log N)，但可能退化为 O(N^2)，这是数据结构课程的必讲内容。C library 的 qsort 就不能保证一定是“快速”排序。(http://www.cs.dartmouth.edu/~doug/mdmspe.pdf)。C++ library 的 sort() 在改造之前，也可能退化为 O(N^2) 的龟速排序。SGI STL 的 sort() 使用了 a new, hybrid sorting algorithm, introsort (for introspective sort), that behaves almost exactly like median-of-3 quicksort for most inputs (and is just as fast) but which is capable of detecting when partitioning is tending toward quadratic behavior. By switching to heapsort in those situations, introsort achieves the same O(N logN) time bound as heapsort but is almost always faster than just using heapsort in the first place. (http://www.cs.rpi.edu/~musser/gp/algorithms.html) 。该排序算法的分析见 (http://www.cs.rpi.edu/~musser/gp/introsort.ps)
1. Hashing
我们经常使用这样的字符串的Hash函数：
// 随手写的，未严格测试
unsigned long Hash(char* str)
{
assert(NULL != str);
unsigned long hash_val = 0xDEEDBEEFul; // hash seed
unsigned char* p = (unsigned char*)str;
while (*p != '/0') {
hash_val = 37 * hash_val + *p;
++p;
}
return hash_val;
}
《程序设计实践》第3章的Markov Chain的实现就使用了几乎一摸一样的Hash函数。这个函数的优点是速度快，英文单词的Hash值的分布也不错。但是，它太简单，容易受到攻击。攻击一般有两种方案：1) 构造一个输入序列，让序列中的每个字符串彼此不同，但Hash值相同；2) 构造一个输入序列，序列中每个字符串彼此不同，Hash值也不一定相同，但是这些Hash值对所用Hash Table的buckets数目同余（即hash_val % bucket_size 相等）。这样就能让Hash Table退化为链表。从而大大增加查找时间。(http://www.cs.rice.edu/~scrosby/hash/)
要解决这个问题，需要用复杂得多的Hash函数(MD5、SHA-1)，让攻击者(几乎)无法构造出Hash值相同的序列。
2. Regular Expressions
Regular Expression Engine 一般有三种：DFA (Deterministic Finite Automaton)、traditional NFA (Nondeterministic Finite Automaton)、POSIX NFA。这三种engines的功能一个比一个强，速度一个比一个慢。(http://msdn.microsoft.com/library/en-us/cpguide/html/cpconmatchingbehavior.asp) (http://www.oreilly.com/catalog/regex/chapter/ch04.html)
DFA 速度最快，可以保证线性时间(?)。NFA需要使用backtracking(回溯)技术，以支持backreference(向前引用)，通常NFA是线性时间，但是其最坏情况是指数时间！
举例来说，表达式 (x+x+)+y 可以匹配 xxx...xxxy 但不能匹配 xxx...xxxx。在某个版本的Python中，这个表达式的匹配是指数时间。(http://mail.python.org/pipermail/python-dev/2003-May/035916.html)
3. Quicksort
Quicksort的平均运行时间是O(N log N)，但可能退化为 O(N^2)，这是数据结构课程的必讲内容。C library 的 qsort 就不能保证一定是“快速”排序。(http://www.cs.dartmouth.edu/~doug/mdmspe.pdf)。C++ library 的 sort() 在改造之前，也可能退化为 O(N^2) 的龟速排序。SGI STL 的 sort() 使用了 a new, hybrid sorting algorithm, introsort (for introspective sort), that behaves almost exactly like median-of-3 quicksort for most inputs (and is just as fast) but which is capable of detecting when partitioning is tending toward quadratic behavior. By switching to heapsort in those situations, introsort achieves the same O(N logN) time bound as heapsort but is almost always faster than just using heapsort in the first place. (http://www.cs.rpi.edu/~musser/gp/algorithms.html) 。该排序算法的分析见 (http://www.cs.rpi.edu/~musser/gp/introsort.ps)
1. Hashing
我们经常使用这样的字符串的Hash函数：
// 随手写的，未严格测试
unsigned long Hash(char* str)
{
assert(NULL != str);
unsigned long hash_val = 0xDEEDBEEFul; // hash seed
unsigned char* p = (unsigned char*)str;
while (*p != '/0') {
hash_val = 37 * hash_val + *p;
++p;
}
return hash_val;
}
《程序设计实践》第3章的Markov Chain的实现就使用了几乎一摸一样的Hash函数。这个函数的优点是速度快，英文单词的Hash值的分布也不错。但是，它太简单，容易受到攻击。攻击一般有两种方案：1) 构造一个输入序列，让序列中的每个字符串彼此不同，但Hash值相同；2) 构造一个输入序列，序列中每个字符串彼此不同，Hash值也不一定相同，但是这些Hash值对所用Hash Table的buckets数目同余（即hash_val % bucket_size 相等）。这样就能让Hash Table退化为链表。从而大大增加查找时间。(http://www.cs.rice.edu/~scrosby/hash/)
要解决这个问题，需要用复杂得多的Hash函数(MD5、SHA-1)，让攻击者(几乎)无法构造出Hash值相同的序列。
2. Regular Expressions
Regular Expression Engine 一般有三种：DFA (Deterministic Finite Automaton)、traditional NFA (Nondeterministic Finite Automaton)、POSIX NFA。这三种engines的功能一个比一个强，速度一个比一个慢。(http://msdn.microsoft.com/library/en-us/cpguide/html/cpconmatchingbehavior.asp) (http://www.oreilly.com/catalog/regex/chapter/ch04.html)
DFA 速度最快，可以保证线性时间(?)。NFA需要使用backtracking(回溯)技术，以支持backreference(向前引用)，通常NFA是线性时间，但是其最坏情况是指数时间！
举例来说，表达式 (x+x+)+y 可以匹配 xxx...xxxy 但不能匹配 xxx...xxxx。在某个版本的Python中，这个表达式的匹配是指数时间。(http://mail.python.org/pipermail/python-dev/2003-May/035916.html)
3. Quicksort
Quicksort的平均运行时间是O(N log N)，但可能退化为 O(N^2)，这是数据结构课程的必讲内容。C library 的 qsort 就不能保证一定是“快速”排序。(http://www.cs.dartmouth.edu/~doug/mdmspe.pdf)。C++ library 的 sort() 在改造之前，也可能退化为 O(N^2) 的龟速排序。SGI STL 的 sort() 使用了 a new, hybrid sorting algorithm, introsort (for introspective sort), that behaves almost exactly like median-of-3 quicksort for most inputs (and is just as fast) but which is capable of detecting when partitioning is tending toward quadratic behavior. By switching to heapsort in those situations, introsort achieves the same O(N logN) time bound as heapsort but is almost always faster than just using heapsort in the first place. (http://www.cs.rpi.edu/~musser/gp/algorithms.html) 。该排序算法的分析见 (http://www.cs.rpi.edu/~musser/gp/introsort.ps)
1. Hashing
我们经常使用这样的字符串的Hash函数：
// 随手写的，未严格测试
unsigned long Hash(char* str)
{
assert(NULL != str);
unsigned long hash_val = 0xDEEDBEEFul; // hash seed
unsigned char* p = (unsigned char*)str;
while (*p != '/0') {
hash_val = 37 * hash_val + *p;
++p;
}
return hash_val;
}
《程序设计实践》第3章的Markov Chain的实现就使用了几乎一摸一样的Hash函数。这个函数的优点是速度快，英文单词的Hash值的分布也不错。但是，它太简单，容易受到攻击。攻击一般有两种方案：1) 构造一个输入序列，让序列中的每个字符串彼此不同，但Hash值相同；2) 构造一个输入序列，序列中每个字符串彼此不同，Hash值也不一定相同，但是这些Hash值对所用Hash Table的buckets数目同余（即hash_val % bucket_size 相等）。这样就能让Hash Table退化为链表。从而大大增加查找时间。(http://www.cs.rice.edu/~scrosby/hash/)
要解决这个问题，需要用复杂得多的Hash函数(MD5、SHA-1)，让攻击者(几乎)无法构造出Hash值相同的序列。
2. Regular Expressions
Regular Expression Engine 一般有三种：DFA (Deterministic Finite Automaton)、traditional NFA (Nondeterministic Finite Automaton)、POSIX NFA。这三种engines的功能一个比一个强，速度一个比一个慢。(http://msdn.microsoft.com/library/en-us/cpguide/html/cpconmatchingbehavior.asp) (http://www.oreilly.com/catalog/regex/chapter/ch04.html)
DFA 速度最快，可以保证线性时间(?)。NFA需要使用backtracking(回溯)技术，以支持backreference(向前引用)，通常NFA是线性时间，但是其最坏情况是指数时间！
举例来说，表达式 (x+x+)+y 可以匹配 xxx...xxxy 但不能匹配 xxx...xxxx。在某个版本的Python中，这个表达式的匹配是指数时间。(http://mail.python.org/pipermail/python-dev/2003-May/035916.html)
3. Quicksort
Quicksort的平均运行时间是O(N log N)，但可能退化为 O(N^2)，这是数据结构课程的必讲内容。C library 的 qsort 就不能保证一定是“快速”排序。(http://www.cs.dartmouth.edu/~doug/mdmspe.pdf)。C++ library 的 sort() 在改造之前，也可能退化为 O(N^2) 的龟速排序。SGI STL 的 sort() 使用了 a new, hybrid sorting algorithm, introsort (for introspective sort), that behaves almost exactly like median-of-3 quicksort for most inputs (and is just as fast) but which is capable of detecting when partitioning is tending toward quadratic behavior. By switching to heapsort in those situations, introsort achieves the same O(N logN) time bound as heapsort but is almost always faster than just using heapsort in the first place. (http://www.cs.rpi.edu/~musser/gp/algorithms.html) 。该排序算法的分析见 (http://www.cs.rpi.edu/~musser/gp/introsort.ps)
1. Hashing
我们经常使用这样的字符串的Hash函数：
// 随手写的，未严格测试
unsigned long Hash(char* str)
{
assert(NULL != str);
unsigned long hash_val = 0xDEEDBEEFul; // hash seed
unsigned char* p = (unsigned char*)str;
while (*p != '/0') {
hash_val = 37 * hash_val + *p;
++p;
}
return hash_val;
}
《程序设计实践》第3章的Markov Chain的实现就使用了几乎一摸一样的Hash函数。这个函数的优点是速度快，英文单词的Hash值的分布也不错。但是，它太简单，容易受到攻击。攻击一般有两种方案：1) 构造一个输入序列，让序列中的每个字符串彼此不同，但Hash值相同；2) 构造一个输入序列，序列中每个字符串彼此不同，Hash值也不一定相同，但是这些Hash值对所用Hash Table的buckets数目同余（即hash_val % bucket_size 相等）。这样就能让Hash Table退化为链表。从而大大增加查找时间。(http://www.cs.rice.edu/~scrosby/hash/)
要解决这个问题，需要用复杂得多的Hash函数(MD5、SHA-1)，让攻击者(几乎)无法构造出Hash值相同的序列。
2. Regular Expressions
Regular Expression Engine 一般有三种：DFA (Deterministic Finite Automaton)、traditional NFA (Nondeterministic Finite Automaton)、POSIX NFA。这三种engines的功能一个比一个强，速度一个比一个慢。(http://msdn.microsoft.com/library/en-us/cpguide/html/cpconmatchingbehavior.asp) (http://www.oreilly.com/catalog/regex/chapter/ch04.html)
DFA 速度最快，可以保证线性时间(?)。NFA需要使用backtracking(回溯)技术，以支持backreference(向前引用)，通常NFA是线性时间，但是其最坏情况是指数时间！
举例来说，表达式 (x+x+)+y 可以匹配 xxx...xxxy 但不能匹配 xxx...xxxx。在某个版本的Python中，这个表达式的匹配是指数时间。(http://mail.python.org/pipermail/python-dev/2003-May/035916.html)
3. Quicksort
Quicksort的平均运行时间是O(N log N)，但可能退化为 O(N^2)，这是数据结构课程的必讲内容。C library 的 qsort 就不能保证一定是“快速”排序。(http://www.cs.dartmouth.edu/~doug/mdmspe.pdf)。C++ library 的 sort() 在改造之前，也可能退化为 O(N^2) 的龟速排序。SGI STL 的 sort() 使用了 a new, hybrid sorting algorithm, introsort (for introspective sort), that behaves almost exactly like median-of-3 quicksort for most inputs (and is just as fast) but which is capable of detecting when partitioning is tending toward quadratic behavior. By switching to heapsort in those situations, introsort achieves the same O(N logN) time bound as heapsort but is almost always faster than just using heapsort in the first place. (http://www.cs.rpi.edu/~musser/gp/algorithms.html) 。该排序算法的分析见 (http://www.cs.rpi.edu/~musser/gp/introsort.ps)
1. Hashing
我们经常使用这样的字符串的Hash函数：
// 随手写的，未严格测试
unsigned long Hash(char* str)
{
assert(NULL != str);
unsigned long hash_val = 0xDEEDBEEFul; // hash seed
unsigned char* p = (unsigned char*)str;
while (*p != '/0') {
hash_val = 37 * hash_val + *p;
++p;
}
return hash_val;
}
《程序设计实践》第3章的Markov Chain的实现就使用了几乎一摸一样的Hash函数。这个函数的优点是速度快，英文单词的Hash值的分布也不错。但是，它太简单，容易受到攻击。攻击一般有两种方案：1) 构造一个输入序列，让序列中的每个字符串彼此不同，但Hash值相同；2) 构造一个输入序列，序列中每个字符串彼此不同，Hash值也不一定相同，但是这些Hash值对所用Hash Table的buckets数目同余（即hash_val % bucket_size 相等）。这样就能让Hash Table退化为链表。从而大大增加查找时间。(http://www.cs.rice.edu/~scrosby/hash/)
要解决这个问题，需要用复杂得多的Hash函数(MD5、SHA-1)，让攻击者(几乎)无法构造出Hash值相同的序列。
2. Regular Expressions
Regular Expression Engine 一般有三种：DFA (Deterministic Finite Automaton)、traditional NFA (Nondeterministic Finite Automaton)、POSIX NFA。这三种engines的功能一个比一个强，速度一个比一个慢。(http://msdn.microsoft.com/library/en-us/cpguide/html/cpconmatchingbehavior.asp) (http://www.oreilly.com/catalog/regex/chapter/ch04.html)
DFA 速度最快，可以保证线性时间(?)。NFA需要使用backtracking(回溯)技术，以支持backreference(向前引用)，通常NFA是线性时间，但是其最坏情况是指数时间！
举例来说，表达式 (x+x+)+y 可以匹配 xxx...xxxy 但不能匹配 xxx...xxxx。在某个版本的Python中，这个表达式的匹配是指数时间。(http://mail.python.org/pipermail/python-dev/2003-May/035916.html)
3. Quicksort
Quicksort的平均运行时间是O(N log N)，但可能退化为 O(N^2)，这是数据结构课程的必讲内容。C library 的 qsort 就不能保证一定是“快速”排序。(http://www.cs.dartmouth.edu/~doug/mdmspe.pdf)。C++ library 的 sort() 在改造之前，也可能退化为 O(N^2) 的龟速排序。SGI STL 的 sort() 使用了 a new, hybrid sorting algorithm, introsort (for introspective sort), that behaves almost exactly like median-of-3 quicksort for most inputs (and is just as fast) but which is capable of detecting when partitioning is tending toward quadratic behavior. By switching to heapsort in those situations, introsort achieves the same O(N logN) time bound as heapsort but is almost always faster than just using heapsort in the first place. (http://www.cs.rpi.edu/~musser/gp/algorithms.html) 。该排序算法的分析见 (http://www.cs.rpi.edu/~musser/gp/introsort.ps)
1. Hashing
我们经常使用这样的字符串的Hash函数：
// 随手写的，未严格测试
unsigned long Hash(char* str)
{
assert(NULL != str);
unsigned long hash_val = 0xDEEDBEEFul; // hash seed
unsigned char* p = (unsigned char*)str;
while (*p != '/0') {
hash_val = 37 * hash_val + *p;
++p;
}
return hash_val;
}
《程序设计实践》第3章的Markov Chain的实现就使用了几乎一摸一样的Hash函数。这个函数的优点是速度快，英文单词的Hash值的分布也不错。但是，它太简单，容易受到攻击。攻击一般有两种方案：1) 构造一个输入序列，让序列中的每个字符串彼此不同，但Hash值相同；2) 构造一个输入序列，序列中每个字符串彼此不同，Hash值也不一定相同，但是这些Hash值对所用Hash Table的buckets数目同余（即hash_val % bucket_size 相等）。这样就能让Hash Table退化为链表。从而大大增加查找时间。(http://www.cs.rice.edu/~scrosby/hash/)
要解决这个问题，需要用复杂得多的Hash函数(MD5、SHA-1)，让攻击者(几乎)无法构造出Hash值相同的序列。
2. Regular Expressions
Regular Expression Engine 一般有三种：DFA (Deterministic Finite Automaton)、traditional NFA (Nondeterministic Finite Automaton)、POSIX NFA。这三种engines的功能一个比一个强，速度一个比一个慢。(http://msdn.microsoft.com/library/en-us/cpguide/html/cpconmatchingbehavior.asp) (http://www.oreilly.com/catalog/regex/chapter/ch04.html)
DFA 速度最快，可以保证线性时间(?)。NFA需要使用backtracking(回溯)技术，以支持backreference(向前引用)，通常NFA是线性时间，但是其最坏情况是指数时间！
举例来说，表达式 (x+x+)+y 可以匹配 xxx...xxxy 但不能匹配 xxx...xxxx。在某个版本的Python中，这个表达式的匹配是指数时间。(http://mail.python.org/pipermail/python-dev/2003-May/035916.html)
3. Quicksort
Quicksort的平均运行时间是O(N log N)，但可能退化为 O(N^2)，这是数据结构课程的必讲内容。C library 的 qsort 就不能保证一定是“快速”排序。(http://www.cs.dartmouth.edu/~doug/mdmspe.pdf)。C++ library 的 sort() 在改造之前，也可能退化为 O(N^2) 的龟速排序。SGI STL 的 sort() 使用了 a new, hybrid sorting algorithm, introsort (for introspective sort), that behaves almost exactly like median-of-3 quicksort for most inputs (and is just as fast) but which is capable of detecting when partitioning is tending toward quadratic behavior. By switching to heapsort in those situations, introsort achieves the same O(N logN) time bound as heapsort but is almost always faster than just using heapsort in the first place. (http://www.cs.rpi.edu/~musser/gp/algorithms.html) 。该排序算法的分析见 (http://www.cs.rpi.edu/~musser/gp/introsort.ps)
1. Hashing
我们经常使用这样的字符串的Hash函数：
// 随手写的，未严格测试
unsigned long Hash(char* str)
{
assert(NULL != str);
unsigned long hash_val = 0xDEEDBEEFul; // hash seed
unsigned char* p = (unsigned char*)str;
while (*p != '/0') {
hash_val = 37 * hash_val + *p;
++p;
}
return hash_val;
}
《程序设计实践》第3章的Markov Chain的实现就使用了几乎一摸一样的Hash函数。这个函数的优点是速度快，英文单词的Hash值的分布也不错。但是，它太简单，容易受到攻击。攻击一般有两种方案：1) 构造一个输入序列，让序列中的每个字符串彼此不同，但Hash值相同；2) 构造一个输入序列，序列中每个字符串彼此不同，Hash值也不一定相同，但是这些Hash值对所用Hash Table的buckets数目同余（即hash_val % bucket_size 相等）。这样就能让Hash Table退化为链表。从而大大增加查找时间。(http://www.cs.rice.edu/~scrosby/hash/)
要解决这个问题，需要用复杂得多的Hash函数(MD5、SHA-1)，让攻击者(几乎)无法构造出Hash值相同的序列。
2. Regular Expressions
Regular Expression Engine 一般有三种：DFA (Deterministic Finite Automaton)、traditional NFA (Nondeterministic Finite Automaton)、POSIX NFA。这三种engines的功能一个比一个强，速度一个比一个慢。(http://msdn.microsoft.com/library/en-us/cpguide/html/cpconmatchingbehavior.asp) (http://www.oreilly.com/catalog/regex/chapter/ch04.html)
DFA 速度最快，可以保证线性时间(?)。NFA需要使用backtracking(回溯)技术，以支持backreference(向前引用)，通常NFA是线性时间，但是其最坏情况是指数时间！
举例来说，表达式 (x+x+)+y 可以匹配 xxx...xxxy 但不能匹配 xxx...xxxx。在某个版本的Python中，这个表达式的匹配是指数时间。(http://mail.python.org/pipermail/python-dev/2003-May/035916.html)
3. Quicksort
Quicksort的平均运行时间是O(N log N)，但可能退化为 O(N^2)，这是数据结构课程的必讲内容。C library 的 qsort 就不能保证一定是“快速”排序。(http://www.cs.dartmouth.edu/~doug/mdmspe.pdf)。C++ library 的 sort() 在改造之前，也可能退化为 O(N^2) 的龟速排序。SGI STL 的 sort() 使用了 a new, hybrid sorting algorithm, introsort (for introspective sort), that behaves almost exactly like median-of-3 quicksort for most inputs (and is just as fast) but which is capable of detecting when partitioning is tending toward quadratic behavior. By switching to heapsort in those situations, introsort achieves the same O(N logN) time bound as heapsort but is almost always faster than just using heapsort in the first place. (http://www.cs.rpi.edu/~musser/gp/algorithms.html) 。该排序算法的分析见 (http://www.cs.rpi.edu/~musser/gp/introsort.ps)
1. Hashing
我们经常使用这样的字符串的Hash函数：
// 随手写的，未严格测试
unsigned long Hash(char* str)
{
assert(NULL != str);
unsigned long hash_val = 0xDEEDBEEFul; // hash seed
unsigned char* p = (unsigned char*)str;
while (*p != '/0') {
hash_val = 37 * hash_val + *p;
++p;
}
return hash_val;
}
《程序设计实践》第3章的Markov Chain的实现就使用了几乎一摸一样的Hash函数。这个函数的优点是速度快，英文单词的Hash值的分布也不错。但是，它太简单，容易受到攻击。攻击一般有两种方案：1) 构造一个输入序列，让序列中的每个字符串彼此不同，但Hash值相同；2) 构造一个输入序列，序列中每个字符串彼此不同，Hash值也不一定相同，但是这些Hash值对所用Hash Table的buckets数目同余（即hash_val % bucket_size 相等）。这样就能让Hash Table退化为链表。从而大大增加查找时间。(http://www.cs.rice.edu/~scrosby/hash/)
要解决这个问题，需要用复杂得多的Hash函数(MD5、SHA-1)，让攻击者(几乎)无法构造出Hash值相同的序列。
2. Regular Expressions
Regular Expression Engine 一般有三种：DFA (Deterministic Finite Automaton)、traditional NFA (Nondeterministic Finite Automaton)、POSIX NFA。这三种engines的功能一个比一个强，速度一个比一个慢。(http://msdn.microsoft.com/library/en-us/cpguide/html/cpconmatchingbehavior.asp) (http://www.oreilly.com/catalog/regex/chapter/ch04.html)
DFA 速度最快，可以保证线性时间(?)。NFA需要使用backtracking(回溯)技术，以支持backreference(向前引用)，通常NFA是线性时间，但是其最坏情况是指数时间！
举例来说，表达式 (x+x+)+y 可以匹配 xxx...xxxy 但不能匹配 xxx...xxxx。在某个版本的Python中，这个表达式的匹配是指数时间。(http://mail.python.org/pipermail/python-dev/2003-May/035916.html)
3. Quicksort
Quicksort的平均运行时间是O(N log N)，但可能退化为 O(N^2)，这是数据结构课程的必讲内容。C library 的 qsort 就不能保证一定是“快速”排序。(http://www.cs.dartmouth.edu/~doug/mdmspe.pdf)。C++ library 的 sort() 在改造之前，也可能退化为 O(N^2) 的龟速排序。SGI STL 的 sort() 使用了 a new, hybrid sorting algorithm, introsort (for introspective sort), that behaves almost exactly like median-of-3 quicksort for most inputs (and is just as fast) but which is capable of detecting when partitioning is tending toward quadratic behavior. By switching to heapsort in those situations, introsort achieves the same O(N logN) time bound as heapsort but is almost always faster than just using heapsort in the first place. (http://www.cs.rpi.edu/~musser/gp/algorithms.html) 。该排序算法的分析见 (http://www.cs.rpi.edu/~musser/gp/introsort.ps)
1. Hashing
我们经常使用这样的字符串的Hash函数：
// 随手写的，未严格测试
unsigned long Hash(char* str)
{
assert(NULL != str);
unsigned long hash_val = 0xDEEDBEEFul; // hash seed
unsigned char* p = (unsigned char*)str;
while (*p != '/0') {
hash_val = 37 * hash_val + *p;
++p;
}
return hash_val;
}
《程序设计实践》第3章的Markov Chain的实现就使用了几乎一摸一样的Hash函数。这个函数的优点是速度快，英文单词的Hash值的分布也不错。但是，它太简单，容易受到攻击。攻击一般有两种方案：1) 构造一个输入序列，让序列中的每个字符串彼此不同，但Hash值相同；2) 构造一个输入序列，序列中每个字符串彼此不同，Hash值也不一定相同，但是这些Hash值对所用Hash Table的buckets数目同余（即hash_val % bucket_size 相等）。这样就能让Hash Table退化为链表。从而大大增加查找时间。(http://www.cs.rice.edu/~scrosby/hash/)
要解决这个问题，需要用复杂得多的Hash函数(MD5、SHA-1)，让攻击者(几乎)无法构造出Hash值相同的序列。
2. Regular Expressions
Regular Expression Engine 一般有三种：DFA (Deterministic Finite Automaton)、traditional NFA (Nondeterministic Finite Automaton)、POSIX NFA。这三种engines的功能一个比一个强，速度一个比一个慢。(http://msdn.microsoft.com/library/en-us/cpguide/html/cpconmatchingbehavior.asp) (http://www.oreilly.com/catalog/regex/chapter/ch04.html)
DFA 速度最快，可以保证线性时间(?)。NFA需要使用backtracking(回溯)技术，以支持backreference(向前引用)，通常NFA是线性时间，但是其最坏情况是指数时间！
举例来说，表达式 (x+x+)+y 可以匹配 xxx...xxxy 但不能匹配 xxx...xxxx。在某个版本的Python中，这个表达式的匹配是指数时间。(http://mail.python.org/pipermail/python-dev/2003-May/035916.html)
3. Quicksort
Quicksort的平均运行时间是O(N log N)，但可能退化为 O(N^2)，这是数据结构课程的必讲内容。C library 的 qsort 就不能保证一定是“快速”排序。(http://www.cs.dartmouth.edu/~doug/mdmspe.pdf)。C++ library 的 sort() 在改造之前，也可能退化为 O(N^2) 的龟速排序。SGI STL 的 sort() 使用了 a new, hybrid sorting algorithm, introsort (for introspective sort), that behaves almost exactly like median-of-3 quicksort for most inputs (and is just as fast) but which is capable of detecting when partitioning is tending toward quadratic behavior. By switching to heapsort in those situations, introsort achieves the same O(N logN) time bound as heapsort but is almost always faster than just using heapsort in the first place. (http://www.cs.rpi.edu/~musser/gp/algorithms.html) 。该排序算法的分析见 (http://www.cs.rpi.edu/~musser/gp/introsort.ps)
1. Hashing
我们经常使用这样的字符串的Hash函数：
// 随手写的，未严格测试
unsigned long Hash(char* str)
{
assert(NULL != str);
unsigned long hash_val = 0xDEEDBEEFul; // hash seed
unsigned char* p = (unsigned char*)str;
while (*p != '/0') {
hash_val = 37 * hash_val + *p;
++p;
}
return hash_val;
}
《程序设计实践》第3章的Markov Chain的实现就使用了几乎一摸一样的Hash函数。这个函数的优点是速度快，英文单词的Hash值的分布也不错。但是，它太简单，容易受到攻击。攻击一般有两种方案：1) 构造一个输入序列，让序列中的每个字符串彼此不同，但Hash值相同；2) 构造一个输入序列，序列中每个字符串彼此不同，Hash值也不一定相同，但是这些Hash值对所用Hash Table的buckets数目同余（即hash_val % bucket_size 相等）。这样就能让Hash Table退化为链表。从而大大增加查找时间。(http://www.cs.rice.edu/~scrosby/hash/)
要解决这个问题，需要用复杂得多的Hash函数(MD5、SHA-1)，让攻击者(几乎)无法构造出Hash值相同的序列。
2. Regular Expressions
Regular Expression Engine 一般有三种：DFA (Deterministic Finite Automaton)、traditional NFA (Nondeterministic Finite Automaton)、POSIX NFA。这三种engines的功能一个比一个强，速度一个比一个慢。(http://msdn.microsoft.com/library/en-us/cpguide/html/cpconmatchingbehavior.asp) (http://www.oreilly.com/catalog/regex/chapter/ch04.html)
DFA 速度最快，可以保证线性时间(?)。NFA需要使用backtracking(回溯)技术，以支持backreference(向前引用)，通常NFA是线性时间，但是其最坏情况是指数时间！
举例来说，表达式 (x+x+)+y 可以匹配 xxx...xxxy 但不能匹配 xxx...xxxx。在某个版本的Python中，这个表达式的匹配是指数时间。(http://mail.python.org/pipermail/python-dev/2003-May/035916.html)
3. Quicksort
Quicksort的平均运行时间是O(N log N)，但可能退化为 O(N^2)，这是数据结构课程的必讲内容。C library 的 qsort 就不能保证一定是“快速”排序。(http://www.cs.dartmouth.edu/~doug/mdmspe.pdf)。C++ library 的 sort() 在改造之前，也可能退化为 O(N^2) 的龟速排序。SGI STL 的 sort() 使用了 a new, hybrid sorting algorithm, introsort (for introspective sort), that behaves almost exactly like median-of-3 quicksort for most inputs (and is just as fast) but which is capable of detecting when partitioning is tending toward quadratic behavior. By switching to heapsort in those situations, introsort achieves the same O(N logN) time bound as heapsort but is almost always faster than just using heapsort in the first place. (http://www.cs.rpi.edu/~musser/gp/algorithms.html) 。该排序算法的分析见 (http://www.cs.rpi.edu/~musser/gp/introsort.ps)