首页 > 代码库 > 【编程珠玑-15章】Strings of pearls
【编程珠玑-15章】Strings of pearls
15.1 Words
问题：为文档中包含的单词生成一个列表？
可行的办法是自己建立一个散列表，写一个简单的数据结构来记录单词和单词出现的次数。
1） 散列函数的建立
书中给出的源代码提供了一个字符串散列函数。其实很像经典的BKDR算法。C语言描述如下：
unsigned int hash(char *p)
{ unsigned int h = 0;
for ( ; *p; p++)
h = MULT * h + *p;
return h % NHASH;
}
我用java实现BKDRHash（参考：http://java.chinaitlab.com/advance/868618.html）：
/*
* BKDRHash(String array)的主要思想：种子乘以字符串中每一个字符的大小，总的和即hash，然后取到正整数范围。
* 0X7FFFFFFF即Integer.MAX_VALUE,hash&0X7FFFFFFF将符号位置为0，其余各位不变。
* seed可以是31 131 1313 13131 131313 etc..
*/
public static int BKDRHash(String array) {
int seed = 31;
int hash = 0;
for (int i = 0; i < array.length(); i++) {
hash = hash * seed + array.charAt(i);
}
return (hash & 0X7FFFFFFF);
}
*******************************************************************
实现这里的hash
private static final int NHASH=29989,MULT=31;
/*散列到0~NHASH=29989范围内*/
public static int hash(String array) {
int hash=0;
for (int i = 0; i < array.length(); i++) {
hash=MULT*hash+array.charAt(i);
}
return (hash&0x7FFFFFFF)%NHASH;
}
2） 完整代码
书中给出的C语言源代码如下：
/* Copyright (C) 1999 Lucent Technologies */
/* From 'Programming Pearls' by Jon Bentley */
/* wordfreq.c -- list of words in file, with counts */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct node *nodeptr;
typedef struct node {
char *word;
int count;
nodeptr next;
} node;
#define NHASH 29989
#define MULT 31
nodeptr bin[NHASH];
unsigned int hash(char *p)
{ unsigned int h = 0;
for ( ; *p; p++)
h = MULT * h + *p;
return h % NHASH;
}
#define NODEGROUP 1000
int nodesleft = 0;
nodeptr freenode;
nodeptr nmalloc()
{ if (nodesleft == 0) {
freenode = malloc(NODEGROUP*sizeof(node));
nodesleft = NODEGROUP;
}
nodesleft--;
return freenode++;
}
#define CHARGROUP 10000
int charsleft = 0;
char *freechar;
char *smalloc(int n)
{ if (charsleft < n) {
freechar = malloc(n+CHARGROUP);
charsleft = n+CHARGROUP;
}
charsleft -= n;
freechar += n;
return freechar - n;
}
void incword(char *s)
{ nodeptr p;
int h = hash(s);
for (p = bin[h]; p != NULL; p = p->next)
if (strcmp(s, p->word) == 0) {
(p->count)++;
return;
}
p = nmalloc();
p->count = 1;
p->word = smalloc(strlen(s)+1);
strcpy(p->word, s);
p->next = bin[h];
bin[h] = p;
}
int main()
{ int i;
nodeptr p;
char buf[100];
for (i = 0; i < NHASH; i++)
bin[i] = NULL;
while (scanf("%s", buf) != EOF)
incword(buf);
for (i = 0; i < NHASH; i++)
for (p = bin[i]; p != NULL; p = p->next)
printf("%s %d\n", p->word, p->count);
return 0;
}
***************************************************************************
下面是我用Java实现的：
/**
* 创建时间：2014年9月1日 下午9:31:13 项目名称：Test
*
* @author Cao Yanfeng
* @since JDK 1.6.0_21 类说明：建立字符串散列函数，以链表的方式解决冲突，统计字符串的出现频次
*/
public class WordsFrequency {
private static final int NHASH = 29989, MULT = 31;
private static Node[] bin;
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
// System.out.println(hash("CAOYANFENGhfOWRFRAEOWGNEARFGAT"));
bin = new Node[NHASH];
String[] array = { "CaoYanfeng", "agaef", "北京大学", "CaoYanfeng",
"China", "agaef", "CaoYanfeng", "agaef", "China", "agaef",
"agaef", "曹艳丰", "CaoYanfeng", "曹艳丰", "北京大学", "CaoYanfeng",
"China" };
for (int i = 0; i < array.length; i++) {
incword(array[i]);
}
for (int i = 0; i < bin.length; i++) {
for (Node node = bin[i]; node != null; node = node.getNext()) {
System.out.println("单词：" + node.getWordString() + "——数量："
+ node.getCount());
}
}
}
/* 以链表的方式解决hashTable的冲突 */
public static void incword(String string) {
int h = hash(string);
Node node;
for (node = bin[h]; node != null; node = node.getNext()) {
if (string.equals(node.getWordString())) {
node.setCount(node.getCount() + 1);
return;
}
}
node = new Node();
node.setWordString(string);
node.setCount(1);
node.setNext(bin[h]);
bin[h] = node;
}
/* 采用类似于BKDRHash(String array)的方式将字符串散列到0~NHASH=29989范围内 */
public static int hash(String string) {
int hash = 0;
for (int i = 0; i < string.length(); i++) {
hash = MULT * hash + string.charAt(i);
}
return (hash & 0x7FFFFFFF) % NHASH;
}
/* 数组的节点类 */
private static class Node {
private String wordString;
private int count;
private Node next;
/**
*
*/
public Node() {
// TODO Auto-generated constructor stub
wordString = null;
count = 0;
next = null;
}
public String getWordString() {
return wordString;
}
public void setWordString(String wordString) {
this.wordString = wordString;
}
public int getCount() {
return count;
}
public void setCount(int count) {
this.count = count;
}
public Node getNext() {
return next;
}
public void setNext(Node next) {
this.next = next;
}
}
}
15.2 Phrases
问题：给定一个文本文件作为输入，查找其中最长的重复子字符串。
这里用的是后缀数组。如下目标字符串： banana其长度为6，则后缀数组的长度为6，分别是以b开头的字串（长度为6），以a开头的字串（长度为5），以n开头的字串（长度为4）。。。最后一个是以a开头的字串（长度为1）。
后缀[0] banana
后缀[1] anana
后缀[2] nana
后缀[3] ana
后缀[4] na
后缀[5] a
所以，算法的流程是，先求出字符串的后缀数组，将后缀数组字母排序，然后顺次比较（避免了两两比较）即可。
后缀[0] a
后缀[1] ana
后缀[2] anana
后缀[3] banana
后缀[4] na
后缀[5] nana
最终的比较结果是 后缀[1] 和 后缀[2] 之间存在最长公共字串 ana。
时间复杂度分析：生成后缀数组 O(n)，排序 O(nlogn*n)，最后面的n是因为字符串比较的时候也是一个一个字符进行比较，所以是O(n)。依次检测相邻的两个字符串 O(n * n)，总的时间复杂度是 O(n^2*logn)，优于暴力方法的 O(n^3)。可以看出，复杂度跟排序相关度大，可以使用倍增算法高效的（nlogn）产生排好序的后缀数组，从而提高复杂度。
书中给出的C语言源代码如下：
/* Copyright (C) 1999 Lucent Technologies */
/* From 'Programming Pearls' by Jon Bentley */
/* longdup.c -- Print longest string duplicated M times */
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
int pstrcmp(char **p, char **q)
{ return strcmp(*p, *q); }
int comlen(char *p, char *q)
{ int i = 0;
while (*p && (*p++ == *q++))
i++;
return i;
}
#define M 1
#define MAXN 5000000
char c[MAXN], *a[MAXN];
int main()
{ int i, ch, n = 0, maxi, maxlen = -1;
while ((ch = getchar()) != EOF) {
a[n] = &c[n];
c[n++] = ch;
}
c[n] = 0;
qsort(a, n, sizeof(char *), pstrcmp);
for (i = 0; i < n-M; i++)
if (comlen(a[i], a[i+M]) > maxlen) {
maxlen = comlen(a[i], a[i+M]);
maxi = i;
}
printf("%.*s\n", maxlen, a[maxi]);
return 0;
}
*****************************************************************************
我用java实现如下：
/**
* 创建时间：2014年9月2日 上午10:05:11
* 项目名称：Test
* @author Cao Yanfeng
* @since JDK 1.6.0_21
* 类说明： 利用后缀数组来查找字符串中最长的重复子串
*/
public class MaxLongDup {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
getMaxLongDup("banana");
}
/*这里利用了两个系统函数，Arrays.sort()和string.substring(i)
* */
public static void getMaxLongDup(String string) {
int length=string.length();
int maxlen=Integer.MIN_VALUE;
int position=-1;
String[] suffix=new String[length];
for (int i = 0; i < suffix.length; i++) {
// suffix[i]=string.substring(i);
suffix[i]=new String(string.substring(i));
}
Arrays.sort(suffix);
for (int i = 0; i < suffix.length-1; i++) {
int comlen=commonLength(suffix[i], suffix[i+1]);
// maxlen=(comlen>maxlen)?comlen:maxlen;
if (comlen>maxlen) {
maxlen=comlen;
position=i;
}
}
System.out.println("最大重复子串："+suffix[position]+";长度为:"+maxlen);
}
/*获得相邻的两个字符串的公共长度*/
public static int commonLength(String string1,String string2) {
int counter=0;
char[] arry1=string1.toCharArray();
int i=0;
char[] array2=string2.toCharArray();
int j=0;
while (i<arry1.length&&j<array2.length) {
if (arry1[i++]==array2[j++]) {
counter++;
}else {
break;
}
}
return counter;
}
}
**************************************************************************
注意，我这里在获得后缀数组的时候使用了两个系统函数：
1） Arrays.sort()。Arrays.sort()对于基本数据类型使用快速排序，而对象的话是堆排序，这里是堆排序；
2） substring(intindex)。根据以下参考文献的说法，substring并没有生成新的String对象，而是引用了原来String对象的位置索引而已。（参考：http://www.cnblogs.com/tedzhao/archive/2012/07/31/Java_String_substring.html）。所以我使用的是后者而不是前者。
// suffix[i]=string.substring(i);
suffix[i]=new String(string.substring(i));
【编程珠玑-15章】Strings of pearls
声明：以上内容来自用户投稿及互联网公开渠道收集整理发布，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任，若内容有误或涉及侵权可进行投诉： 投诉/举报 工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。