C#数据结构与算法揭秘六

这节我们讨论两种用的蛮多的数据结构——串和数组

首先，老样子，什么是串，这里串不是吃的牛肉串，羊肉串，而是字符串。在应用程序中使用最频繁的类型是字符串。字符串简称串，是一种特殊的线性表，其特殊性在于串中的数据元素是一个个的字符。字符串在计算机的许多方面应用很广。如在汇编和高级语言的编译程序中，源程序和目标程序都是字符串数据。在事务处理程序中，顾客的信息如姓名、地址等及货物的名称、产地和规格等，都被作为字符串来处理。另外，字符串还具有自身的一些特性。因此，把字符串作为一种数据结构来研究。具体情况，如图所示，顾客信息处理的字符串。

串有哪些基本的概念了， 串(String)由 n(n≥0)字符组成的有限序列。一般记为： S=”c1c2…cn” (n≥0) 其中，S是串名，双引号作为串的定界符，用双引号引起来的字符序列是串

值。ci（1≤i≤n）可以是字母、数字或其它字符，n为串的长度，当n=0 时，称为空串(Empty String)。 串中任意个连续的字符组成的子序列称为该串的子串(Substring)。包含子串的串相应地称为主串。子串的第一个字符在主串中的位置叫子串的位置。如串s1”abcdefg”，它的长度是 7，串s2”cdef”的长度是 4，s2是s1的子串，s2的位置是 3。
如果两个串的长度相等并且对应位置的字符都相等，则称这两个串相等。而在 C#中，比较两个串是否相等还要看串的语言文化等信息。所谓语言文化，是指中文的字符串和中文字符串进行了比较，英文字符串与英文字符串进行了比较。父串子串的示意图：

串是如何存储及类定义的了，由于串中的字符都是连续存储的，而在 C#中串具有恒定不变的特性，即字符串一经创建，就不能将其变长、变短或者改变其中任何的字符。相应的示意图如下所示：

所以，这里不讨论串的链式存储，也不用接口来表示串的操作。同样，把串看作是一个类，类名为 StringDS。取名为 StringDS 是为了和 C#自身的字符串类 String 相区别。类
StringDS 只有一个字段， 即存放串中字符序列的数组 data。 由于串的运算有很多，在类 StringDS 中只包含部分基本的运算增加，清空，球长度等等操作。给串类 StringDS 的 源代码实现如下所示：

public class StringDS
{
private char[] data; //字符数组

//索引器
public char this[int index]
{
get
{
return data[index];
}
}

//构造器
public StringDS(char[] arr)
{

data = new char[arr.Length];
for(int i = 0; i < arr.Length; ++i)
{
data[i] = arr[i];
}
}

//构造器
public StringDS(StringDS s)
{
for(int i = 0; i < arr.Length; ++i)
{
data[i] = s[i];
}
}

//构造器
public StringDS(int len)
{
char[] arr = new char[len];
data = arr;
}

//求串长
public int GetLength()
{
return data.Length;
}

求串的长度就是求串中字符的个数，可以通过求数组 data 的长度来求串的长度。算法的时间复杂度是O(1),具体情况，如图所示：

//串比较
public int Compare(StringDS s)
{
int len=((this.GetLength()<=s.GetLength())?
this.GetLength():s.GetLength());
int i = 0;
for (i = 0; i < len; ++i)
{
if (this[i] != s[i])
{
break;
}
}

if (i <= len)

{
if (this[i] < s[i])
{
return -1;
}
else if (this[i] > s[i])
{
return 1;
}
}
else if(this.GetLength() == s.GetLength())
{
return 0;
}
else if (this.GetLength() < s.GetLength())
{
return -1;
}

return 1;
}

如果两个串的长度相等并且对应位置的字符相同，则串相等，返回 0；如果串 s 对应位置的字符大于该串的字符或者如果串 s 的长度大于该串， 而在该串的长度返回内二者对应位置的字符相同，则返回-1，该串小于串 s；其余情况返回1，该串大于串 s。该算法的时间复杂度是O(n)  涉及到字符串数组的遍历。具体伪代码，如图所示：

//求子串
public StringDS SubString(int index, int len) 
{
if ((index<0) || (index>this.GetLength()–1)
|| (len<0) || (len>this.GetLength()–index))
{
Console.WriteLine("Position or Length is error!");
return null;
}

StringDS s = new StringDS(len);

for (int i = 0; i < len; ++i)
{
s[i] = this[i + index-1];
}

return s;
}

{
StringDS s1 = new StringDS(this.GetLength() +
s.GetLength());

for(int i = 0; i < this.GetLength(); ++i)
{
s1.data[i] = this[i];
}

for(int j = 0; j < s.GetLength(); ++j)
{
s1.data[this.GetLength() + j] = s[j];
}

return s1;
}

从主串的index位置起找长度为len的子串，若找到，返回该子串，否则，返回一个空串。涉及字符串的遍历，所以时间复杂度是O(n)  相应图如图所示：

//串插入
public StringDS Insert(int index, StringDS s)
{
int len = s.GetLength();
int len2 = len + this.GetLength();
StringDS s1 = new StringDS(len2);

if (index < 0 || index > this.GetLength() - 1)
{
Console.WriteLine("Position is error!");
return null;
}

for (int i = 0; i < index; ++i)
{
s1[i] = this[i];
}

for(int i = index; i < index + len ; ++i)
{
s1[i] = s[i - index];
}

for (int i = index + len; i < len2; ++i)
{
s1[i] = this[i - len];

return s1;
} 

串插入是在一个串的位置index处插入一个串s。如果位置符合条件，则该操作返回一个新串，新串的长度是该串的长度与串s的长度之和，新串的第1部分是该串的开始字符到第index之间的字符，第2部分是串s,第3部分是该串从index位置字符到该串的结束位置处的字符。如果位置不符合条件，则返回一个空串。时间复杂度是O(n),具体 操作如图所示：

//串删除
public StringDS Delete(int index, int len)
{
if ((index<0) || (index>this.GetLength()-1)
|| (len<0) || (len>this.GetLength()-index))
{
Console.WriteLine("Position or Length is error!");
return null;
}

StringDS s = new StringDS(this.GetLength() - len);

for (int i = 0; i < index; ++i)
{
s[i] = this[i];
}

for (int i = index + len; i < this.GetLength(); ++i)
{
s[i] = this[i];
}

return s;
}

串删除是从把串的第index位置起连续的len个字符的子串从主串中删除掉。如果位置和长度符合条件，则该操作返回一个新串，新串的长度是原串的长度减去len，新串的前部分是原串的开始到第index个位置之间的字符，后部分是原串从第index+len位置到原串结束的字符。如果位置和长度不符合条件，则返回一个空串。相应的时间复杂度是O(n),相应情况，如图所示:

}

这就是我对串的理解，我们看看数组的理解。

什么是数组。所谓数组是数组是一种常用的数据结构，可以看作是线性表的推广。数组作为一种数据结构， 其特点是结构中的数据元素可以是具有某种结构的数据， 甚至可以是数组，但属于同一数据类型。数组在许多高级语言里面都被作为固定类型来使用。

数组是 n(n≥1)个相同数据类型的数据元素的有限序列。一维数组可以看作是一个线性表，二维数组可以看作是“数据元素是一维数组”的一维数组，三维数组可以看作是“数据元素是二维数组”的一维数组，依次类推。 图是一个 m 行 n 列的二维数组。

数组是一个具有固定格式和数量的数据有序集， 每一个数据元素通过唯一的下标来标识和访问。通常，一个数组一经定义，每一维的大小及上下界都不能改变。 所以， 在数组上不能进行插入、 删除数据元素等操作。 数组上的操作一般有： 

1、取值操作：给定一组下标，读其对应的数据元素；算法的复杂度是O(1) 

2、赋值操作：给定一组下储或修改与其对应的数据元素； 算法的复杂度是O(1)
3、清空操作：将数组中的所有数据元素清除； 算法的复杂度是O(1)
4、复制操作：将一个数组的数据元素赋给另外一个数组； 算法的复杂度是O(n)
5、排序操作：对数组中的数据元素进行排序，这要求数组中的数据元素是可排序的；希尔排序，冒泡排序等等，算法的复杂度是O(n²) 
6、反转操作：反转数组中数据元素的顺序。以前提过，请见了C#数据结构与算法揭秘一。

什么是数组的内存映象 ，

通常，采用顺序存储结构来存储数组中的数据元素，因为数组中的元素要求连续存放。本质上，计算机的内存是一个一维数组，内存地址就是数组的下标。所以，对于一维数组，可根据数组元素的下标得到它的存储地址，也可根据下标来访问一维数组中的元素。而对于多维数组，需要把多维的下标表达式转换成一维的下标表达式。当行列固定后，要用一组连续的存储单元存放数组中的元素，有一个次序约定问题， 这产生了两种存储方式： 一种是以行序为主序 （先行后列）的顺序存放，另一种是以列序为主序（先列后行）的顺序存放。下图给出了图中的二维数组的两种存放方式示意图。

下面按元素的下标求地址： 当以行序为主序进行存储时，设数组的基址是Loc(a11)，每个数据元素占w个存储单元，则a11的物理地址可由下式计算： Loc(aij)= Loc(a11)+((i-1)*n+j-1)*w 这是因为数组元素aij的前面有i-1行， 每一行有n个数据元素， 在第i行中aij的前面还有j-1个元素。 如图所示

当以列序为主序进行存储时，则a11的物理地址可由下式计算： Loc(aij)= Loc(a11)+((j-1)*m+i-1)*w （4-2） 这是因为数组元素aij的前面有j-1列， 每一列有m个数据元素， 在第j列中aij的前面还有i-1个元素。 由以上的公式可知，数组元素的存储位置是其下标的线性函数，一旦确定了数组各维的长度，就可以计算任意一个元素的存储地址，并且时间相等。所以，存取数组中任意一个元素的时间也相等，因此，数组是一种随机存储结构。时间复杂度是O(n2).相应的情况，如图所示：

这就是我对数组的理解