1. A*搜寻算法
   俗称A星算法。这是一种在图形平面上， 有多个节点的路径，求出最低通过成本的算法。常用于游戏中的NPC的移动计算，或线上游戏的BOT的移动计算上。该算法像Dijkstra算法一样，可以找到一条最短路径；也像BFS一样，进行启发式 的搜索。
2. Beam Search
   束搜索(beam search) 方法是解决优化问题的一种启发式方法,它是在分枝定界方法基础上发展起来的,它使用启发式方法估计k 个最好的路径,仅从这k 个路径出发向下搜索,即每一层只有满意的结点会被保留,其它的结点则被永久抛弃,从而比分枝定界法能大大节省运行时间。束搜索于20 世纪70 年代中期首先被应用于人工智能领域,1976 年Lowerre 在其称为HARPY的语音识别系统中第一次使用了束搜索方法,他的目标是并行地搜索几个潜在的最优决策路径以减少回溯,并快速地获得一个解。
3. 二分取中查找算法
   一种在有序数组中查找某一特定元素 的搜索算法。搜素过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜素过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小 于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。这种搜索算法每一次比较都使搜索范围缩小一半。
4. Branch and bound
   分支定界 (branch and bound) 算法是一种在问题的解空间树上搜索问题的解的方法。但与回溯算法不同，分支定界算法采用广度优先或最小耗费优先的方法搜索解空间树，并且，在分支定界算法 中，每一个活结点只有一次机会成为扩展结点。
5. 数据压缩
   数据压缩是通过减少计算机中所存储数据或者通 信传播中数据的冗余度，达到增大数据密度，最终使数据的存储空间减少的技术。数据压缩在文件存储和分布式系统领域有着十分广泛的应用。数据压缩也代表着尺 寸媒介容量的增大和网络带宽的扩展。
6. Diffie–Hellman密钥协商
   Diffie–Hellman key exchange，简称“D–H”， 是一种安全协议。它可以让双方在完全没有对方任何预先信息的条件下通过不安全信道建立起一个密钥。这个密钥可以在后续的通讯中作为对称密钥来加密通讯内 容。
7. Dijkstra’s 算法
   迪科斯彻算法 （Dijkstra）是由荷兰计算机科学家艾 兹格·迪科斯彻（Edsger Wybe Dijkstra）发明的。算法解决的是有向图中单个源点到其他顶点的最短路径问题。举例来说，如果图中的顶点表示城市，而边上的权重表示著城市间开车行 经的距离，迪科斯彻算法可以用来找到两个城市之间的最短路径。
8. 动态规划
   动态规划是一种在数学和计算机科学中使用 的，用于求解包含重叠子问题的最优化问 题的方法。其基本思想是，将原问题分解为相似的子问题，在求解的过程中通过子问题的解求出原问题的解。动态规划的思想是多种算法的基础，被广泛应用于计算 机科学和工程领域。比较著名的应用实例有：求解最 短路径问题，背 包问题，项 目管理，网络流优 化等。这里也有一篇文章说得比较详细。
9. 欧几里得算法
   在数学中，辗转相除法，又称欧几里得算 法，是求最 大公约数的算法。辗转相除法首次出现于欧 几里得的《几 何原本》（第VII卷，命题i和ii）中，而在中国则可以追溯至东汉出现的《九 章算术》。
10. 最大期望（EM）算法
    在统计计算中，最大期望 （EM）算法是在概率（probabilistic） 模型中寻找参数最大似然估计的算法，其中概率模型依赖于无法观测的隐藏变量（Latent Variable）。 最大期望经常用在机 器学习和计 算机视觉的数 据聚类（Data Clustering） 领域。最大期望算法经过两个步骤交替进行计算，第一步是计算期望（E），利用对隐藏变量的现有估计值，计算其最大似然估计值；第二步是最大化（M），最大 化在 E 步上求得的最大似然值来计算参数的值。M 步上找到的参数估计值被用于下一个 E 步计算中，这个过程不断交替进行。
11. 快速傅里叶变换 (FFT)
    快 速傅里叶变换（Fast Fourier Transform，FFT），是离 散傅里叶变换的快速算法，也可用于计算离散傅里叶变换的逆变换。快速傅里叶变换有广泛的应用，如数 字信号处理、计算大 整数乘法、求解偏 微分方程等等。本条目只描述各种快速算法，对于离散傅里叶变换的性质和应用，请参见离 散傅里叶变换。
12. 哈希函数
    Hash Function是一种从任何一种数据中创建小的数字“指纹”的方法。该函数将数据打乱混合，重新创建一个叫做散列值的指纹。散列值通常用来代表一个短的 随机字母和数字组成的字符串。好的散列函数在输入域中很少出现散列冲突。在散列表和数据处理中，不抑制冲突来区别数据，会使得数据库记录更难找到。
13. 堆排序
    Heapsort 是 指利用堆 积树（堆） 这种数据结构所设计的一种排序算法。堆积树是一个近似完 全二叉树的结构，并同时满足堆积属性：即子结点的键值或索引总是小于（或者大于）它的父结点。
14. 归并排序
    Merge sort是 建立在归并操作上的一种有效的排序算法。 该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。
15. RANSAC 算法
    RANSAC 是”RANdom SAmple Consensus”的缩写。该算法是用于从一组观测数据中估计数学模型参数的迭代方法，由Fischler and Bolles在1981 提出，它是一种非确定性算法，因为它只能以一定的概率得到合理的结果，随着迭代次数的增加，这种概率是增加的。 该算法的基本假设是观测数据集中存在”inliers”（那些对模型参数估计起到支持作用的点）和”outliers”（不符合模型的点），并且这组观测 数据受到噪声影响。RANSAC 假设给定一组”inliers”数据就能够得到最优的符合这组点的模型。
16. RSA加密演算法
    这是一个公钥加密算法，也是世界上 第一个适合用来做签名的算法。今天的RSA已经专利失效，其被广泛地用于电子商务加密，大家都相信，只要密钥足够长，这个算法就会是安全的
17. 并查集Union-find
    并查集是一种树型的数据结 构，用于处理一些不相交集合（Disjoint Sets）的合并及查询问题。常常在使用中以森林来表示。
18. Viterbi algorithm
    寻找最可能的隐 藏状态序列(Finding most probable sequence of hidden states)

附录

• 关于这个世界上的算法，你可以看看Wikipedia的这个网页：http://en.wikipedia.org/wiki/List_of_algorithms
• 关于排序算法，你可以看看本站的这几篇文章《一个显示排序过程的Python脚本》、 《一个排 序算法比较的网站》

© 我想网 Akon 所有 , 2010. | 永久链接 | 没有评论 | 提交到 Google Reader 鲜果 抓虾

您可能会感兴趣的其他文章

• 递归－三角数字
• 用PHP数组对百万数据进行排重
• 浅谈递归过程以及递归的优化
• 检查素数的正则表达式
• 排序－选择
• 排序－插入
• 排序－冒泡
• 排序算法汇总
• 全文检索中近义词、关联词的解决方案
• 一个显示排序过程的Python脚本

Feed enhanced by Better Feed from Ozh

要使用这个正规则表达式，你需要把自然数转成多个1的字符串，如：2 要写成 “11”， 3 要写成 “111”, 17 要写成“11111111111111111”，这种工作使用一些脚本语言可以轻松的完成。

一开始我对这个表达式持怀疑态度，但仔细研究了一下这个表达式，发现是非常合理的，下面，让我带你来细细剖析一下是这个表达式的工作原理。

首先，我们看到这个表达式中有“|”，也就是说这个表达式可以分成两个部分：/^1?$/ 和 /^(11+?)\1+$/

• 第一部分：/^1?$/， 这个部分相信不用我多说了，其表示匹配“非空串”以及字串中不只一个“1”的字符串。
• 第二部分：/^(11+?)\1+$/，这个部分是整个表达式的关键部分。其可以分成两个部分，(11+?) 和\1+$，前半部很简单了，匹配以“11”开头的并重复0或n个1的字符串，后面的部分意思是把前半部分作为一个字串去匹配还剩下的字符串1次或多次（这句话的意思是——剩余的字串的1的个数要是前面字串1个数的整数倍）。

通过上面的分析，我们知道，第二部分是最重要的，对于第二部分，举几个例子，

示例一：判断自然数8。我们可以知道，8转成我们的格式就是“11111111”，对于(11+?)，其匹配了“11”，于是还剩下“111111”，而\1+$正好匹配了剩下的“111111”，因为，“11”这个模式在“111111”出现了三次，符合模式匹配，返回true。取反（^），所以，得到false，于是这个数不是质数。

示例二：判断自然数11。转成我们需要的格式是“11111111111”（十一个1），对于(11+?)，其匹配了“11”（前两个1），还剩下“111111111”（九个1），而\1+$无 法为“11”匹配那“九个1”，因为“11”这个模式并没有在“九个1”这个串中正好出现N次。于是，我们的正则表达式引擎会尝试下一种方法，先匹配 “111”（前三个1），然后把“111”作为模式去匹配剩下的“11111111”（八个1），很明显，那“八个1”并没有匹配“三个1”多次。所以， 引擎会继续向下尝试……直至返回false。

通过示例二，我们可以得到这样的等价数算算法，正则表达式会匹配这若干个1中有没有出现“二个1”的整数倍，“三个1”的整数倍，“四个1”的整数倍……，而，这正好是我们需要的算素数的算法。现在大家明白了吧。

下面，我们用perl来使用这个正规则表达式不停地输出素数：（关于perl的语法我就不多说了）

perl -e'$|++;(1 x$_)!~/^1?$|^(11+?)\1+$/&&print"$_ "while ++$_'

另外，让我们来举一反三，根据上述的这种方法，我们甚至可以用正则表达式来求证某方式是否有解，如：

• 二元方程：17x + 12y = 51   判断其是否有解的正则表达式是：^(.*)\1{16}(.*)\2{11}$
• 三元方程：11x + 2y + 5z = 115 判断其是否有解的正则表达式是：^(.*)\1{10}(.*)\2{1}(.*)\3{4}$

大家不妨自己做做练习，为什么上述的两个正则表达式可以判断方程是否有解。如果无法参透其中的奥妙的话，你可以读读这篇英文文章。

© 我想网 Akon 所有 , 2010. | 永久链接 | 没有评论 | 提交到 Google Reader 鲜果 抓虾

您可能会感兴趣的其他文章

• 高级正则表达式的重要概念
• 递归－三角数字
• 用PHP数组对百万数据进行排重
• 浅谈递归过程以及递归的优化
• 正则表达式入门
• 排序－选择
• 排序－插入
• 排序－冒泡
• 排序算法汇总
• 常用的正则表达式

Feed enhanced by Better Feed from Ozh

递归是实现程序计算过程中的描述过程 的基本模式之一，在讨论递归的问题前我们必须十分小心，因为递归包含两个方面的内容，一个是递归的计算过程，一个是递归过程，后者是语法上的事实而前者是 概念上的计算过程，事实上在程序上我们也许是使用循环来实现的。

一般在讨论递归的时候都喜欢用斐波那契数来作为例 子，我们也不要免俗。我们将斐波那契数的定义如下图来说明：

实现的代码：

def Fib(n):

if (n<1):

return 0

elif (n<3):

return 1

else:

return Fib(n-1)+Fib(n-2)

我们可以看出，这个算法几乎就是对上图定义的直译，我们假设 n=6，那么得到的计算过程就是，要计算Fib(6)就得计算Fib(5)和Fib(4)，以此类推，如下图：

我们可以看到过程如同一棵倒置的树，这 种方式被称之为树形递归，也被称之为线性递归。这种递归的方式非常的直白，很好理解其计算过程，一般很多人写递归都会下意识的采用这种方式。但是缺点也是 很明显的，从其计算过程可以看出，经过了很多冗余的计算，并且消耗了大量的调用堆栈，这个消耗是指数级增长的，经常有人说调用堆栈很容易在很短的递归过程 就耗光了，多半就是采用了线性递归造成的。线性递归的过程可用下图描述，可以清晰的看到展开收拢的过程：

除了这种递归方式还有 另外一种实现递归的方式，同样是上面的斐波那契数作为例子，这次我们不按照斐波那契的定义入手，我们从正常产生数列的过程入手来实现，0，1，的情况很简 单可以直接返回，之后的计算过程就是累加，我们在递归的过程中要保持状态，这个状态要保持三个数，也就是上两个数和迭代的步数，所以我们定义的方法为

def Fib(n,b1=1,b2=1,c=3):

if n<3:

return 1

else:

if n==c:

return b1+b2

else:

return Fib(n,b1=b2,b2=b1+b2,c=c+1)

这 种方法我们在每一次递归的过程中保持了上一次计算的状态，所以称之为“线性迭代过程”，也就是俗称的尾递归。由于每一步计算都保持了状态所以消除了冗余计 算，所以这种方式的效率明显高于前一种，其计算过程如下

fib(6)

fib 0,0,1

fib 0,1,2

fib 1,2,3

fib 2,3,4

fib 3,5,5

fib 5,8,6

这两种递归方式之间是可以转换的，凡是可以通过固定数量状态来描述中间计算过程的递归过程都可以通过线性迭代来表示。

我们可以发现，其实尾递归的过程和循环基本上是等价的，我们可以将尾递归的过程很方便到用循环来代替，所以很多的语言对尾递归提供了编译级别的优化，也就是 将尾递归在编译期转化成循环的代码。不过对于没有提供尾递归优化的语言来说也是很有意义的，比如python的默认调用堆栈长度是1000，如果用线性递 归很快就会消耗光，但是尾递归就不会，比如尾递归的Fib函数，用Fib(1001)调用没问题的而且跑得飞快，Fib(1002)的时候才堆栈溢出。但 是如果是线性递归的方式计算n=30的时候就能明显感觉到速度变慢，40以上基本就挂了。

这里我无意对比两种方式的优劣，也许线性递归性能 有差距但是它的可读性非常的强，几乎就等同于公式的直接描述，所以可以根据计算规模来合理选用。

© 我想网 Akon 所有 , 2010. | 永久链接 | 没有评论 | 提交到 Google Reader 鲜果 抓虾

您可能会感兴趣的其他文章

• 递归－三角数字
• 用PHP数组对百万数据进行排重
• 检查素数的正则表达式
• 排序－选择
• 排序－插入
• 排序－冒泡
• 排序算法汇总
• 全文检索中近义词、关联词的解决方案
• 一些重要的算法
• 一个显示排序过程的Python脚本

Feed enhanced by Better Feed from Ozh

下图是“冒泡排序”的一个示例，其中：

1. 折线表示了各个元素的位置变化。
2. 折线的深浅表示了元素的大小。越深则越大。

同样，还有其它一些排序算法的图片：

堆排序（Heap Sort）

选择排序（Selection）

快速排序（Quick）

Shell排序

插入排序（Insertion）

你可以使用如下的Python代码来制作这些图片：（需要 Cairo图片库支持）

Python 排序脚本

这个脚本参数如下：

• -a 表示使用什么样的算法，取值为"quick", "heap", "selection", "insertion", "bubble", "shell"。
• -n 表示要排序的数据个数。
• -f 表示输入文件。
• -p 表示文件前缀。
• -d 表示输出顺序。
• -x 图片宽度。
• -y 图片高度。
• -l 所有线的宽度。
• -b 边界宽度。

使用示例如下：

./visualise.py -l 6 -x 700 -y 300 -n 15

© 我想网 Akon 所有 , 2010. | 永久链接 | 没有评论 | 提交到 Google Reader 鲜果 抓虾

您可能会感兴趣的其他文章

• 递归－三角数字
• 用PHP数组对百万数据进行排重
• 浅谈递归过程以及递归的优化
• 检查素数的正则表达式
• 排序－选择
• 排序－插入
• 排序－冒泡
• 排序算法汇总
• 国外PHP开发者放弃PHP而改用Python
• 全文检索中近义词、关联词的解决方案

Feed enhanced by Better Feed from Ozh

Sorting Algorithm Animations
http://www.sorting-algorithms.com/

这是一个非常不错的排序算法的网站，当你打开这个网站的时候，请不要因为看到很多个图片的大红叉而鄙视它。你先点击网页上方的 Problem Size，选择一个尺寸，20，30，40还是50，都行，于是你就可以看到下面整个大表中有图片显示出来了。如下所示：

其中，

• 列。是代表每一个排序算法，有“插入”“选择”“冒泡”“Shell”，“合并Merge”，“堆排 序”，“快速排序”，“快速3排序”。单击每个一算法的链接，你可以看到这个算法的详细解释，其中包括，算法的伪代码，算法的复杂度，相关的讨论，重点， 以及该算法的相关参考文档。
• 行。是不同的数据样本，第一个是“随机样本”，第二个是“几乎排好序的样本”，第三个是 “最差的样本（反序）”，第四个是“有一些相同项的样本”。这些样本在不同的算法上都会有不同的表现。
• 单元格。每个单元格都是一个图片。简单的用鼠标单击一下每个图片，可以动画地演示算法整个 过程。其中两个小红箭头表示了正在需要“交换顺序的数据”。

这个网站，还是做得很8错的。希望大家喜欢。

© 我想网 Akon 所有 , 2010. | 永久链接 | 没有评论 | 提交到 Google Reader 鲜果 抓虾

您可能会感兴趣的其他文章

• 递归－三角数字
• 用PHP数组对百万数据进行排重
• 浅谈递归过程以及递归的优化
• 检查素数的正则表达式
• 排序－选择
• 排序－插入
• 排序－冒泡
• 排序算法汇总
• 全文检索中近义词、关联词的解决方案
• 一些重要的算法

Feed enhanced by Better Feed from Ozh

假如得到一个uid列表，数量在百万行以上，格式如下：

10001000
10001001
10001002
......
10001000
......
10001111

其实利用php数组的特性，很好进行排重，我们先来看一下php数组的定义：PHP 中的数组实际上是一个有序映射。映射是一种把 values 关联到 keys 的类型。此类型在很多方面做了优化，因此可以把它当成真正的数组，或列表（向量），散列表（是映射的一种实现），字典，集合，栈，队列以及更多可能性。数组元素的值也可以是另一个数组。树形结构和多维数组也是允许的。

在php的数组中，键（keys）也称为索引，具有唯一性，我们正可以利用这一特性进行排重，示例代码如下：

<?php
//定义一个数组，用于存放排重后的结果
$result = array();
//读取uid列表文件
$fp = fopen('test.txt', 'r');

while(!feof($fp))
{
    $uid = fgets($fp);
    $uid = trim($uid);
    $uid = trim($uid, "\r");
    $uid = trim($uid, "\n");

    if($uid == '')
    {
        continue;
    }
    //以uid为key去看该值是否存在
    if(empty($result[$uid]))
    {
        $result[$uid] = 1;
    }
}

fclose($fp);

//将结果保存到文件
$content = '';
foreach($result as $k => $v)
{
    $content .= $k."\n";
}
$fp = fopen('result.txt', 'w');
fwrite($fp, $content);
fclose($fp);
?>

20多行代码，就可以对百万以上的数据进行排重，效率也不错，非常实用。手机号、email，也可以采用这种方式进行排重。

还有，这可方法还可以用于两个文件进行排重的工作，如果你有两个uid列表文件，格式和上面的uid列表一样，示例程序如下：

<?php
//定义数组，用于存放排重后的结果
$result = array();
//读取第一个uid列表文件，放入$result_1
$fp = fopen('test_1.txt', 'r');

while(!feof($fp))
{
    $uid = fgets($fp);
    $uid = trim($uid);
    $uid = trim($uid, "\r");
    $uid = trim($uid, "\n");

    if($uid == '')
    {
        continue;
    }
    //以uid为key写入$result，如有重复就会覆盖
    $result[$uid] = 1;
}

fclose($fp);

//读取第二个uid列表文件，并进行排重操作
$fp = fopen('test_2.txt', 'r');
while(!feof($fp))
{
    $uid = fgets($fp);
    $uid = trim($uid);
    $uid = trim($uid, "\r");
    $uid = trim($uid, "\n");

    if($uid == '')
    {
        continue;
    }
    //以uid为key去看该值是否存在
    if(empty($result[$uid]))
    {
        $result[$uid] = 1;
    }
}
fclose($fp);

//$result里保存的就排重以后的结果，可以输出到文件，代码省略
?>

仔细想想，不难发现，利用数组的这一特性还可以解决我们工作中的更多问题。

© 我想网 Akon 所有 , 2010. | 永久链接 | 没有评论 | 提交到 Google Reader 鲜果 抓虾

您可能会感兴趣的其他文章

• 递归－三角数字
• 设计模式之单例模式
• 论述PHP开发框架: What, When, Why and Which?
• 腾讯PHP程序员面试题目
• 简易Wordpress模板代码帮助手册中文版
• 用 PHP 读取和编写 XML DOM
• 深入理解PHP之匿名函数
• 浅谈递归过程以及递归的优化
• 检查素数的正则表达式
• 最快的 PHP 模板引擎 Blitz Templates

Feed enhanced by Better Feed from Ozh

首先我们要定义用户的活动消息，也可以理解为一个事件，就是我们举的例子：用户上传照片、与别人结为好友、修改了个人资料等等，动作各有不同，但需 要在结构上通用，我们先设计一个

ID //消息ID
UserID //用户ID
MsgType //消息类型，比如加好友、上传照片等不同的类型
EventMsg //消息的内容，这里我们可以用Json的数据格式来描述出不同的活动内容
CreateTime //消息创建时间

这个结构也是个数据库的结构，当用户做个一个动作之后，就会创建这样一个消息，并保存在数据库中，当显示好友的活动信息时，就从这张表里查询自己好 友id的数据，并按时间显示，这个做法是一个最简单的实现，但会出现一些问题，当你与一个用户成为好友之后，该好友之前发生的动作会显示出来，而不是在成 为好友时点之后的动作，同样，切断好友关系之后也有类似的问题，如果从业务角度和用户体验上可以接受的话，也没什么，但由于信息是按时间排序，有时候会给 用户错乱的感觉，还有，这个信息不能删除，如果删除了所有好友就看不到这条信息了，但在Facebook里是则是可以删除好友的动作信息的，这个方法还有 一个问题是，所有信息都放在一张大表里，在信息爆炸增长，个人好友也很多的情况下，查询效率会非常低，产生严重的性能障碍，如果对这张表做水平切分，则在 实现上复杂了许多，性能也未必好很多，接下来我们再思考是否有更好的解决办法。

在SNS的理论里，个人好友的合理数量在150个左右（最近有文章说Facebook的人均好友数是120人），SNS网站应该是有好友数量的限制的，我们就按人均 150个好友来设想，是否可以在用户发生某些动作之后，针对他的所有好友都写入一条信息，所能解决的是，信息是在用户成为好友时点之后写入，用户可以删除 好友的活动信息，不影响其他用户的显示，在显示时查询效率要高很多，但是负面效应也十分明显，一个用户的动作有平均150个写入，对于数据库来说开销也非 常大，我们想想在这样的设计下，是否可以提高性能。

首先看数据库设计，我们要把信息表和信息与用户的对应表分开，我们上面定义的数据结构保留，我们定义它的表名为Event，我们再新建一张表 EventUser，结构如下

ID  //主键
EventID //Event表的ID
FriendUserID //好友的ID
CreateTime //消息创建时间

对FriendUserID做索引，当用户发生动作时，首先将动作信息写入Event表，之后查找用户的所有好友，将EventID、好友ID逐条 写入EventUser表，当要显示自己的好友活动信息是，查询EventUser中FriendUserID等于自己ID的信息，并和Event表做一 个Join查询就可以了。

进一步提升性能的方法，将Event里的信息缓存，比如用Memcached，EventID做为Key，内容做为Value，这样，查询 EventUser是就不用Join Event表，而是从缓存里读取，由于要记录给每个好友的信息，所以EventUser会变得非常大，平均要比我们最初设计的数据容量大150倍，我们对 EventUser表做水平切分，根据用户ID做Hash算法，基本上能均匀的分配到所有的表中，至于EventUser水平切分的算法还有多种，根据实 际情况来定，总的来说就是把数据分摊掉，同时EventUser里的数据可以不永久保存，做定期删除，可以保持数据容量在一个合理的范围内。

对于用户动作之后的数据写入，可以采用异步的方法，在发生动作时，抛出一个消息，由另外一个线程在做写入操作，如果对每个动作平均150次的写入仍 存顾虑，我们可以针对每个用户开出一块内存空间，或是缓存，里面保存最后50条最新的好友动作，并在每条记录里做一个持久化标志，当有50条信息都标志是 “未持久化”时，做一次数据库的写入，然后把信息置为“已持久化”，这种非实时写入的方式，可以提高一定的数据库效率，显示时，先从内存中取出，再查数据 库。

还有一些问题，对不不同消息类型的处理方式不同，比如用户修改个人资料，并不是每次发生这样的动作都要做一次给朋友做一次“群发”的操作，如果遇到 这个人在短时间内做了多次修改个人资料的操作，就给朋友发出多个消息，会产生垃圾信息，让人觉得很怪异，所以对于这样的操作会有一定的时效性，比如在一天 之内的修改个人资料，就是一个消息，这时候的处理是更新，而不是插入。

以上是我对SNS中好友动态功能的设计思路，可能还有一些未想到的问题，还需要认真思考。

© 我想网 Akon 所有 , 2010. | 永久链接 | 没有评论 | 提交到 Google Reader 鲜果 抓虾

您可能会感兴趣的其他文章

• 集大成者的两款Adobe AIR平台上的社交网络
• 让网站“社会化”的5点建议(SNS)
• 美刊总结SNS网络6大规则：要有一定程度的不透明
• 社区产品的三个关键点
• 社交网络时代的营销
• 社交网站的设计
• 社交媒体(SNS)对搜索引擎优化的6大好处
• 目前微博同步的最佳解决方案
• 深色调社交图标：免费且高质量的社交媒体图标集
• 机会或陷阱,国内SNS网站全面总结

Feed enhanced by Better Feed from Ozh

create table  KEYS(
   ITEM_ID varcha2(50) not null,
   SEARCH_KEY varchar2(100),
);

String key = request.getParameter("inputValue");
String sql = "select * from KEYS as k where k.SEARCH_KEY like '%key%'";

    	InputStream fi = this.getClass().getClassLoader().getResourceAsStream("mydictionary.dic");
    	File indexDir = new File("d:\\tong");
    	Analyzer luceneAnalyzer = new StandardAnalyzer();
        	IndexWriter indexWriter = new IndexWriter(indexDir, luceneAnalyzer,true);
	BufferedReader reader = new BufferedReader(new InputStreamReader(fi, "UTF-8"));
	String line = new String();
	while ((line = reader.readLine()) != null)
	{
		Document document = new Document();
		Field FieldName = new Field("line", line,Field.Store.YES, Field.Index.TOKENIZED);
		document.add(FieldName);
		indexWriter.addDocument(document);
	}
	indexWriter.optimize();
        	indexWriter.close();
	reader.close();

	public List getTongYi(String searchword) throws Exception
	{
		List list = new ArrayList();
		Hits hits = null;
		String queryString = searchword;
		Query query = null;
		String result = "";
		IndexSearcher searcher = new IndexSearcher("d:\\tong");
		Analyzer analyzer = new StandardAnalyzer();
		QueryParser qp = new QueryParser("line", analyzer);
		query = qp.parse(queryString);
		if (searcher != null)
		{
		    hits = searcher.search(query);
		    for(int i=0;i<hits.length();i++)
		    {
		    	Document doc = hits.doc(i);
		    	System.out.println((i+1)+"."+doc.get("line"));
		    	result = doc.get("line");
		    }
		}
		if(result!=null && !result.equals(""))
		{
			String [] manyresult = result.split(" ");
			for(int i=0;i<manyresult.length;i++)
			{
				if(manyresult[i]!=null && !manyresult[i].trim().equals(""))
				{
					list.add(manyresult[i]);
				}
			}
		}
		return list;
	}

© 我想网 Akon 所有 , 2009. | 永久链接 | 没有评论 | 提交到 Google Reader 鲜果 抓虾

您可能会感兴趣的其他文章

• 用PHP数组对百万数据进行排重
• 浅谈递归过程以及递归的优化
• 检查素数的正则表达式
• 排序－选择
• 排序－插入
• 排序－冒泡
• 排序算法汇总
• 全文检索中近义词、关联词的解决方案
• 一些重要的算法
• 一个显示排序过程的Python脚本

Feed enhanced by Better Feed from Ozh

代码如下，程序简单，没有提供注释。

class Select {
public static void main(String[] args) {
int[] a = {2,4,6,3,6,2,6,4,9};
sort(a);
print(a);
}

private static void sort(int[] a) {
int temp;
for(int i=0; i<a.length-1; i++) {
int min = i;
for(int j=i+1; j<a.length; j++) {
if(a[j] < a[min]) min = j;
}
if(min != i) {
temp = a[min];
a[min] = a[i];
a[i] = temp;
}
}
}

private static void print(int[] a) {
for(int i: a) System.out.print(i + ” “);
System.out.println();
}
}

© 我想网 Akon 所有 , 2009. | 永久链接 | 没有评论 | 提交到 Google Reader 鲜果 抓虾

您可能会感兴趣的其他文章

• 递归－三角数字
• 用PHP数组对百万数据进行排重
• 浅谈递归过程以及递归的优化
• 检查素数的正则表达式
• 排序－插入
• 排序－冒泡
• 排序算法汇总
• 全文检索中近义词、关联词的解决方案
• 一些重要的算法
• 一个显示排序过程的Python脚本

Feed enhanced by Better Feed from Ozh

编程中为了简便，采用了递归算法，运算时会带来额外的开销，如果能将相应的算法替换为迭代，则更为有效。删除的算法相应复杂一些，但也可以承受。

API
add：将数加入树
remove：从树中删除指定的节点
contains：树中是否包含指定的数
ordinal：从小到大遍历打印数（测试只用）
max：查找最大值
min：查找最小值
其中Node类是辅助类，为了简单没有写标准的 get，set方法。

因为该树没有自我保持平衡的能力，因此对于随机插入的数据，效果较好，对于有局部生降序特征的插入序列，则会失去平衡，极端状况下，树退化成链表。关于平衡树请参见（Tree2-3-4 ，红黑树 ,Tree-2-3 )
Tree的main函数仅为测试之用。

class Node {

private int value;

private Node left;

private Node right;

Node(int value) {

this.value = value;

}

int value() {

return value;

}

void left(Node left) {

this.left = left;

}

void right(Node right) {

this.right = right;

}

Node left() {

return left;

}

Node right() {

return right;

}

}

class Tree {

private Node root;

void add(int value) {

Node node = new Node(value);

if(root == null) root = node;

else add(root,node);

}

private void add(Node current, Node node) {

if(node.value() < current.value()) {

if(current.left() == null) current.left(node);

else add(current.left(), node);

} else if(node.value() > current.value()) {

if(current.right() == null) current.right(node);

else add(current.right(), node);

}

}

boolean contains(int value) {

if(root == null) return false;

else return contains(root,value);

}

private boolean contains(Node current, int value) {

if(current == null) return false;

if(current.value() == value) return true;

if(value < current.value()) return contains(current.left(),value);

else return contains(current.right(),value);

}

void remove(int value) {

remove(null,root,value);

}

private void remove(Node parent, Node current, int value) {

if(current == null) return;

if(current.value() == value) {

Node node;

if(current.left() == null && current.right() ==  null) node = null;

else if (current.left() != null && current.right() == null) node = current.left();

else if (current.right() != null && current.left() == null) node = current.right();

else {

node = removeMin(current,current.right());

node.left(current.left());

node.right(current.right());

}

if(parent == null) root = node;

else if(parent.left() == current) parent.left(node);

else parent.right(node);

} else if(value < current.value()) remove(current,current.left(),value);

else remove(current,current.right(),value);

}

private Node removeMin(Node parent, Node current) {

if(current.left() != null) return removeMin(current,current.left());

else {

if(parent.left() == current) parent.left(current.right());

else parent.right(current.right());

return current;

}

}

int max() {

if(root == null) return -1;

else return max(root);

}

private int max(Node current) {

if(current.right() == null) return current.value();

else return max(current.right());

}

int min() {

if(root == null) return -1;

else return min(root);

}

private int min(Node current) {

if(current.left() == null) return current.value();

else return min(current.left());

}

void ordinal() {

if (root == null) return;

else ordinal(root);

}

void ordinal(Node current) {

if(current.left() != null) ordinal(current.left());

System.out.println(current.value() + ” “);

if(current.right() != null) ordinal(current.right());

}

public static void main(String[] args) {

Tree t = new Tree();

t.add(50);

t.add(6);

t.add(29);

t.add(100);

t.add(34);

t.add(45);

t.add(4);

t.add(68);

t.ordinal();

System.out.println(t.contains(34));

assert t.contains(34);

assert t.contains(6);

assert !t.contains(110);

assert t.max() == 100;

assert t.min() == 4;

t.remove(50);

t.remove(45);

t.remove(6);

t.ordinal();

}

}

© 我想网 Akon 所有 , 2009. | 永久链接 | 没有评论 | 提交到 Google Reader 鲜果 抓虾

您可能会感兴趣的其他文章

• 递归－三角数字
• 用PHP数组对百万数据进行排重
• 浅谈递归过程以及递归的优化
• 检查素数的正则表达式
• 排序－选择
• 排序－插入
• 排序－冒泡
• 排序算法汇总
• 全文检索中近义词、关联词的解决方案
• 一些重要的算法

Feed enhanced by Better Feed from Ozh