4 串与数组
4.1 串
字符串（串），是由n（>=0）个字符组成的优先序列。从逻辑结构来看，串也是一种特殊的线性表，即串可以看成是每个数据元素仅有一个字符组成的线性表。长度n为0的串称为空串，即空串不包含任何字符。包含一个及以上空白字符串的串称为空白串。需要说明的是，空串和空白串的区别。空串不包含任何字符，长度为0；空白串是由一个或多个字符所组成的字符串，其长度是空白字符的个数。
4.1.1 串的抽象数据类型描述
package adt;
public interface IString {
/**
* 将一个已经存在的串置为空串
*/
public void clear();
/**
* 判断当前串是否为空。
*/
public boolean isEmpty();
/**
* 返回串中的字符个数
*/
public int length();
/**
* 读取并返回串中的第index个字符值。其中，0<=index<=length()-1。
*/
public char charAt(int index);
/**
* 返回值为当前串中从序号begin开始，到序号end-1为止的子串。其中，0<=begin<=length()-1，1<=end<=length()
* 。
*/
public IString substring(int begin, int end);
/**
* 在当前串的第offset个字符之前插入串str。其中，0<=offset<=length()。
*/
public IString insert(int offset, IString str);
/**
* 删除当前串中从序号begin开始到序号end-1为止的子串。其中0<=begin<=length()-1;1<=end<=length()。
*/
public IString delete(int begin, int end);
/**
* 把str串连接到当前串的后面
*/
public IString concat(IString str);
/**
* 将当前串与目标串str进行比较，若当前串大于str，则返回一个正整数； 若当前串等于str，则返回0；若当前串小于str，则返回一个负整数
*/
public int compareTo(IString str);
/**
* 在当前串中从begin位置开始搜索与str相等的子串，所搜索成功，则返回str在当前串中的位置；否则返回-1。
*/
public int indexOf(IString str, int begin);
}
4.1.2 顺序串类的定义
串的顺序存储结构与线性表的顺序存储结构类似，可以采用一组地址连续的存储单元来存储串字符序列。
package sequeue;
import adt.IString;
public class SeqString implements IString {
private char[] strvalue;// 字符数组，存放串值
private int curlen;// 当前串的长度
// 构造方法1,构造一个空串
public SeqString() {
strvalue = new char[0];
curlen = 0;
}
// 构造方法2，以字符串常量构造字符串对象
public SeqString(String str) {
char[] tempchararray = str.toCharArray();
strvalue = tempchararray;
curlen = tempchararray.length;
}
// 构造方法3,以字符数组构造串对象
public SeqString(char[] value) {
strvalue = new char[value.length];
for (int i = 0; i < value.length; i++) {// 复制数组
strvalue[i] = value[i];
}
curlen = value.length;
}
@Override
public void clear() {
this.curlen = 0;
}
@Override
public boolean isEmpty() {
return curlen == 0;
}
@Override
public int length() {
return curlen;
}
@Override
public char charAt(int index) {
if ((index < 0) || (index >= curlen)) {
throw new StringIndexOutOfBoundsException(index);
}
return strvalue[index];
}
// 扩充字符串存储空间容量，参数指定容量
public void allocate(int newCapacity) {
char[] temp = strvalue;
strvalue = new char[newCapacity];// 复制数组
for (int i = 0; i < curlen; i++) {
strvalue[i] = temp[i];
}
}
@Override
// 返回串中序号从begin至end-1的子串
public IString substring(int begin, int end) {
return null;
}
@Override
// 在当前串的第offset个字符之前插入串str
public IString insert(int offset, IString str) {
return null;
}
@Override
// 删除当前串中从序号begin开始到序号end-1为止的子串
public IString delete(int begin, int end) {
return null;
}
@Override
// 添加指定串str到当前串尾
public IString concat(IString str) {
return null;
}
@Override
// 将当前串与目标串str进行比较
public int compareTo(IString str) {
return 0;
}
@Override
// 子串定位
public int indexOf(IString str, int begin) {
return 0;
}
}
4.1.3 串的基本操作实现
1. 求子串操作
求子串操作的功能是，返回当前串中序号从begin至end-1的子串。begin的范围是0<=begin<=length()-1；end的范围是1<=end<=length()。思路：
1）检查begin和end参数的合法性
2）若要截取整个串，则返回原串；否则截取从begin至end-1之间的子串
// 返回串中序号从begin至end-1的子串
public IString substring(int begin, int end) {
if (begin < 0) {
throw new StringIndexOutOfBoundsException("起始位置不能小于0");
}
if (end > curlen) {
throw new StringIndexOutOfBoundsException("结束位置不能大于串的当前长度");
}
if (begin > end) {
throw new StringIndexOutOfBoundsException("开始位置不能大于结束位置");
}
if (begin == 0 && end == curlen) {
return this;
} else {
char[] buffer = new char[end - begin];
for (int i = 0; i < buffer.length; i++) {
buffer[i] = this.strvalue[i + begin];
}
return new SeqString(buffer);
}
}2. 串的插入操作
串的插入操作是指，在当前串中第offset个字符之前插入串str，并返回结果串对象。其中，参数offset的有效范围是0<=offset<=length()。思路：
1）检查插入位置的合法范围。
2）若插入时存储空间不足，则调用allocate(newCount)，重新分配存储空间。
3）将strvalue中从offset开始的字符向后移动len个位置（len为待插入串str的长度）。
4）将str串插入到strvalue中从offset开始的位置。
5）改变串的长度
public IString insert(int offset, IString str) {
if ((offset < 0) || (offset > curlen)) {
throw new StringIndexOutOfBoundsException("插入位置不合法");
}
int len = str.length();
int newCount = curlen + len;
if (newCount > strvalue.length) {
allocate(newCount);// 插入存储空间不足，需扩充容量
}
for (int i = curlen - 1; i >= offset; i++) {
strvalue[len + i] = strvalue[i];// 从offset开始向后移动len个字符
}
for (int i = 0; i < len; i++) {
strvalue[offset + i] = str.charAt(i);// 复制串str
}
this.curlen = newCount;//改变串长度
return this;
}3. 串的删除操作
串的删除操作是指在当前串中删除从start到end-1之间的子串，并返回当前串对象。参数start和end的取值范围分别是0<=begin<=length()-1和1<=end<=length()。思路：
1）检查参数的合法性
2）将strvalue中从end开始到尾串的子串向前移动到从begin开始的位置。
3）当前串长度减去end-begin。
public IString delete(int begin, int end) {
if (begin < 0) {
throw new StringIndexOutOfBoundsException("起始位置不能小于0");
}
if (end > curlen) {
throw new StringIndexOutOfBoundsException("结束位置不能大于串的当前长度");
}
if (begin > end) {
throw new StringIndexOutOfBoundsException("开始位置不能大于结束位置");
}
for (int i = 0; i < end - begin; i++) {
strvalue[begin + i] = strvalue[end + i];// 从end开始至串尾的子串向前移动到从begin开始的位置
}
curlen = curlen - (end - begin);// 当前串的长度将去(end-begin)
return this;
}4. 串的比较操作
串的比较操作是将当前串与参数str指定的串进行比较，若当前串的值大于str的串的值，则返回一个正整数； 若当前串的值等于str的串值，则返回0；若当前串的值小于str的串值，则返回一个负整数。思路：
1）求出当前串与待比较串的长度，并把较小值赋值到n
2）从下标0到n-1依次取出两个串中对应的字符进行比较，若不等，则返回 第一个不相等的字符的数值差
3）若下标从0到n-1对应的字符均相等，则返回两个串长度的差
public int compareTo(SeqString str) {
int len1 = this.curlen;
int len2 = str.length();// 求出当前串与待比较串的长度
int n = Math.min(len1, len2);// 把较小值赋值到n
char[] s1 = this.strvalue;
char[] s2 = str.strvalue;
int k = 0;
while (k < n) {
char ch1 = s1[k];
char ch2 = s2[k];
if (ch1 != ch2) {
return ch1 - ch2; // 返回第一个不相等字符的数值差
}
k++;
}
return len1 - len2;// 返回两个串长度的差
}5. 串的模式匹配操作
串的查找定位操作（也称为串的模式匹配操作）是指在当前串（主串）中寻找子串（模式串）的过程。若在主串中找到了一个和模式串相同的子串，则查找成功；若在主串中找不到与模式串相同的子串，则查找失败。当模式匹配成功时，返回模式串的首字符在主串中的为序号；当匹配失败时，返回-1。
两种主要的模式匹配算法是Brute-Force算法和KMP算法。
1）Brute-Force模式匹配算法
Brute-Force算法是一种简单、直观的模式匹配算法。其实现方法是：设s为主串，t为模式串，i为主串当前比较字符的下标，j为模式串当前比较的下标。令i的初值为start，j的初值为0。从主串的第start个字符（i=start）起和模式串的第一个字符（j=0）比较，若相等，则继续比较后续字段（i++，j++）；否则从主串的第二个字符起重新开始和模式串比较（i返回到原位置加1，j返回到0），依次类推，知道模式串中的每一个字符依次和主串s的一个连续的字符序列相等，则称匹配成功，返回模式串t的第一个字符在主串s中的位置；否则称匹配失败，返回-1。
public int indexOf(IString t, int start) {
if (this != null && t != null && t.length() > 0
&& this.length() >= t.length()) {
int slen = this.length();
int tlen = t.length();
int i = start;
int j = 0;//j为模式串当前字符的下标
while (i < slen && j < tlen) {
if (this.charAt(i) == t.charAt(j)) {
i++;
j++;//继续比较后续字符
} else {
i = j - i + 1;//主串下标返回原位置加1
j = 0;//模式串下标返回到0
}
}
if (j >= t.length()) {
return i - tlen;// 匹配成功，返回子串序号
} else {
return -1;
}
}
return -1;
}2）KMP算法
4.2 数组
数组是n（n>=1）个具有相同类型的数据元素a0，a1，... an-1构成的有限序列，并且这些数据元素占用一片地址连续的内存单元。其中，n称为数组的长度。
一维数组可以看成是一个顺序存储结构的线性表。数组元素是一维数组的数组称为二维数组，数组元素是二维数组的数组称为三维数组，以此类推。二维数组和三维数组都属于多维数组。实际上，多维数组实际上时是用一维数组实现的。
扫一扫
855
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
