博客园_This is where I belong！

帮GF解道笔试题

2011-12-06T15:16:00Z

话说今天GF去参加了某公司笔试题，题目就是传说中的字符串排序，这里偶也总结了一些方法，留作参考吧。

在动手之前上两个个人的Helper片段：

1 public class CompareHelper<T> where T : IComparable<T>
2 {
3 public static bool AreEqual(T left, T right)
4 {
5 return left.CompareTo(right) == 0;
6 }
7
8 public static bool LessThan(T left, T right)
9 {
10 return left.CompareTo(right) < 0;
11 }
12
13 public static bool LessThanEqual(T left, T right)
14 {
15 return left.CompareTo(right) <= 0;
16 }
17
18 public static bool GreaterThan(T left, T right)
19 {
20 return left.CompareTo(right) > 0;
21 }
22
23 public static bool GreaterThanEqual(T left, T right)
24 {
25 return left.CompareTo(right) >= 0;
26 }
27 }
28
29 public static class GenericHelper
30 {
31 public static void Enumerate<T>(this IEnumerable<T> collection, Action<T> doIt)
32 {
33 foreach (T item in collection)
34 {
35 doIt(item);
36 }
37 }
38 }

随后，控制台的程序如下：

1 class Program
2 {
3 static void Main(string[] args)
4 {
5 string s = "IAmMyx";
6 //内置方法
7 char[] arr = s.ToCharArray();
8 arr = arr.OrderBy(a => a).ToArray();
9 arr.Enumerate(a => Console.Write(a));
10
11 Console.WriteLine();
12
13 //排序算法（最亲切的冒泡排序，其他的就不上了）
14 char[] arr2 = s.ToCharArray();
15 for (int i = 0; i <= arr2.Length - 1; i++)
16 {
17 for (int j = i + 1; j <= arr.Length - 1; j++)
18 {
19 if (CompareHelper<char>.GreaterThan(arr2[j - 1], arr2[j]))
20 {
21 Swap(ref arr2[j], ref arr2[j - 1]);
22 }
23 }
24 }
25 arr2.Enumerate(a => Console.Write(a));
26
27 Console.Read();
28 }
29
30 static void Swap<T>(ref T x, ref T y)
31 {
32 T temp = x;
33 x = y;
34 y = temp;
35 }
36 }

客户端的方法，我也总结了两种。

首先是可以通过string的localeCompare方法进行比较，如下：

1 String.prototype.before = function(str) {
2 return this.localeCompare(str) <= -1;
3 };
4
5 String.prototype.after = function(str) {
6 return this.localeCompare(str) >= 1;
7 };
8
9 String.prototype.equal = function(str) {
10 return this.localeCompare(str) == 0;
11 };
12 document.write("I".before("A") + '<br/>'); //false
13 document.write("I".before("i") + '<br/>'); //true
14 document.write("I".before("Z") + '<br/>'); //true

所以利用sort方法我们可以实现排序，这里提供一个个人类库中的扩展方法，如下：

1 function compareAsc(num1, num2) {
2 return num1.after(num2);
3 };
4 function compareDesc(num1, num2) {
5 return num2.after(num1);
6 };
7 Array.prototype.sortArr = function(bIsDesc) {
8 if (bIsDesc) {
9 this.sort(compareDesc);
10 }
11 else {
12 this.sort(compareAsc);
13 }
14 return this.join(',');
15 };

由上可以将数组进行升序或降序排列，使用方法如下：

1 var s = ['I', 'A', 'm', 'M', 'y', 'x'];
2 s = s.sortArr();
3 document.write(s + '<br/>');

此外，个人还收集了一个强悍的正则表达式排序法，分享如下：

1 var str = "15,18,16,20.6,5,8.1,2,4.9,13.21,24,22";
2 document.write
3 (
4 (str + ",").match(/\d+[.,]/g)
5 .sort(function(x, y) {
6 return parseInt(x) - parseInt(y)
7 })
8 .join("")
9 .substr(0, str.length);
10 )

快速评论通道：

作者：Rocky翔
出处：http://www.cnblogs.com/RockyMyx/
本文版权归作者和博客园共有，欢迎转载，但请在文章明显位置给出原文连接，否则保留追究法律责任的权利。

本文链接

求一个字符串中所有字符出现的次数

2011-11-13T15:57:00Z

如题是今天群里讨论的一个小话题，这里将讨论的结果作个简单的备份吧。

1 var s = "asdafghfghjgtyurygsgf";
2 var o = {};
3 s.replace(/./g, function (c) {
4 o[c] ? (o[c]++) : o[c] = 1
5 });
6 for (var i in o) {
7 document.write('字符：' + i + ' 次数：' + o[i] + '<br/>');
8 }

1 var s = "asdafghfghjgtyurygsgf";
2 var str = s.split('');
3 var arr = new Array();
4 var str2 = '';
5 for (var i in str) {
6 if (str2.indexOf(str[i]) != -1) {
7 arr[str[i]] += 1;
8 } else {
9 arr[str[i]] = 1;
10 str2 += str[i];
11 }
12 }
13 for (var i in arr) {
14 document.writeln(i + '的个数为:' + arr[i] + '<br/>');
15 }

1 var str = 'asdafghfghjgtyurygsgf', arr = str.split('');
2 var i, j, k, l, c, map = {};
3 for (i = 0, j = arr.length; i < j; i++) {
4 c = arr[i];
5 map[c] = 1;
6 for (k = i + 1; k < j; k++) {
7 if (c == arr[k]) {
8 map[c]++;
9 j = j - 1;
10 for (l = k; l < j; l++) {
11 arr[l] = arr[l + 1];
12 }
13 k--;
14 }
15 }
16 }
17 var s = '', p;
18 for (p in map) {
19 if (map.hasOwnProperty(p)) {
20 s += p + ' => ' + map[p] + '\n';
21 }
22 }
23 alert(s);

1 string s = "asdafghfghjgtyurygsgf";
2 char[] arr = s.ToCharArray();
3 Dictionary<char, int> dict = new Dictionary<char, int>();
4 foreach (char c in arr)
5 {
6 if (!dict.ContainsKey(c)) dict.Add(c, 1);
7 else ++dict[c];
8 }
9 dict.Enumerate(a => Console.WriteLine("字符：" + a.Key.ToString() + "\b次数：" + a.Value.ToString()));

1 public static class GenericHelper
2 {
3 ///<summary>
4 /// 遍历集合并执行Action委托
5 ///</summary>
6 public static void Enumerate<T>(this IEnumerable<T> collection, Action<T> doIt)
7 {
8 foreach (T item in collection)
9 {
10 doIt(item);
11 }
12 }
13 }

本文链接

各大公司（Google，Microsoft，Baidu， Microsoft Research Asia etc.）实习生面试题总汇

2011-10-21T15:12:00Z

1.把二元查找树转变成排序的双向链表（树）

题目：

输入一棵二元查找树，将该二元查找树转换成一个排序的双向链表。

要求不能创建任何新的结点，只调整指针的指向。

/ \

6 14

/ \ / \

4 8 12 16

转换成双向链表

4=6=8=10=12=14=16。

首先我们定义的二元查找树节点的数据结构如下：

struct BSTreeNode

{

int m_nValue; // value of node

BSTreeNode *m_pLeft; // left child of node

BSTreeNode *m_pRight; // right child of node

};

2.设计包含min函数的栈（栈）

定义栈的数据结构，要求添加一个min函数，能够得到栈的最小元素。

要求函数min、push以及pop的时间复杂度都是O(1)。

3.求子数组的最大和（数组）

题目：

输入一个整形数组，数组里有正数也有负数。

数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和。

求所有子数组的和的最大值。要求时间复杂度为O(n)。

例如输入的数组为1, -2, 3, 10, -4, 7, 2, -5，和最大的子数组为3, 10, -4, 7, 2，

因此输出为该子数组的和18。

4.在二元树中找出和为某一值的所有路径（树）

题目：输入一个整数和一棵二元树。

从树的根结点开始往下访问一直到叶结点所经过的所有结点形成一条路径。

打印出和与输入整数相等的所有路径。

例如输入整数22和如下二元树

/ \

5 12

/ \

4 7

则打印出两条路径：10, 12和10, 5, 7。

二元树节点的数据结构定义为：

struct BinaryTreeNode // a node in the binary tree

{

int m_nValue; // value of node

BinaryTreeNode *m_pLeft; // left child of node

BinaryTreeNode *m_pRight; // right child of node

};

5.查找最小的k个元素（数组）

题目：输入n个整数，输出其中最小的k个。

例如输入1，2，3，4，5，6，7和8这8个数字，则最小的4个数字为1，2，3和4。

第6题（数组）

腾讯面试题：

给你10分钟时间，根据上排给出十个数，在其下排填出对应的十个数

要求下排每个数都是先前上排那十个数在下排出现的次数。

上排的十个数如下：

【0，1，2，3，4，5，6，7，8，9】

举一个例子，

数值: 0,1,2,3,4,5,6,7,8,9

分配: 6,2,1,0,0,0,1,0,0,0

0在下排出现了6次，1在下排出现了2次，

2在下排出现了1次，3在下排出现了0次....

以此类推..

第7题（链表）

微软亚院之编程判断俩个链表是否相交

给出俩个单向链表的头指针，比如h1，h2，判断这俩个链表是否相交。

为了简化问题，我们假设俩个链表均不带环。

问题扩展：

1.如果链表可能有环列?

2.如果需要求出俩个链表相交的第一个节点列?

第8题（算法）

此贴选一些比较怪的题，，由于其中题目本身与算法关系不大，仅考考思维。特此并作一题。

1.有两个房间，一间房里有三盏灯，另一间房有控制着三盏灯的三个开关，这两个房间是分割开的，从一间里不能看到另一间的情况。现在要求受训者分别进这两房间一次，然后判断出这三盏灯分别是由哪个开关控制的。有什么办法呢？

2.你让一些人为你工作了七天，你要用一根金条作为报酬。金条被分成七小块，每天给出一块。

如果你只能将金条切割两次，你怎样分给这些工人?

3.　★用一种算法来颠倒一个链接表的顺序。现在在不用递归式的情况下做一遍。

★用一种算法在一个循环的链接表里插入一个节点，但不得穿越链接表。

★用一种算法整理一个数组。你为什么选择这种方法?

★用一种算法使通用字符串相匹配。

★颠倒一个字符串。优化速度。优化空间。

★颠倒一个句子中的词的顺序，比如将“我叫克丽丝”转换为“克丽丝叫我”，

实现速度最快，移动最少。

★找到一个子字符串。优化速度。优化空间。

★比较两个字符串，用O(n)时间和恒量空间。

★假设你有一个用1001个整数组成的数组，这些整数是任意排列的，但是你知道所有的整数都在1到1000(包括1000)之间。此外，除一个数字出现两次外，其他所有数字只出现一次。假设你只能对这个数组做一次处理，用一种算法找出重复的那个数字。如果你在运算中使用了辅助的存储方式，那么你能找到不用这种方式的算法吗?

★不用乘法或加法增加8倍。现在用同样的方法增加7倍。

第9题（树）

判断整数序列是不是二元查找树的后序遍历结果

题目：输入一个整数数组，判断该数组是不是某二元查找树的后序遍历的结果。

如果是返回true，否则返回false。

例如输入5、7、6、9、11、10、8，由于这一整数序列是如下树的后序遍历结果：

/ \

6 10

/ \ / \

5 7 9 11

因此返回true。

如果输入7、4、6、5，没有哪棵树的后序遍历的结果是这个序列，因此返回false。

第10题（字符串）

翻转句子中单词的顺序。

题目：输入一个英文句子，翻转句子中单词的顺序，但单词内字符的顺序不变。

句子中单词以空格符隔开。为简单起见，标点符号和普通字母一样处理。

例如输入“I am a student.”，则输出“student. a am I”。

第11题（树）

求二叉树中节点的最大距离...

如果我们把二叉树看成一个图，父子节点之间的连线看成是双向的，

我们姑且定义"距离"为两节点之间边的个数。

写一个程序，

求一棵二叉树中相距最远的两个节点之间的距离。

第12题（语法）

题目：求1+2+…+n，

要求不能使用乘除法、for、while、if、else、switch、case等关键字以及条件判断语句（A?B:C）。

第13题（链表）：

题目：输入一个单向链表，输出该链表中倒数第k个结点。链表的倒数第0个结点为链表的尾指针。

链表结点定义如下：

struct ListNode

{

int m_nKey;

ListNode* m_pNext;

};

第14题（数组）：

题目：输入一个已经按升序排序过的数组和一个数字，

在数组中查找两个数，使得它们的和正好是输入的那个数字。

要求时间复杂度是O(n)。如果有多对数字的和等于输入的数字，输出任意一对即可。

例如输入数组1、2、4、7、11、15和数字15。由于4+11=15，因此输出4和11。

第15题（树）：

题目：输入一颗二元查找树，将该树转换为它的镜像，

即在转换后的二元查找树中，左子树的结点都大于右子树的结点。

用递归和循环两种方法完成树的镜像转换。

例如输入：

/ \

6 10

/\ /\

5 7 9 11

输出：

/ \

10 6

/\ /\

11 9 7 5

定义二元查找树的结点为：

struct BSTreeNode // a node in the binary search tree (BST)

{

int m_nValue; // value of node

BSTreeNode *m_pLeft; // left child of node

BSTreeNode *m_pRight; // right child of node

};

第16题（树）：

题目（微软）：

输入一颗二元树，从上往下按层打印树的每个结点，同一层中按照从左往右的顺序打印。

例如输入

/ \

6 10

/ \ / \

5 7 9 11

输出8 6 10 5 7 9 11。

第17题（字符串）：

题目：在一个字符串中找到第一个只出现一次的字符。如输入abaccdeff，则输出b。

分析：这道题是2006年google的一道笔试题。

第18题（数组）：

题目：n个数字（0,1,…,n-1）形成一个圆圈，从数字0开始，

每次从这个圆圈中删除第m个数字（第一个为当前数字本身，第二个为当前数字的下一个数字）。

当一个数字删除后，从被删除数字的下一个继续删除第m个数字。

求出在这个圆圈中剩下的最后一个数字。

July：我想，这个题目，不少人已经见识过了。

第19题（数组、递归）：

题目：定义Fibonacci数列如下：

/ 0 n=0

f(n)= 1 n=1

\ f(n-1)+f(n-2) n=2

输入n，用最快的方法求该数列的第n项。

分析：在很多C语言教科书中讲到递归函数的时候，都会用Fibonacci作为例子。

因此很多程序员对这道题的递归解法非常熟悉，但....呵呵，你知道的。。

第20题（字符串）：

题目：输入一个表示整数的字符串，把该字符串转换成整数并输出。

例如输入字符串"345"，则输出整数345。

第21题（数组）

2010年中兴面试题

编程求解：

输入两个整数 n 和 m，从数列1，2，3.......n 中随意取几个数,

使其和等于 m ,要求将其中所有的可能组合列出来.

第22题（推理）：

有4张红色的牌和4张蓝色的牌，主持人先拿任意两张，再分别在A、B、C三人额头上贴任意两张牌，

A、B、C三人都可以看见其余两人额头上的牌，看完后让他们猜自己额头上是什么颜色的牌，

A说不知道，B说不知道，C说不知道，然后A说知道了。

请教如何推理，A是怎么知道的。

如果用程序，又怎么实现呢？

第23题（算法）：

用最简单，最快速的方法计算出下面这个圆形是否和正方形相交。"

3D坐标系原点(0.0,0.0,0.0)

圆形:

半径r = 3.0

圆心o = (*.*, 0.0, *.*)

正方形:

4个角坐标;

1:(*.*, 0.0, *.*)

2:(*.*, 0.0, *.*)

3:(*.*, 0.0, *.*)

4:(*.*, 0.0, *.*)

第24题（链表）：

链表操作，单链表就地逆置，

第25题（字符串）：

写一个函数,它的原形是int continumax(char *outputstr,char *intputstr)

功能：

在字符串中找出连续最长的数字串，并把这个串的长度返回，

并把这个最长数字串付给其中一个函数参数outputstr所指内存。

例如："abcd12345ed125ss123456789"的首地址传给intputstr后，函数将返回9，

outputstr所指的值为123456789

26.左旋转字符串（字符串）

题目：

定义字符串的左旋转操作：把字符串前面的若干个字符移动到字符串的尾部。

如把字符串abcdef左旋转2位得到字符串cdefab。请实现字符串左旋转的函数。

要求时间对长度为n的字符串操作的复杂度为O(n)，辅助内存为O(1)。

27.跳台阶问题（递归）

题目：一个台阶总共有n级，如果一次可以跳1级，也可以跳2级。

求总共有多少总跳法，并分析算法的时间复杂度。

这道题最近经常出现，包括MicroStrategy等比较重视算法的公司

都曾先后选用过个这道题作为面试题或者笔试题。

28.整数的二进制表示中1的个数（运算）

题目：输入一个整数，求该整数的二进制表达中有多少个1。

例如输入10，由于其二进制表示为1010，有两个1，因此输出2。

分析：

这是一道很基本的考查位运算的面试题。

包括微软在内的很多公司都曾采用过这道题。

29.栈的push、pop序列（栈）

题目：输入两个整数序列。其中一个序列表示栈的push顺序，

判断另一个序列有没有可能是对应的pop顺序。

为了简单起见，我们假设push序列的任意两个整数都是不相等的。

比如输入的push序列是1、2、3、4、5，那么4、5、3、2、1就有可能是一个pop系列。

因为可以有如下的push和pop序列：

push 1，push 2，push 3，push 4，pop，push 5，pop，pop，pop，pop，

这样得到的pop序列就是4、5、3、2、1。

但序列4、3、5、1、2就不可能是push序列1、2、3、4、5的pop序列。

30.在从1到n的正数中1出现的次数（数组）

题目：输入一个整数n，求从1到n这n个整数的十进制表示中1出现的次数。

例如输入12，从1到12这些整数中包含1 的数字有1，10，11和12，1一共出现了5次。

分析：这是一道广为流传的google面试题。

31.华为面试题（搜索）：

一类似于蜂窝的结构的图，进行搜索最短路径（要求5分钟）

32.（数组、规划）

有两个序列a,b，大小都为n,序列元素的值任意整数，无序；

要求：通过交换a,b中的元素，使[序列a元素的和]与[序列b元素的和]之间的差最小。

例如:

var a=[100,99,98,1,2, 3];

var b=[1, 2, 3, 4,5,40];

33.（字符串）

实现一个挺高级的字符匹配算法：

给一串很长字符串，要求找到符合要求的字符串，例如目的串：123

1******3***2 ,12*****3这些都要找出来

其实就是类似一些和谐系统。。。。。

34.（队列）

实现一个队列。

队列的应用场景为：

一个生产者线程将int类型的数入列，一个消费者线程将int类型的数出列

35.（矩阵）

求一个矩阵中最大的二维矩阵(元素和最大).如:

1 2 0 3 4

2 3 4 5 1

1 1 5 3 0

中最大的是:

4 5

5 3

要求:(1)写出算法;(2)分析时间复杂度;(3)用C写出关键代码

第36题-40题（有些题目搜集于CSDN上的网友，已标明）：

36.引用自网友：longzuo（运算）

谷歌笔试：

n支队伍比赛，分别编号为0，1，2。。。。n-1，已知它们之间的实力对比关系，

存储在一个二维数组w[n][n]中，w[i][j] 的值代表编号为i，j的队伍中更强的一支。

所以w[i][j]=i 或者j，现在给出它们的出场顺序，并存储在数组order[n]中，

比如order[n] = {4,3,5,8,1......}，那么第一轮比赛就是 4对3， 5对8。.......

胜者晋级，败者淘汰，同一轮淘汰的所有队伍排名不再细分，即可以随便排，

下一轮由上一轮的胜者按照顺序，再依次两两比，比如可能是4对5,直至出现第一名

编程实现，给出二维数组w，一维数组order 和用于输出比赛名次的数组result[n]，

求出result。

37.（字符串）

有n个长为m+1的字符串，

如果某个字符串的最后m个字符与某个字符串的前m个字符匹配，则两个字符串可以联接，

问这n个字符串最多可以连成一个多长的字符串，如果出现循环，则返回错误。

38.（算法）

百度面试：

1.用天平（只能比较，不能称重）从一堆小球中找出其中唯一一个较轻的，使用x次天平，

最多可以从y个小球中找出较轻的那个，求y与x的关系式。

2.有一个很大很大的输入流，大到没有存储器可以将其存储下来，

而且只输入一次，如何从这个输入流中随机取得m个记录。

3.大量的URL字符串，如何从中去除重复的，优化时间空间复杂度

39.（树、图、算法）

网易有道笔试：

(1).

求一个二叉树中任意两个节点间的最大距离，

两个节点的距离的定义是这两个节点间边的个数，

比如某个孩子节点和父节点间的距离是1，和相邻兄弟节点间的距离是2，优化时间空间复杂度。

(2).

求一个有向连通图的割点，割点的定义是，如果除去此节点和与其相关的边，

有向图不再连通，描述算法。

40.百度研发笔试题（栈、算法）

引用自：zp155334877

1)设计一个栈结构，满足一下条件：min，push，pop操作的时间复杂度为O(1)。

2)一串首尾相连的珠子(m个)，有N种颜色(N<=10)，

设计一个算法，取出其中一段，要求包含所有N中颜色，并使长度最短。

并分析时间复杂度与空间复杂度。

3)设计一个系统处理词语搭配问题，比如说中国和人民可以搭配，

则中国人民人民中国都有效。要求：

*系统每秒的查询数量可能上千次；

*词语的数量级为10W；

*每个词至多可以与1W个词搭配

当用户输入中国人民的时候，要求返回与这个搭配词组相关的信息。

41.求固晶机的晶元查找程序（匹配、算法）

晶元盘由数目不详的大小一样的晶元组成，晶元并不一定全布满晶元盘，

照相机每次这能匹配一个晶元，如匹配过，则拾取该晶元，

若匹配不过，照相机则按测好的晶元间距移到下一个位置。

求遍历晶元盘的算法求思路。

42.请修改append函数，利用这个函数实现（链表）：

两个非降序链表的并集，1->2->3 和 2->3->5 并为 1->2->3->5

另外只能输出结果，不能修改两个链表的数据。

43.递归和非递归俩种方法实现二叉树的前序遍历。

44.腾讯面试题（算法）：

1.设计一个魔方（六面）的程序。

2.有一千万条短信，有重复，以文本文件的形式保存，一行一条，有重复。

请用5分钟时间，找出重复出现最多的前10条。

3.收藏了1万条url，现在给你一条url，如何找出相似的url。（面试官不解释何为相似）

45.雅虎（运算、矩阵）：

1.对于一个整数矩阵，存在一种运算，对矩阵中任意元素加一时，需要其相邻（上下左右）

某一个元素也加一，现给出一正数矩阵，判断其是否能够由一个全零矩阵经过上述运算得到。

2.一个整数数组，长度为n，将其分为m份，使各份的和相等，求m的最大值

比如{3，2，4，3，6} 可以分成{3，2，4，3，6} m=1;

{3,6}{2,4,3} m=2

{3,3}{2,4}{6} m=3 所以m的最大值为3

46.搜狐（运算）：

四对括号可以有多少种匹配排列方式？比如两对括号可以有两种：（）（）和（（））

47.创新工场（算法）：

求一个数组的最长递减子序列比如{9，4，3，2，5，4，3，2}的最长递减子序列为{9，5，4，3，2}

48.微软（运算）：

一个数组是由一个递减数列左移若干位形成的，比如{4，3，2，1，6，5}

是由{6，5，4，3，2，1}左移两位形成的，在这种数组中查找某一个数。

49.一道看上去很吓人的算法面试题（排序、算法）：

如何对n个数进行排序，要求时间复杂度O(n)，空间复杂度O(1)

50.网易有道笔试（sorry，与第39题重复）：

1.求一个二叉树中任意两个节点间的最大距离，两个节点的距离的定义是这两个节点间边的个数，

比如某个孩子节点和父节点间的距离是1，和相邻兄弟节点间的距离是2，优化时间空间复杂度。

2.求一个有向连通图的割点，割点的定义是，

如果除去此节点和与其相关的边，有向图不再连通，描述算法。

-------------------------------------------------------------------

51.和为n连续正数序列（数组）。

题目：输入一个正数n，输出所有和为n连续正数序列。

例如输入15，由于1+2+3+4+5=4+5+6=7+8=15，所以输出3个连续序列1-5、4-6和7-8。

分析：这是网易的一道面试题。

52.二元树的深度（树）。

题目：输入一棵二元树的根结点，求该树的深度。

从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。

例如：输入二元树：

/ \

6 14

/ / \

4 12 16

输出该树的深度3。

二元树的结点定义如下：

struct SBinaryTreeNode // a node of the binary tree

{

int m_nValue; // value of node

SBinaryTreeNode *m_pLeft; // left child of node

SBinaryTreeNode *m_pRight; // right child of node

};

分析：这道题本质上还是考查二元树的遍历。

53.字符串的排列（字符串）。

题目：输入一个字符串，打印出该字符串中字符的所有排列。

例如输入字符串abc，则输出由字符a、b、c所能排列出来的所有字符串

abc、acb、bac、bca、cab和cba。

分析：这是一道很好的考查对递归理解的编程题，

因此在过去一年中频繁出现在各大公司的面试、笔试题中。

54.调整数组顺序使奇数位于偶数前面（数组）。

题目：输入一个整数数组，调整数组中数字的顺序，使得所有奇数位于数组的前半部分，

所有偶数位于数组的后半部分。要求时间复杂度为O(n)。

55.（语法）

题目：类CMyString的声明如下：

class CMyString

{

public:

CMyString(char* pData = NULL);

CMyString(const CMyString& str);

~CMyString(void);

CMyString& operator = (const CMyString&str);

private:

char* m_pData;

};

请实现其赋值运算符的重载函数，要求异常安全，即当对一个对象进行赋值时发生异常，对象的状态不能改变。

56.最长公共字串（算法、字符串）。

题目：如果字符串一的所有字符按其在字符串中的顺序出现在另外一个字符串二中，

则字符串一称之为字符串二的子串。

注意，并不要求子串（字符串一）的字符必须连续出现在字符串二中。

请编写一个函数，输入两个字符串，求它们的最长公共子串，并打印出最长公共子串。

例如：输入两个字符串BDCABA和ABCBDAB，字符串BCBA和BDAB都是是它们的最长公共子串，

则输出它们的长度4，并打印任意一个子串。

分析：求最长公共子串（Longest Common Subsequence, LCS）是一道非常经典的动态规划题，

因此一些重视算法的公司像MicroStrategy都把它当作面试题。

57.用俩个栈实现队列（栈、队列）。

题目：某队列的声明如下：

template<typename T> class CQueue

{

public:

CQueue() {}

~CQueue() {}

void appendTail(const T& node); // append a element to tail

void deleteHead(); // remove a element from head

private:

T> m_stack1;

T> m_stack2;

};

分析：从上面的类的声明中，我们发现在队列中有两个栈。

因此这道题实质上是要求我们用两个栈来实现一个队列。

相信大家对栈和队列的基本性质都非常了解了：栈是一种后入先出的数据容器，

因此对队列进行的插入和删除操作都是在栈顶上进行；队列是一种先入先出的数据容器，

我们总是把新元素插入到队列的尾部，而从队列的头部删除元素。

58.从尾到头输出链表（链表）。

题目：输入一个链表的头结点，从尾到头反过来输出每个结点的值。链表结点定义如下：

struct ListNode

{

int m_nKey;

ListNode* m_pNext;

};

分析：这是一道很有意思的面试题。

该题以及它的变体经常出现在各大公司的面试、笔试题中。

59.不能被继承的类（语法）。

题目：用C++设计一个不能被继承的类。

分析：这是Adobe公司2007年校园招聘的最新笔试题。

这道题除了考察应聘者的C++基本功底外，还能考察反应能力，是一道很好的题目。

60.在O（1）时间内删除链表结点（链表、算法）。

题目：给定链表的头指针和一个结点指针，在O(1)时间删除该结点。链表结点的定义如下：

struct ListNode

{

int m_nKey;

ListNode* m_pNext;

};

函数的声明如下：

void DeleteNode(ListNode* pListHead, ListNode* pToBeDeleted);

分析：这是一道广为流传的Google面试题，能有效考察我们的编程基本功，还能考察我们的反应速度，

更重要的是，还能考察我们对时间复杂度的理解。

-------------------------------------------------------------------------

61.找出数组中两个只出现一次的数字（数组）

题目：一个整型数组里除了两个数字之外，其他的数字都出现了两次。

请写程序找出这两个只出现一次的数字。要求时间复杂度是O(n)，空间复杂度是O(1)。

分析：这是一道很新颖的关于位运算的面试题。

62.找出链表的第一个公共结点（链表）。

题目：两个单向链表，找出它们的第一个公共结点。

链表的结点定义为：

struct ListNode

{

int m_nKey;

ListNode* m_pNext;

};

分析：这是一道微软的面试题。微软非常喜欢与链表相关的题目，

因此在微软的面试题中，链表出现的概率相当高。

63.在字符串中删除特定的字符（字符串）。

题目：输入两个字符串，从第一字符串中删除第二个字符串中所有的字符。

例如，输入”They are students.”和”aeiou”，

则删除之后的第一个字符串变成”Thy r stdnts.”。

分析：这是一道微软面试题。在微软的常见面试题中，与字符串相关的题目占了很大的一部分，

因为写程序操作字符串能很好的反映我们的编程基本功。

64. 寻找丑数（运算）。

题目：我们把只包含因子2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，

但14不是，因为它包含因子7。习惯上我们把1当做是第一个丑数。

求按从小到大的顺序的第1500个丑数。

分析：这是一道在网络上广为流传的面试题，据说google曾经采用过这道题。

65.输出1到最大的N位数（运算）

题目：输入数字n，按顺序输出从1最大的n位10进制数。比如输入3，

则输出1、2、3一直到最大的3位数即999。

分析：这是一道很有意思的题目。看起来很简单，其实里面却有不少的玄机。

66.颠倒栈（栈）。

题目：用递归颠倒一个栈。例如输入栈{1, 2, 3, 4, 5}，1在栈顶。

颠倒之后的栈为{5, 4, 3, 2, 1}，5处在栈顶。

67.俩个闲玩娱乐（运算）。

1.扑克牌的顺子

从扑克牌中随机抽5张牌，判断是不是一个顺子，即这5张牌是不是连续的。

2-10为数字本身，A为1，J为11，Q为12，K为13，而大小王可以看成任意数字。

2.n个骰子的点数。

把n个骰子扔在地上，所有骰子朝上一面的点数之和为S。输入n，

打印出S的所有可能的值出现的概率。

68.把数组排成最小的数（数组、算法）。

题目：输入一个正整数数组，将它们连接起来排成一个数，输出能排出的所有数字中最小的一个。

例如输入数组{32, 321}，则输出这两个能排成的最小数字32132。

请给出解决问题的算法，并证明该算法。

分析：这是09年6月份百度的一道面试题，

从这道题我们可以看出百度对应聘者在算法方面有很高的要求。

69.旋转数组中的最小元素（数组、算法）。

题目：把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个排好序的数组的一个旋转，

输出旋转数组的最小元素。例如数组{3, 4, 5, 1, 2}为{1, 2, 3, 4, 5}的一个旋转，该数组的最小值为1。

分析：这道题最直观的解法并不难。从头到尾遍历数组一次，就能找出最小的元素，

时间复杂度显然是O(N)。但这个思路没有利用输入数组的特性，我们应该能找到更好的解法。

70.给出一个函数来输出一个字符串的所有排列（经典字符串问题）。

ANSWER 简单的回溯就可以实现了。当然排列的产生也有很多种算法，去看看组合数学，

还有逆序生成排列和一些不需要递归生成排列的方法。

印象中Knuth的<TAOCP>第一卷里面深入讲了排列的生成。这些算法的理解需要一定的数学功底，

也需要一定的灵感，有兴趣最好看看。

71.数值的整数次方（数字、运算）。

题目：实现函数double Power(double base, int exponent)，求base的exponent次方。

不需要考虑溢出。

分析：这是一道看起来很简单的问题。可能有不少的人在看到题目后30秒写出如下的代码：

double Power(double base, int exponent)

{

double result = 1.0;

for(int i = 1; i <= exponent; ++i)

result *= base;

return result;

}

72.（语法）

题目：设计一个类，我们只能生成该类的一个实例。

分析：只能生成一个实例的类是实现了Singleton模式的类型。

73.对称字符串的最大长度（字符串）。

题目：输入一个字符串，输出该字符串中对称的子字符串的最大长度。

比如输入字符串“google”，由于该字符串里最长的对称子字符串是“goog”，因此输出4。

分析：可能很多人都写过判断一个字符串是不是对称的函数，这个题目可以看成是该函数的加强版。

74.数组中超过出现次数超过一半的数字（数组）

题目：数组中有一个数字出现的次数超过了数组长度的一半，找出这个数字。

分析：这是一道广为流传的面试题，包括百度、微软和Google在内的多家公司都

曾经采用过这个题目。要几十分钟的时间里很好地解答这道题，

除了较好的编程能力之外，还需要较快的反应和较强的逻辑思维能力。

75.二叉树两个结点的最低共同父结点（树）

题目：二叉树的结点定义如下：

struct TreeNode

{

int m_nvalue;

TreeNode* m_pLeft;

TreeNode* m_pRight;

};

输入二叉树中的两个结点，输出这两个结点在数中最低的共同父结点。

分析：求数中两个结点的最低共同结点是面试中经常出现的一个问题。这个问题至少有两个变种。

76.复杂链表的复制（链表、算法）

题目：有一个复杂链表，其结点除了有一个m_pNext指针指向下一个结点外，

还有一个m_pSibling指向链表中的任一结点或者NULL。其结点的C++定义如下：

struct ComplexNode

{

int m_nValue;

ComplexNode* m_pNext;

ComplexNode* m_pSibling;

};

下图是一个含有5个结点的该类型复杂链表。

图中实线箭头表示m_pNext指针，虚线箭头表示m_pSibling指针。为简单起见，

指向NULL的指针没有画出。

请完成函数ComplexNode* Clone(ComplexNode* pHead)，以复制一个复杂链表。

分析：在常见的数据结构上稍加变化，这是一种很新颖的面试题。

要在不到一个小时的时间里解决这种类型的题目，我们需要较快的反应能力，

对数据结构透彻的理解以及扎实的编程功底。

77.关于链表问题的面试题目如下（链表）：

1.给定单链表，检测是否有环。

使用两个指针p1,p2从链表头开始遍历，p1每次前进一步，p2每次前进两步。如果p2到达链表尾部，

说明无环，否则p1、p2必然会在某个时刻相遇(p1==p2)，从而检测到链表中有环。

2.给定两个单链表(head1, head2)，检测两个链表是否有交点，如果有返回第一个交点。

如果head1==head2，那么显然相交，直接返回head1。

否则，分别从head1,head2开始遍历两个链表获得其长度len1与len2，假设len1>=len2，

那么指针p1由head1开始向后移动len1-len2步，指针p2=head2，

下面p1、p2每次向后前进一步并比较p1p2是否相等，如果相等即返回该结点，

否则说明两个链表没有交点。

3.给定单链表(head)，如果有环的话请返回从头结点进入环的第一个节点。

运用题一，我们可以检查链表中是否有环。

如果有环，那么p1p2重合点p必然在环中。从p点断开环，

方法为：p1=p, p2=p->next, p->next=NULL。此时，原单链表可以看作两条单链表，

一条从head开始，另一条从p2开始，于是运用题二的方法，我们找到它们的第一个交点即为所求。

4.只给定单链表中某个结点p(并非最后一个结点，即p->next!=NULL)指针，删除该结点。

办法很简单，首先是放p中数据,然后将p->next的数据copy入p中，接下来删除p->next即可。

5.只给定单链表中某个结点p(非空结点)，在p前面插入一个结点。

办法与前者类似，首先分配一个结点q，将q插入在p后，接下来将p中的数据copy入q中，

然后再将要插入的数据记录在p中。

78.链表和数组的区别在哪里（链表、数组）？

分析：主要在基本概念上的理解。

但是最好能考虑的全面一点，现在公司招人的竞争可能就在细节上产生，

谁比较仔细，谁获胜的机会就大。

79.（链表、字符串）

1.编写实现链表排序的一种算法。说明为什么你会选择用这样的方法？

2.编写实现数组排序的一种算法。说明为什么你会选择用这样的方法？

3.请编写能直接实现strstr()函数功能的代码。

80.阿里巴巴一道笔试题（运算、算法）

问题描述:

12个高矮不同的人,排成两排,每排必须是从矮到高排列,而且第二排比对应的第一排的人高,问排列方式有多少种?

这个笔试题,很YD,因为把某个递归关系隐藏得很深。

先来几组百度的面试题：

===================

81.第1组百度面试题

1.一个int数组，里面数据无任何限制，要求求出所有这样的数a[i]，

其左边的数都小于等于它，右边的数都大于等于它。

能否只用一个额外数组和少量其它空间实现。

2.一个文件，内含一千万行字符串，每个字符串在1K以内，

要求找出所有相反的串对，如abc和cba。

3.STL的set用什么实现的？为什么不用hash？

82.第2组百度面试题

1.给出两个集合A和B，其中集合A={name}，

集合B={age、sex、scholarship、address、...}，

要求：

问题1、根据集合A中的name查询出集合B中对应的属性信息；

问题2、根据集合B中的属性信息（单个属性，如age<20等），查询出集合A中对应的name。

2.给出一个文件，里面包含两个字段{url、size}，

即url为网址，size为对应网址访问的次数，

要求：

问题1、利用Linux Shell命令或自己设计算法，

查询出url字符串中包含“baidu”子字符串对应的size字段值；

问题2、根据问题1的查询结果，对其按照size由大到小的排列。

（说明：url数据量很大，100亿级以上）

83.第3组百度面试题

1.今年百度的一道题目

百度笔试：给定一个存放整数的数组，重新排列数组使得数组左边为奇数，右边为偶数。

要求：空间复杂度O(1)，时间复杂度为O（n）。

2.百度笔试题

用C语言实现函数void * memmove(void *dest, const void *src, size_t n)。

memmove函数的功能是拷贝src所指的内存内容前n个字节到dest所指的地址上。

分析：

由于可以把任何类型的指针赋给void类型的指针

这个函数主要是实现各种数据类型的拷贝。

84.第4组百度面试题

2010年3道百度面试题[相信，你懂其中的含金量]

1.a~z包括大小写与0~9组成的N个数

用最快的方式把其中重复的元素挑出来。

2.已知一随机发生器，产生0的概率是p，产生1的概率是1-p，现在要你构造一个发生器，

使得它构造0和1的概率均为1/2；构造一个发生器，使得它构造1、2、3的概率均为1/3；...，

构造一个发生器，使得它构造1、2、3、...n的概率均为1/n，要求复杂度最低。

3.有10个文件，每个文件1G，

每个文件的每一行都存放的是用户的query，每个文件的query都可能重复。

要求按照query的频度排序.

85.又见字符串的问题

1.给出一个函数来复制两个字符串A和B。

字符串A的后几个字节和字符串B的前几个字节重叠。

分析：记住，这种题目往往就是考你对边界的考虑情况。

2.已知一个字符串，比如asderwsde,寻找其中的一个子字符串比如sde的个数，

如果没有返回0，有的话返回子字符串的个数。

86.

怎样编写一个程序，把一个有序整数数组放到二叉树中？

分析:本题考察二叉搜索树的建树方法，简单的递归结构。

关于树的算法设计一定要联想到递归，因为树本身就是递归的定义。

而，学会把递归改称非递归也是一种必要的技术。

毕竟，递归会造成栈溢出，关于系统底层的程序中不到非不得以最好不要用。

但是对某些数学问题，就一定要学会用递归去解决。

87.

1.大整数数相乘的问题。（这是2002年在一考研班上遇到的算法题）

2.求最大连续递增数字串（如“ads3sl456789DF3456ld345AA”中的“456789”）

3.实现strstr功能，即在父串中寻找子串首次出现的位置。

（笔试中常让面试者实现标准库中的一些函数）

88.2005年11月金山笔试题。编码完成下面的处理函数。

函数将字符串中的字符'*'移到串的前部分，

前面的非'*'字符后移，但不能改变非'*'字符的先后顺序，函数返回串中字符'*'的数量。

如原始串为：ab**cd**e*12，

处理后为*****abcde12，函数并返回值为5。（要求使用尽量少的时间和辅助空间）

89.神州数码、华为、东软笔试题

1.2005年11月15日华为软件研发笔试题。实现一单链表的逆转。

2.编码实现字符串转整型的函数（实现函数atoi的功能），据说是神州数码笔试题。如将字符

串 ”+123”123, ”-0123”-123, “123CS45”123, “123.45CS”123, “CS123.45”0

3.快速排序（东软喜欢考类似的算法填空题，又如堆排序的算法等）

4.删除字符串中的数字并压缩字符串。

如字符串”abc123de4fg56”处理后变为”abcdefg”。注意空间和效率。

（下面的算法只需要一次遍历，不需要开辟新空间，时间复杂度为O(N)）

5.求两个串中的第一个最长子串（神州数码以前试题）。

如"abractyeyt","dgdsaeactyey"的最大子串为"actyet"。

90.

1.不开辟用于交换数据的临时空间，如何完成字符串的逆序

(在技术一轮面试中，有些面试官会这样问)。

2.删除串中指定的字符

（做此题时，千万不要开辟新空间，否则面试官可能认为你不适合做嵌入式开发）

3.判断单链表中是否存在环。

91.

1.一道著名的毒酒问题

有1000桶酒，其中1桶有毒。而一旦吃了，毒性会在1周后发作。

现在我们用小老鼠做实验，要在1周内找出那桶毒酒，问最少需要多少老鼠。

2.有趣的石头问题

有一堆1万个石头和1万个木头，对于每个石头都有1个木头和它重量一样，

把配对的石头和木头找出来。

92.

1.多人排成一个队列,我们认为从低到高是正确的序列,但是总有部分人不遵守秩序。

如果说,前面的人比后面的人高(两人身高一样认为是合适的),

那么我们就认为这两个人是一对“捣乱分子”,比如说,现在存在一个序列:

176, 178, 180, 170, 171

这些捣乱分子对为

<176, 170>, <176, 171>, <178, 170>, <178, 171>, <180, 170>, <180, 171>,

那么,现在给出一个整型序列,请找出这些捣乱分子对的个数(仅给出捣乱分子对的数目即可,不用具体的对)

要求：

输入:

为一个文件(in)，文件的每一行为一个序列。序列全为数字，数字间用”,”分隔。

输出：

为一个文件(out)，每行为一个数字，表示捣乱分子的对数。

详细说明自己的解题思路，说明自己实现的一些关键点。

并给出实现的代码，并分析时间复杂度。

限制：

输入每行的最大数字个数为100000个，数字最长为6位。程序无内存使用限制。

93.在一个int数组里查找这样的数，它大于等于左侧所有数，小于等于右侧所有数。

直观想法是用两个数组a、b。a[i]、b[i]分别保存从前到i的最大的数和从后到i的最小的数，

一个解答：这需要两次遍历，然后再遍历一次原数组，

将所有data[i]>=a[i-1]&&data[i]<=b[i]的data[i]找出即可

给出这个解答后，面试官有要求只能用一个辅助数组，且要求少遍历一次。

94.微软笔试题

求随机数构成的数组中找到长度大于=3的最长的等差数列9 d- x' W) w9 ?" o3 b0 R

输出等差数列由小到大:

如果没有符合条件的就输出

格式：

输入[1,3,0,5,-1,6]

输出[-1,1,3,5]

要求时间复杂度，空间复杂度尽量小

95.华为面试题

1 判断一字符串是不是对称的，如：abccba

2.用递归的方法判断整数组a[N]是不是升序排列

96.08年中兴校园招聘笔试题

1．编写strcpy 函数

已知strcpy 函数的原型是

char *strcpy(char *strDest, const char *strSrc);

其中strDest 是目的字符串，strSrc 是源字符串。不调用C++/C 的字符串库函数，请

编写函数 strcpy

最后压轴之戏，终结此微软等100题系列V0.1版。

那就，

连续来几组微软公司的面试题，让你一次爽个够：

======================

97.第1组微软较简单的算法面试题

1.编写反转字符串的程序，要求优化速度、优化空间。

2.在链表里如何发现循环链接？

3.编写反转字符串的程序，要求优化速度、优化空间。

4.给出洗牌的一个算法，并将洗好的牌存储在一个整形数组里。

5.写一个函数，检查字符是否是整数，如果是，返回其整数值。

（或者：怎样只用4行代码编写出一个从字符串到长整形的函数？）

98.第2组微软面试题

1.给出一个函数来输出一个字符串的所有排列。

2.请编写实现malloc()内存分配函数功能一样的代码。

3.给出一个函数来复制两个字符串A和B。字符串A的后几个字节和字符串B的前几个字节重叠。

4.怎样编写一个程序，把一个有序整数数组放到二叉树中？

5.怎样从顶部开始逐层打印二叉树结点数据？请编程。

6.怎样把一个链表掉个顺序（也就是反序，注意链表的边界条件并考虑空链表）？

99.第3组微软面试题

1.烧一根不均匀的绳，从头烧到尾总共需要1个小时。

现在有若干条材质相同的绳子，问如何用烧绳的方法来计时一个小时十五分钟呢？

2.你有一桶果冻，其中有黄色、绿色、红色三种，闭上眼睛抓取同种颜色的两个。

抓取多少个就可以确定你肯定有两个同一颜色的果冻？（5秒-1分钟）

3.如果你有无穷多的水，一个3公升的提捅，一个5公升的提捅，两只提捅形状上下都不均匀，

问你如何才能准确称出4公升的水？（40秒-3分钟）

一个岔路口分别通向诚实国和说谎国。

来了两个人，已知一个是诚实国的，另一个是说谎国的。

诚实国永远说实话，说谎国永远说谎话。现在你要去说谎国，

但不知道应该走哪条路，需要问这两个人。请问应该怎么问？（20秒-2分钟）

100.第4组微软面试题，挑战思维极限

1.12个球一个天平，现知道只有一个和其它的重量不同，问怎样称才能用三次就找到那个球。

13个呢？（注意此题并未说明那个球的重量是轻是重，所以需要仔细考虑）（5分钟-1小时）

2.在9个点上画10条直线，要求每条直线上至少有三个点？（3分钟-20分钟）

3.在一天的24小时之中，时钟的时针、分针和秒针完全重合在一起的时候有几次？

都分别是什么时间？你怎样算出来的？（5分钟-15分钟）

终结附加题：

微软面试题，挑战你的智商

==========

说明：如果你是第一次看到这种题，并且以前从来没有见过类似的题型，

并且能够在半个小时之内做出答案，说明你的智力超常..）

1.第一题 . 五个海盗抢到了100颗宝石，每一颗都一样大小和价值连城。他们决定这么分：

抽签决定自己的号码（1、2、3、4、5）

首先，由1号提出分配方案，然后大家表决，当且仅当超过半数的人同意时，

按照他的方案进行分配，否则将被扔进大海喂鲨鱼

如果1号死后，再由2号提出分配方案，然后剩下的4人进行表决，

当且仅当超过半数的人同意时，按照他的方案进行分配，否则将被扔入大海喂鲨鱼。

依此类推

条件：每个海盗都是很聪明的人，都能很理智地做出判断，从而做出选择。

问题：第一个海盗提出怎样的分配方案才能使自己的收益最大化？

2.一道关于飞机加油的问题，已知：

每个飞机只有一个油箱，

飞机之间可以相互加油（注意是相互，没有加油机）

一箱油可供一架飞机绕地球飞半圈，

问题：

为使至少一架飞机绕地球一圈回到起飞时的飞机场，至少需要出动几架飞机？

（所有飞机从同一机场起飞，而且必须安全返回机场，不允许中途降落，中间没有飞机场）

本文链接

个人对一道百度面试题的实现

2011-09-01T02:46:00Z

今天看到园子里的一篇博文，链接如下：http://www.cnblogs.com/sdlypyzq/archive/2011/08/31/2161067.html，给出了一道百度面试题如下：

假设一整型数组存在若干正数和负数，现在通过某种算法使得该数组的所有负数在正数的左边，且保证负数件和正数间元素相对位置不变。

例如
-3 4 2 -1 7 3 -5
排序后
-3 -1 -5 4 2 7 3

下面给出自己的一个简单的实现，懒得开VS了，直接上Notepad++了。。代码如下：

本文链接

基于.NET的分词软件设计与实现V7.0--移植B/S（完结篇）

2011-07-31T02:45:00Z

之前的文章介绍了个人分词软件在介入数据库作为词典存储介质后的表现，为了让分词软件能够更好得得到展示，本篇讲介绍将其移植B/S端的相关方法。

在《基于.NET的分词软件设计与实现V3.0--对比测试及改变》中，我介绍了很多基于B/S和C/S的分词程序，在移植B/S端时，我参照了很多相关的功能，并从中提炼了四个最主要的功能（其中标注不作为本分词软件的重点，故予以排除）：

1、以“\”为间隔的切分；

2、以“ ”为间隔的切分（所谓的“北大标准”切分）；

3、去除文本标点；

4、在之前的版本中我进行了去除文本格式的尝试，虽然在对比测试后没有予以使用，但在这里依然作为一个附属功能提炼出来，称为“去除文本格式”，即去除文本中多余的换行符、空格符等。

　代码清单：

1、HTML代码：

1 <div id="header">
2 </div>
3 <div id="logo">
4 <div id="imgLogo">
5 </div>
6 </div>
7 <div id="container">
8 <div id="bk_container">
9 <label id="inputMessage"> 请输入需要分词的文本：</label>
10 <textarea id="tbContent" cols="85" rows="20"></textarea>
11 <div id="option">
12 <input type="checkbox" id="ckPunc" /> 去除文本标点
13 <input type="checkbox" id="ckFormat" /> 去除文本格式
14 <input type="checkbox" id="ckPeking" /> 使用北大标准输出
15 <img src="img/bt_splitter.gif" id="btnSubmit" alt="分词" onclick="getResult();" />
16 </div>
17 <label id="result"> 分词处理结果：</label>
18 <textarea id="tbResult" cols="85" rows="20"></textarea>
19 </div>
20 </div>
21 <div id="footer">
22 <div id="footerImg">
23 </div>
24 </div>
25 <script src="js/ajax.js" type="text/javascript"></script>
26 <script src="js/segment.js" type="text/javascript"></script>

展示效果（介于保密，故不展示页面的header和footer信息）：

2、ajax.js代码：

1 var MyxAjax =
2 {
3 arrXmlHttp: [],
4 getXmlHttp: function() {
5 var xmlHttp = false;
6 try {
7 xmlHttp = new ActiveXObject("Microsoft.XMLHTTP");
8 }
9 catch (e) {
10 try {
11 xmlHttp = new ActiveXObject("Msxml2.XMLHTTP");
12 }
13 catch (E) {
14 xmlHttp = false;
15 }
16 }
17 if (!xmlHttp && typeof XMLHttpRequest != 'undefined') {
18 xmlHttp = new XMLHttpRequest();
19 }
20 return xmlHttp;
21 },
22
23 clearXmlHttp: function() {
24 for (var i = 0, ln = this.arrXmlHttp.length; i < ln; i++) {
25 if (this.arrXmlHttp[i]) {
26 try {
27 delete this.arrXmlHttp[i];
28 } catch (e) { }
29 }
30 }
31 this.arrXmlHttp = [];
32 },
33
34 send: function(url, options) {
35 var xmlHttp = this.getXmlHttp();
36 var _options = {
37 method: "GET",
38 data: null,
39 successCallback: function() { },
40 failCallback: function() { }
41 };
42 for (var property in options) {
43 _options[property] = options[property];
44 }
45 xmlHttp.open(_options.method, url, true);
46 if (_options.method == "POST") {
47 xmlHttp.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
48 }
49 xmlHttp.onreadystatechange = function() {
50 if (xmlHttp.readyState == 4) {
51 if (xmlHttp.status >= 200 && xmlHttp.status < 300) {
52 _options.successCallback(xmlHttp, _options.data);
53 }
54 else {
55 _options.failCallback(xmlHttp, _options.data);
56 }
57 }
58 }
59 this.clearXmlHttp();
60 xmlHttp.send(_options.data);
61 this.arrXmlHttp.push(xmlHttp);
62 return xmlHttp;
63 }
64 }

在测试的过程中，发现所有的基于B/S的分词软件都在分词操作的时候进行了页面刷新，个人觉得这影响了用户体验，故在个人的分词软件移植B/S端时，使用Ajax技术，使页面不进行刷新。

上述ajax.js的代码是个人封装的Ajax操作类，里面包含了常见的Ajax操作。

3、segment.js代码：

1 function $$(id) {
2 return document.getElementById(id);
3 }
4
5 function getResult() {
6 if ($$('tbContent').value == "") {
7 alert("请输入需要进行分词的内容！");
8 return;
9 }
10 var url = "Handler.ashx?";
11 var params = "content=" + encodeURIComponent($$('tbContent').value);
12 MyxAjax.send(url, { method: "POST", data: params, successCallback: showResult });
13 }
14
15 function showResult(req, data) {
16 var result = req.responseText;
17 if ($$('ckPunc').checked)
18 result = result.replace(/\\[·～！◎￥％…※×（）－—＝【『』】÷§：；”“‘’，《。》、？～｀！￥％＾＆＊（）＿－＝［｛］｝＼｜；：＂＇，．／＜＞？]\\/g, '\\');
19 if ($$('ckFormat').checked)
20 result = result.replace(/[ \r\n　]+/g, '');
21 if ($$('ckPeking').checked)
22 result = result.replace(/\\/g, ' ');
23 $$('tbResult').value = result;
24 }

这里要注意两句代码：

encodeURIComponent($$('tbContent').value)：对分词的内容进行了编码处理，去除了特殊字符的影响。

MyxAjax.send(url, { method: "POST", data: params, successCallback: showResult })：这里必须使用POST传值，而不能使用GET方式，这是基于以下两点进行考虑的：

（1）、POST传输数据时，不需要在URL中显示出来，而GET方法要在URL中显示；

（2）、POST传输的数据量大，可以达到2M，而GET方法则会受到URL长度的限制，参见官方资料：

（3）、基于搜索引擎的收录考虑，POST传值模式的收录量很好，但是GET传值模式就会有所不同，百度几乎不收，谷歌还好，当然这跟搜索引擎本身也有关系。

综上所述，基于安全、用户分词文本的长度未知以及SEO三方面的考虑，这里选择了POST的传参方式。

4、Handler.ashx代码：

1 public void ProcessRequest(HttpContext context)
2 {
3 Splitter s = new Splitter(context.Server.MapPath("~/Resources/Vocabulary.txt"), context.Server.MapPath("~/Resources/ChinesePunctuations.txt"), context.Server.MapPath("~/Resources/EnglishPunctuations.txt"));
4 s.InputStr = HttpUtility.HtmlDecode(context.Request["content"].ToString());
5 string result = s.GetResult();
6 context.Response.Write(result);
7 }

5、Splitter.cs代码：

1 public class WebSplitter
2 {
3 #region 字段属性
4
5 /// <summary>
6 /// 待分词文本
7 /// </summary>
8 public string InputStr { get; set; }
9 /// <summary>
10 /// Updated：分词词典(HashSet)
11 /// </summary>
12 HashSet<string> _dict = new HashSet<string>();
13 /// <summary>
14 /// 中文标点分隔符
15 /// </summary>
16 string _chineseSpiltters;
17 /// <summary>
18 /// 英文标点分隔符
19 /// </summary>
20 string _englishSpiltters;
21 /// <summary>
22 /// 非中文字符（包括数字、英文及英文标点符号）正则表达式
23 /// </summary>
24 Regex _nonChineseRegex;
25 /// <summary>
26 /// 中文字符正则表达式
27 /// </summary>
28 Regex _chineseRegex;
29 /// <summary>
30 /// 中文标点符号正则表达式
31 /// </summary>
32 Regex _chinesePunctuationRegex;
33 /// <summary>
34 /// Updated：是否对待分词文本作格式化（即是否保留原来文本的格式）
35 /// </summary>
36 //bool _isinit = false;
37 public bool IsFormat { get; set; }
38 /// <summary>
39 /// Updated：是否去除待分词文本的标点
40 /// </summary>
41 //bool _isStripPunctuation = false;
42 public bool IsStripPunctuation { get; set; }
43 /// <summary>
44 /// Updated：是否使用北大标准输出（以空格为间隔），默认为973标准（以\为间隔）
45 /// </summary>
46 public bool IsPekingStandard { get; set; }
47
48 #endregion
49
50 #region 构造函数
51
52 public WebSplitter()
53 {
54 _dict = GetVocabularyDictionary("Vocabulary.txt");
55 _chineseSpiltters = GetPunctuationDictionary("ChinesePunctuations.txt");
56 _englishSpiltters = GetPunctuationDictionary("EnglishPunctuations.txt");
57
58 _nonChineseRegex = new Regex("[" + _englishSpiltters + "0-9A-Za-z]+");
59 _chineseRegex = new Regex(@"[\u4e00-\u9fa5]+");
60 _chinesePunctuationRegex = new Regex("[" + _chineseSpiltters + "]+");
61 }
62
63 public WebSplitter(string vocabularyPath, string chinesePunctuationsPath, string englishPunctuations)
64 {
65 _dict = GetVocabularyDictionary(vocabularyPath);
66 _chineseSpiltters = GetPunctuationDictionary(chinesePunctuationsPath);
67 _englishSpiltters = GetPunctuationDictionary(englishPunctuations);
68
69 _nonChineseRegex = new Regex("[" + _englishSpiltters + "0-9A-Za-z]+");
70 _chineseRegex = new Regex(@"[\u4e00-\u9fa5]+");
71 _chinesePunctuationRegex = new Regex("[" + _chineseSpiltters + "]+");
72 }
73
74 #endregion
75
76 #region 私有方法
77
78 /// <summary>
79 /// 创建分词字典
80 /// </summary>
81 /// <param name="dictPath">分词字典存放路径</param>
82 HashSet<string> GetVocabularyDictionary(string dictPath)
83 {
84 var arrVocabulary = File.ReadAllLines(dictPath, Encoding.Default);
85 foreach (string s in arrVocabulary)
86 {
87 _dict.Add(s);
88 }
89 return _dict;
90 }
91
92 /// <summary>
93 /// 创建分隔符组成的字符串
94 /// </summary>
95 /// <param name="dictPath">分隔符字典存放路径</param>
96 string GetPunctuationDictionary(string dictPath)
97 {
98 StringBuilder strBuilder = new StringBuilder();
99 var arrPunctuation = File.ReadAllLines(dictPath);
100 foreach (string s in arrPunctuation)
101 {
102 strBuilder.Append(s);
103 }
104 return strBuilder.ToString();
105 }
106
107 /// <summary>
108 /// Updated：对待分词文本进行预处理（如删除一个或多个标点符号、空白字符、换行符等)
109 /// </summary>
110 /// <param name="str">待分词文本</param>
111 string PreProcess()
112 {
113 Regex regex = new Regex("[ \r\n　]+");
114 if (regex.IsMatch(InputStr))
115 {
116 InputStr = regex.Replace(InputStr, "");
117 }
118 return InputStr.Trim();
119 }
120
121 /// <summary>
122 /// 为所有数字英文添加分隔符
123 /// </summary>
124 /// <returns></returns>
125 string SplitNonChinese()
126 {
127 //Updated
128 if (IsFormat)
129 InputStr = PreProcess();
130
131 for (int j = 0; j < _nonChineseRegex.Matches(InputStr).Count; j++)
132 {
133 InputStr = InputStr.Insert(_nonChineseRegex.Matches(InputStr)[j].Index + _nonChineseRegex.Matches(InputStr)[j].Value.Length, @"\");
134 }
135 return InputStr;
136 }
137
138 /// <summary>
139 /// Updated：去除待分词文本中的标点
140 /// </summary>
141 string StripPunctuation()
142 {
143 InputStr = SplitNonChinese();
144 foreach (var item in _chinesePunctuationRegex.Matches(InputStr))
145 {
146 InputStr = InputStr.Replace(item.ToString(), "");
147 }
148 return InputStr;
149 }
150
151 /// <summary>
152 /// 为所有中文标点添加分隔符
153 /// </summary>
154 string SplitChinesePunctuation()
155 {
156 InputStr = SplitNonChinese();
157 for (int i = 0; i < _chinesePunctuationRegex.Matches(InputStr).Count; i++)
158 {
159 InputStr = InputStr.Insert(_chinesePunctuationRegex.Matches(InputStr)[i].Index + _chinesePunctuationRegex.Matches(InputStr)[i].Value.Length, @"\");
160 }
161 return InputStr;
162 }
163
164 /// <summary>
165 /// 为所有汉字添加分隔符
166 /// </summary>
167 string SplitChinese()
168 {
169 //Updated
170 if (IsStripPunctuation)
171 InputStr = StripPunctuation();
172 else
173 InputStr = SplitChinesePunctuation();
174
175 StringBuilder sb = new StringBuilder(InputStr);
176 int i = 0;
177 foreach (Match item in _chineseRegex.Matches(sb.ToString()))
178 {
179 sb = sb.Insert(item.Index + item.Value.Length + i, "\\");
180 i++;
181 }
182 return sb.ToString();
183 }
184
185 /// <summary>
186 /// 采用逆向匹配算法对字符串进行分词操作
187 /// </summary>
188 /// <param name="str">待分词的字符串</param>
189 List<string> Spiltter(string str)
190 {
191 List<string> result = new List<string>();
192
193 string initStr = str.Remove(0, 1);
194 int l = 0;
195
196 while (!string.IsNullOrEmpty(initStr))
197 {
198 for (int i = 1; i < str.Length; i++)
199 {
200 if (initStr.Length == 1 || _dict.Contains(initStr))
201 {
202 if (Regex.IsMatch(initStr, "[　 \n\r]+"))
203 result.Add(initStr);
204 else
205 result.Add(initStr + "\\");
206
207 l += initStr.Length;
208 initStr = str.Remove(str.Length - l, l);
209 break;
210 }
211 else
212 {
213 initStr = initStr.Remove(0, 1);
214 }
215 }
216 }
217 return result;
218 }
219
220 /// <summary>
221 /// 输出最终结果（仅在IsFormat属性为true时执行）
222 /// </summary>
223 string OutputResult(string str)
224 {
225 str = str.Replace("\\", " ");
226 return str;
227 }
228
229 #endregion
230
231 #region 公有方法
232
233 /// <summary>
234 /// 获得分词结果
235 /// </summary>
236 /// <param name="str">待分词文本</param>
237 public string GetResult()
238 {
239 StringBuilder strBuilder = new StringBuilder();
240 List<string> splitterResult = new List<string>();
241 List<string> strList = SplitChinese().Split('\\').ToList();
242
243 for (int i = 0; i <= strList.Count - 1; i++)
244 {
245 if (!string.IsNullOrEmpty(strList[i]))
246 {
247 if (strList[i].Length == 1 || _nonChineseRegex.IsMatch(strList[i]) || _dict.Contains(strList[i]))
248 {
249 strBuilder.Append(strList[i] + "\\");
250 }
251 else
252 {
253 splitterResult = Spiltter(strList[i]);
254 for (int q = splitterResult.Count - 1, p = q; p >= 0; p--)
255 {
256 strBuilder.Append(splitterResult[p]);
257 }
258 }
259 }
260 }
261
262 //Updated
263 if (IsPekingStandard)
264 return OutputResult(strBuilder.ToString());
265
266 return strBuilder.ToString();
267 }
268 #endregion
269 }

　　最终效果：

1、默认输出：

2、去除文本标点：

3、去除文本标点+格式：

4、去除文本标点+格式+以北大标准输出：

至此，终于将自己在四月下旬到五月上旬对于分词软件进行的一些研究整理完毕，最后谢谢一路关注偶的园友们，还望能够得到大家的宝贵意见和建议。

系列索引：

1、基于.NET的分词软件设计与实现V1.0--总体思路及算法实现

2、基于.NET的分词软件设计与实现V2.0--性能问题说明及功能增强

　 3、基于.NET的分词软件设计与实现V3.0--对比测试及改变

　 4、基于.NET的分词软件设计与实现V4.0--使用SortedList提高分词效率

5、基于.NET的分词软件设计与实现V5.0--使用Hashtable和HashSet<T>提高分词效率

6、基于.NET的分词软件设计与实现V6.0--使用数据库篇（涉及索引、聚集因子和存储过程）

7、基于.NET的分词软件设计与实现V7.0--移植B/S

本文链接

分享几个asp.net开源图表组件

2011-07-27T02:49:00Z

1、NPlot：http://netcontrols.org/nplot/：我觉得是.NET开源轻量级中最好的

2、graphviz(quickgraph)：这个大家可以搜索一下，功能很强大(看介绍和图片)。

3、ZedGraph：原题“A flexible line graph class library in C#”，在codeproject.com上，效果不错；

4、Graph Library：在codeproject.com上，有bar、line、pie三种样式；

5、Full Customizable 3D PieChart with ASP.net，WebForm，在codeproject.com上，3d饼图；

6、ASPCharts，WebForm，在codeproject.com上；

7、ASPChartNet，WebForm，在codeproject.com上；

8、Web Chart，WebForm，在codeproject.com上，效果非常不错；

9、SharpVectorGraphics，这是一个矢量图形库，效果一流；

10、dotnetcharting：http://www.dotnetcharting.com/，就是不开源，但效果一流，仍然写在这里。

本文链接

基于.NET的分词软件设计与实现V6.0--使用数据库篇（涉及索引、聚集因子和存储过程）

2011-07-22T09:33:00Z

忙了一阵子，今天用空下来的一点时间来总结一下之前未完成的分词系列吧。。

上篇提到了使用HashSet<T>作为词典存储数据结构的方法，这也是在不使用数据库的情况下，自己在能力范围之内找到的最佳的解决方案。

但是，如果使用数据库呢，好吧，下面就让我们来看在使用数据库的情况下，本分词软件的表现。

　一、建立数据库

在之前的版本中，分词的词典都以文本的形式直接保存在txt文件中，这里自然要将其全部转存到数据库的表中，介于词典采用的是每行存取一个词的方法，我采用的方法是循环读取文本文档的每一行，随后使用insert语句将其录入数据库的表中。

随后我们不作任何优化措施，直接开始简单的测试，首先开启SQL中显示统计信息和分析、编译、执行各语句耗时的功能：

SET STATISTICS IO ON
SET STATISTICS TIME ON

来看一下查询“他们”这个简单的词，select * from Vocabulary where item = '他们'

SQL中的执行结果：

注意下面几个数据：逻辑读取871次，CPU时间=62毫秒，占用时间=59毫秒。

随后，我们将程序中判断某个词是否存在的程序改为：

/// <summary>
/// Updated：判断是否在词典中出现
/// </summary>
/// <param name="str"></param>
/// <returns></returns>
bool isExist(string str)
{
DBHelper db = new DBHelper();
return Convert.ToInt32(db.ExecuteScalar("select count(*) from Vocabulary where item = '" + str + "'")) > 0;
}

起初我计划以1000字的文本测试，但最后发现这个想法很不现实，为什么？让我们看下100字文本的分词结果就知道了：

没错，100字的文本分词时间居然达到了20+秒，无法忍受的一个结果。

　二、优化第一步——建立索引

索引的文章园子里面有很多，从原理到实例都有些经典的，这里自不必多说，这里主要看一下索引在本分词软件中的应用。

首先，我们频繁使用item字段，也就是保存词的字段进行查询，且其是表的主键，很适合建立聚集索引：

USE [Splitter]
GO
/****** 对象: Index [PK_Vocabulary] 脚本日期: 05/06/2011 23:56:26 ******/
CREATE CLUSTERED INDEX [PK_Vocabulary] ON [dbo].[Vocabulary]
(
[item] ASC
)
WITH
(
SORT_IN_TEMPDB = OFF,
DROP_EXISTING = OFF,
IGNORE_DUP_KEY = OFF,
ONLINE = OFF
)
ON [PRIMARY]

好了，建立完成后来看一下最终的结果：

是不是看着顺眼多了（附加一句：py和len两个字段是我为了方便某些特殊查询，比如看有多少个拼音简写是ab的词等，在程序中木有用处）。

下面以相同的语句查询“他们”这个词，看下结果：

注意下面几个数据：逻辑读取2次，CPU时间=0毫秒，占用时间=11毫秒。耗时明显大幅度降低了。

　三、优化第二步——使用填充因子

　填充因子百分比指首次创建索引时索引页的叶级别充满程序，若没有显示设置，则默认为0。

当最初生成索引时，SQLServer 将索引 B 树结构放置在连续的物理页上，以便通过连续 I/O 扫描索引页获取最佳 I/O 性能。当由于发生页拆分，需要将新的页插入索引的逻辑 B 树结构时，SQL Server 必须分配新的 8 KB 索引页。这种插入发生在硬盘上的其它位置，从而打断了索引页的物理连续特性。使 I/O 操作从连续变为不连续，从而使得性能减低一半。可以通过重建索引页以恢复索引页的物理连续顺序来解决过多的页拆分。聚集索引的叶级也会遇到相同的问题，从而影响表的数据页。

100%填充因子可以提升读取的性能，但会减缓写活动的功能，引发频繁的页拆分，因为数据库引擎为了在数据页中得到空间必须持续地交换行的位置。

填充因子太低会给插入带来便利，但读取较慢，因为如果填充因子太小,就需要使用更多的页来保存数据，而更多页就意味着每个查询要读取的物理数据页读操作的数量也变得更多，此时，读和写操作的机能都会降低。

最佳实践：在没有修改活动的表中使用100%的填充因子，中低活动的使用70-90%，高活动的使用50%甚至更低的填充因子。

USE [Splitter]
GO
/****** 对象: Index [PK_Vocabulary] 脚本日期: 05/06/2011 23:56:26 ******/
CREATE CLUSTERED INDEX [PK_Vocabulary] ON [dbo].[Vocabulary]
(
[item] ASC
)
WITH
(
PAD_INDEX = ON,
FILLFACTOR = 100, --填充因子100%
SORT_IN_TEMPDB = OFF,
DROP_EXISTING = OFF,
IGNORE_DUP_KEY = OFF,
ONLINE = OFF
)
ON [PRIMARY]

上面的代码演示了创建聚集索引并指定100%的填充因子。

继续看一下数据库中查询“他们”的效果：

注意下面几个数据：逻辑读取3次，CPU时间=0毫秒，占用时间=1毫秒。

可以看到较建立索引并使用默认填充因子的表现又更进了一步。

下面可以看一下1000字文本的测试结果了：

可以看到，1000字的文本仅仅花了1.7秒左右，较之前没有使用索引的惨不忍睹有了不少好转。

　四、优化第三步——使用存储过程

　首先，列举一下公认的存储过程的几个优点：

•高效：

–存储过程只在建立时编译，以后每次执行就不需要重新编译，而一般SQL语句每执行一次都需要先分析，然后再执行，所以使用存储过程可提高SQL语句的执行效率。

–存储过程代码直接存储于数据库中，不会产生大量T-sql语句的代码流量，显著降低了网络流量。

•安全：存储过程执行时，使用的是参数化的SQL语句，防止了常见的如SQL注入攻击等。

•可复用，可维护性高：更新存储过程通常比更改、测试以及重新部署程序集需要较少的时间和精力。

　由于分词过程中需要大量重复的执行SQL语句，那到底使用存储过程对于执行效率有没有提高呢，那我们一试：

USE [Splitter]
GO
/****** 对象: StoredProcedure [dbo].[IsExist] 脚本日期: 05/07/2011 01:34:56 ******/
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO

CREATE PROCEDURE [dbo].[IsExist]
(
@item varchar(50),
@result int output
)
AS
BEGIN
SET NOCOUNT ON;

SELECT @result = count(*) from Vocabulary WHERE item = @item
END

程序中详细调用步骤：

bool isExist(string str)
{
SqlConnection con = new SqlConnection(ConfigurationManager.ConnectionStrings["ConnectionString"].ToString());
con.Open();
SqlCommand cmd = new SqlCommand("IsExist", con);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add(new SqlParameter("@item", SqlDbType.VarChar, 50));
cmd.Parameters["@item"].Value = str;
cmd.Parameters.Add(new SqlParameter("@result", SqlDbType.Int));
cmd.Parameters["@result"].Direction = ParameterDirection.Output;
int result = cmd.ExecuteNonQuery();
con.Close();
return Convert.ToBoolean(result);
}

再次对1000字的文本进行测试，时间有小幅提升，大致在1.3秒左右，较之前有25%左右的性能提升。

　五、总结
至此算是完成了本分词软件的所有研究，进行一个总结示例如下（其中V5.0和V6.0合并在上篇一起讲了）：

不过这还木有完结，下篇将是最后一篇，讲述本分词软件移植BS时的最后展示效果。

本文链接

编程心语（五）—— Summer Vacation Job Diary（July）

2011-07-13T08:32:00Z

Update：2011-07-13

July again , I reviewed my blog posts , and surprisedly found out that I started the internship on July 12, 2010 , For now , July 13, 2011, an entire year , what a coincidence.

Ok, I hope I can get something new from it , new programming skills , new project experience , etc.

Come on.

本文链接

基于.NET的分词软件设计与实现V5.0--使用Hashtable和HashSet<T>提高分词效率

2011-07-03T01:13:00Z

上篇使用了SortedList，对分词的性能有了显著的改进，但是有一点偶没有提，那就是构造词典的时间，由于SortedList需要保证元素的有序性，所以对于我使用的20+万的词典来说，构造时间也达到了10秒左右，因此与之前的三个版本相比，虽然分词的性能大幅提升，但总的时间并没有什么改进，所以使用SortedList的方案自然也不可行，那让我们看看之前提到的Hashtable表现如何。

一、Hashtable的优势——高效的查找

时间复杂度：

这无疑是Hashtable最大的优势所在，对于之前提到的数据结构：ArrayList采用顺序查找，时间复杂度为O(n)，而SortedList采用二分查找，时间复杂度为O(logN)，而Hashtable则是O(1)。

　 原理：

当Hashtable添加数据时，(例如:hash.Add(key)) 首先调用当前键值key的GetHashCode()方法，得到哈希值（该值为Int32），取该哈希值的绝对值跟内部数组（上面代码的buckets）的总容量进行余运算(就是'%'操作)，得到一个小于总容量的值，把该值当做数组序号，存在对应的位置。

Hashtable之所以查找高效，是因为其存储的元素都是通过键值对的形式进行存储的，需要某个元素的值时，可通过映射Key值，找到数组中对应的索引位置，然后取出元素，整个过程无需循环。

　 代价：

哈希表高效的查找是有代价的，那就是内存，不过，介于现在硬件的发展速度，这种用空间换时间的做法显然没有任何压力。

二、Hashtable的不足

1、哈希表不能有重复键值

这意味着我们在进行哈希表构造时，需要在添加元素时进行判断，若其Key值不存在，则不用重复添加，否则报错。

2、哈希表会占用更多内存

之前提到哈希表高效的查找是以内存为代价的，而原理又是怎样的呢？

首先，我们实例化ArrayList或List<T>的时候,如果不指定容量,则其内部是赋值为一个静态的空数组。当有添加操作时，会实例化为一个长度为4的数组，如果容量满了以后，再添加，就会自动扩充为两倍的容量。所以使用ArrayList和List <T>的时候，建议在实例化方法里指定容量。

哈希表也有一个类似的情况，new Hashtable()如果不指定长度，则会将内置bucket数组的长度默认指定为11。如果给定一个值如new Hashtable(20)，也并不会将bucket数组长度设置为20，而是循环内部一个素数数组,设置为刚好大于20的素数（此处是23，由此可知，哈希表内部存取数组长度总是一个素数）。

此外，哈希表在未存满的情况下就要扩充： Hashtable有一个加载因子为0.72f。实际能存储的数据量等于内部长度* 0.72f。也就是说在Hashtable中，假如初始化了100个位置，只有72个可用，其他28个不能用，但仍然要占着地方。由于哈希算法本身的特点，哈希表内部存取数组长度总是一个素数，所以当需要扩充时，新的数组长度是刚好大于原数组二倍长度的素数，也就是说略大于二倍。

三、Hashtable——Q&A

其实，在刚接触Hashtable的时候，就看到一句话，也是上文提到的——哈希表内部存取数组长度总是一个素数，比较不解，如果你和我当时一样有着相同的疑问，那么下面的话希望能够解答。

哈希表大小为素数在理论上是有依据的，针对不同的哈希算法有不同的证明。例如，对于平方探测法，有如下定理：如果使用平方探测，且表大小是素数，那么当表至少有一半是空的时候，总能够插入一个新的元素。

hash函数用质数来做模运算(%)，分析发现,如果不是用质数来做模运算的话，很多生活中的数据分布会集中在某些点上，所以需要采用质数做模的除数。

因为用质数做了模的除数，自然存储空间的大小也用质数了，因为模完之后,数据是在[0-所选质数]之间。

四、HashSet<T>对于Hashtable的改进

之前提到的一个Hashtable不允许添加重复值，所以我们构造词典的时候代码会是这样：

可以看到Hashtable是使用键-值方式进行存储的，但有些时候，我们只需要其中一个值，比如上图所示的情况，我只需要词典中的词，对于value我们不需要进行设置，所以这样就造成了内存浪费。

不过其实有一种数据结构可以改变这样的情况，那就是HashSet<T>，HashSet<T>只保存一个值，所以更加适合处理这种情况。

HashSet<T>每条数据只保存一项，并不采用Key-Value的方式，换句话说，HashSet<T>中的Key就是Value，假如已经知道了Key，也没必要再查询去获取Value，需要做的只是检查值是否已存在。

HashSet<T>的Add方法返回bool值，在添加数据时，如果发现集合中已经存在，则忽略这次操作，并返回false值。而Hashtable和Dictionary<TKey,TValue>碰到重复添加的情况会直接抛出错误。

但HashSet<T>不能使用下标来访问元素，如：hs[1]。

所以上面的代码就可以写作：

看着舒心了些吧。。。

五、HashSet<T>在个人分词软件中的应用效果

好了，介绍的差不多，来看下最终的效果吧，以之前的那个完整的测试文本进行测试：

启动毫无压力，运行结果也灰常满意。

到此为此，介绍了个人在分词软件上对于算法、数据结构等方面的研究、测试与改进，最后的这个HashSet<T>的词典版本，也是个人的最终版本。

不过之前的所有测试使用的词典都是以文本形式存储的，下篇将介绍使用数据库进行词典存储后，分词软件的性能表现及相关改进。

本文部分内容参考了园子里面的文章，在此附上友情链接：http://www.cnblogs.com/hkncd/archive/2011/05/06/2035684.html

本文链接

基于.NET的分词软件设计与实现V4.0--使用SortedList提高分词效率

2011-07-02T14:49:00Z

隔了一段时间，忙其他的去了，下面继续偶之前的分词软件。

在之前的3个版本里，我们已经实现了分词的基本功能，并对其合理性等作了大量的测试评估工作，但是性能的提升还很不如意，所以这里我提出了使用SortedList提高分词效率的方案。

C#中提供了众多集合类的数据结构，如大家常用的List<T>，Dictionary<T>等，这里我将着重介绍一下SortedList，并实现其在偶的分词软件中的应用。

一、SortedList简介

引自MSDN：SortedList 元素可通过其键来访问（如任意 IDictionary 实现中的元素），或通过其索引来访问（如任意 IList 实现中的元素）。

SortedList 在内部维护两个数组以存储列表中的元素；即，一个数组用于键，另一个数组用于相关联的值。每个元素都是一个可作为 DictionaryEntry 对象进行访问的键/值对，键不能为空引用（在 Visual Basic 中为 Nothing），但值可以。 SortedList 的容量是 SortedList 可以保存的元素数。SortedList 的默认初始容量为 0。随着元素添加到 SortedList 中，在需要时可以通过重新分配自动增加容量。可通过调用 TrimToSize 或通过显式设置 Capacity 属性减少容量。

SortedList 的元素将按照特定的 IComparer 实现（在创建 SortedList 时指定）或按照键本身提供的 IComparable 实现并依据键来进行排序。不论在哪种情况下，SortedList 都不允许重复键。索引顺序基于排序顺序。当添加元素时，元素将按正确的排序顺序插入 SortedList，同时索引会相应地进行调整。当移除元素时，索引也会相应地进行调整。因此，当在SortedList 中添加或移除元素时，特定键/值对的索引可能会更改。由于要进行排序，所以在 SortedList 上操作比在 Hashtable 上操作要慢。但是，SortedList 允许通过相关联键或通过索引对值进行访问，可提供更大的灵活性。可使用一个整数索引访问此集合中的元素。此集合中的索引从零开始。 C# 语言中的 foreach 语句（在 Visual Basic 中为 for each）需要集合中每个元素的类型。由于 SortedList 的每个元素都是一个键/值对，因此元素类型既不是键的类型，也不是值的类型。而是 DictionaryEntry 类型。

二、SortedList介绍——个人整理

我们知道对于List<T>等集合，在查找某个元素是否存在时使用的是顺序遍历查找法，这样查询的偶然性比较大，效率低，而SortedList则采用了二分查找法，显著提高了查找效率（二分查找的介绍就略了吧）。

SortedList保存数据时和哈希表一样用Key-Value的方式进行存储，但不同的是，它把Key和Value分别保存在两个object[]数组中，每次插入删除操作都会保持这两个object[]大小的同步性。

SortedList在初始化时如果不指定大小，则会给一个默认的十六进制值0x10（16），在添加操作中，如果容量不足则会自动扩充为2倍容量，这些与ArrayList和Hashtable相同。

SortedList的独特之处在于它保证数据的有序性，这点是如何保证呢？

原来，在Add（key，value）方法中，SortedList会首先用二分查找插入的key值，如果有重复项，则报错，如果没有重复项，则根据key值大小，比较得出在集合中的位置，然后插入到该位置中，反编译查看源代码如下：

1 public void Add(TKey key, TValue value)
2 {
3 if (key == null)
4 {
5 System.ThrowHelper.ThrowArgumentNullException(System.Exceptio
6 nArgument.key);
7 }

//二分查找
8 int num = Array.BinarySearch<TKey>(this.keys, 0, this._size, key, this.comparer);
9 if (num >= 0)
10 {
11 System.ThrowHelper.ThrowArgumentException(System.ExceptionResource.Argument_AddingDuplicate);
12 }
13 this.Insert(~num, key, value);
14 }
15
16 private void Insert(int index, TKey key, TValue value)
17 {
18 if (this._size == this.keys.Length)
19 {
20 this.EnsureCapacity(this._size + 1);
21 }
22 if (index < this._size)
23 {
24 Array.Copy(this.keys, index, this.keys, index + 1, this._size - index);
25 Array.Copy(this.values, index, this.values, index + 1, this._size - index);
26 }
27 this.keys[index] = key;
28 this.values[index] = value;
29 this._size++;
30 this.version++;
31 }

由于要进行排序，所以在 SortedList 上操作比在 Hashtable 上操作要慢。

但是，SortedList 允许通过相关联键或通过索引对值进行访问，可提供更大的灵活性，因为SortedList 兼容了 Hashtable 和 Array 的特征，当使用 Item 索引器属性按照元素的键访问元素时，其行为类似于 Hashtable，当使用 GetByIndex 或 SetByIndex 按照元素的索引访问元素时，其行为又类似于 Array。所以对于Hashtable来说，用object型的Key值来匹配，而对于ArrayList来说，则用int型的下标序号来获取，而SortedList由于兼有二者的特征，所以既可以用object型的key获取，也可以用int型的序号来获取，从而提高了数据访问的灵活性。

示例如下：

1 public static void Main()
2 {
3 ArrayList arrList = new ArrayList();
4 arrList.Add("rocky");
5 Console.WriteLine(arrList[0]);
6
7 Hashtable ht = new Hashtable();
8 ht.Add("name", "rocky");
9 Console.WriteLine(hash["name"]);
10
11 SortedList sortedList = new SortedList();
12 sortedList.Add("name", "rocky");
13 sortedList.Add("hobby", "coding");
14 Console.WriteLine(sortedList["name"]);
15 Console.WriteLine(sortedList.GetByIndex(1));
16 }

此外，SortedList还有泛型版本：SortedList<TKey,TValue>，为了减少装箱拆箱带来的困扰，肯定优先使用泛型版本。

总结：

优点： 1、SortedList在添加元素时保证了集合中数据的有序性，并通过二分查找，显著提高了元素的查找效率。

　 2、SortedList兼容了ArrayList和Hashtable的数据访问方式，提高了数据访问的灵活性。

缺点： SortedList为了保证数据的有序性，所以构建时间较为耗时。

三、SortedList<TKey,TValue>在个人分词软件中的应用

首先，相对于第三个版本来说，这里将List<string> _dict = new List<string>();的词典构造方式改为：

SortedList<string, string> _dict = new SortedList<string, string>();

随后调用_dict的Add方法进行词典构造即可。

四、SortedList<TKey,TValue>在个人分词软件中的应用效果

其实，说了上面一大通，就是为了看选择SortedList这样的数据结构后能不能使分词性能得到显著的提升，还记得之前对1000字左右的文本进行分词，时间大概在8、9秒的样子，那下面就看一下SortedList的表现。

下面是之前的测试文本：

下面进行分词：

简直毫无压力。随后来点狠的，直接上之前2.0版中提到的完整的测试文本，看下分词效果：

依然毫无压力，可以看到每1000字的分词效率从之前的8、9秒一下提到了100毫秒左右，可以说是质的飞跃，也可以很好地看到SortedList在数据查找方面的优势。

下篇将使用上面提到的另一种数据结构——Hashtable进行测试。

系列索引：基于.NET的分词软件设计与实现索引

本文链接

博客园_This is where I belong！

帮GF解道笔试题

求一个字符串中所有字符出现的次数

各大公司（Google，Microsoft，Baidu， Microsoft Research Asia etc.）实习生面试题总汇

个人对一道百度面试题的实现

基于.NET的分词软件设计与实现V7.0--移植B/S（完结篇）

分享几个asp.net开源图表组件

基于.NET的分词软件设计与实现V6.0--使用数据库篇（涉及索引、聚集因子和存储过程）

五、总结至此算是完成了本分词软件的所有研究，进行一个总结示例如下（其中V5.0和V6.0合并在上篇一起讲了）：

编程心语（五）—— Summer Vacation Job Diary（July）

基于.NET的分词软件设计与实现V5.0--使用Hashtable和HashSet<T>提高分词效率

基于.NET的分词软件设计与实现V4.0--使用SortedList提高分词效率

　五、总结
至此算是完成了本分词软件的所有研究，进行一个总结示例如下（其中V5.0和V6.0合并在上篇一起讲了）：