C#与数据结构

C#与数据结构

 

线性表

线性表是最简单也是最常用的一种数据结构。例如,英文字母表(AB,…,Z) 是一个线性表,表中的每一个英文字母是一个数据元素;又如成绩单是一个线性表,表中的每一行是一个数据元素,每个数据元素又是由学号、姓名、成绩等数据项 组成。线性表是最简单的数据结构,而顺序表和链表作为线性表的两种重要存在形式,是堆栈、队列、串以及树和图等数据结构的实现基础,内容非常重要,一定要 认真对待。

本章将介绍线性表的定义、线性表的顺序存储结构和链式存储结构以及相关算法实现。这些存储结构在C#类库中都有相对应的集合类,本章也将对这些集合类的原理、实现及使用做进一步地探讨。

 线性表的定义

线性表(Linear List)是具有相同特性的数据元素的一个有限序列(如图2.1所 示)。该序列中所含元素的个数称作线性表的长度。线性表中的元素在位置上是有序的,好比储户去银行排队取钱,人们依次排列,排在前面的先取钱,排在后面的 后取钱。这种位置上的有序性就是一种线性关系。由此可以看出线性表的前后两个元素存在一一对应的关系。但是需要注意,这种前后关系是逻辑而非物理意义上 的。就好比银行进行了改革,使用排队机进行排队,所有储户分散在银行的各个角落,他们取钱的顺序是依据从排队机获取的纸条上的号数来决定的。

 

线性表的顺序存储结构—顺序表

线性表的顺序存储结构是指用一块地址连续的存储空间依次存储线性表的数据元素。这种存储方式好比改革前的银行,需要在业务窗口前排队取钱。由此可以看出顺序表中逻辑上相邻的元素在物理上也是相邻的。

顺序表的特点

1.         容量固定

存储顺序表的元素需要一整块内存空间,因而顺序表的容量一旦确定,便不能更改。为了理解这一点,可以把内存空间想象成一栋学生宿舍楼,一个班集的学生就是一张线性表,宿舍楼的每个房间都可以住10个学生。如图2.2所示,在新生入学时A班的40个学生被安排进了前4个宿舍(101104),B班的50个学生被安排进了随后的5个宿舍(105109)。当两个班的学生住进宿舍之后,A班又补录了10个学生,这时如果希望A班的所有学生住在连续的5间宿舍已经变得不可能,因为105宿舍已经住进了B班的学生。其实计算机的内存也存在同样的情况,当为某个表分配了一片固定的内存空间后,这个空间周围的其它内存空间极有可能马上被占用,你无法任意地改变已经分配的内存空间的大小。

 

1.         访问速度快

在顺序表使用索引访问数据元素是非常简单、快速的。如图2.3所示,假设顺序表中的第一个元素的位置是Loc,每个数据元素所占用的存储空间为n,那么可以很快地计算出第i个元素的存储地址为:Loc + (i – 1) * n


 

2.2.2 数组

线性表的顺序存储结构在C#中的最直接表现形式就是数组。在C#语言中,数组是最基础也是存取速度最快的一种集合类型。数组是引用类型,保存它们所需的内存空间会在托管堆上分配,一旦数组被创建,其中的所有元素将被初始化为它们的默认值。

int[] arrInt = new int[5];
arrInt[
2= 5;
arrInt[
4= 3;

 

以上代码声明了一个值类型int的数组,并把它的长度初始化为5,最后分别给第3和第5个元素赋值。它在内存中的分布如图2.4所示:


 

从图2.4可以得知,new int[5]会在托管堆中会划分一块能够存放5个整型数据的内存空间,并且每个元素都会被初始化为0,这意味着数组在被创建的同时就拥有了值。另外数组的长度一旦确定就不能再被更改,这使得数组没有添加和删除元素的操作。任何对于数组的添加和删除元素的操作都只能是逻辑意义上的。

注意:在托管堆中创建数组时,除了数组元素,数组对象所占有的内存块还包含一个类型对象指针、同步真索引等额外成员。也就是说new int[5]在内存中划分的空间大于20个字节,图2.4省略了这些额外成员。

当数组元素为值类型时,数组对象存放的是值类型对象本身。当元素为引用类型时,数组对象存放的则是对象的引用(指针)。

Control[] arrCtrl = new Control[5];
arrCtrl[
0= new Button();
arrCtrl[
3= new Label();

 

以上代码声明了一个引用类型Control的数组,并把它的长度初始化为5,最后分别给第1和第4个元素赋值。两个值是分别ButtonLabel对象,虽然它们都继承自Control类,但两者却是不同类,它们的大小不一样。但数组中各个元素的大小是相同的,这些大小不同的对象是如何存储的呢?下面是arrCtrl数组的内存分布图:


 

由图2.5可知,new Control[5]在托管堆中划分了一块能够存放5个指针的内存空间,并且每个元素都被初始化为null。当使用 arrCtrl[0]=new Button() 给数组元素赋值时,首先在托管堆中创建一个Button对象,然后把Button的内存地址存放在数组的第一个元素中,这样就可以通过数组中的指针访问Button对象了。

数组有很多优点,但它的缺点也非常明显。在实际编程中,经常需要对集合中的元素进行添加和删除,也需要动态地改变集合的大小,数组显然无法满足这些需求。怎么样才能使数组具有改变空间大小的功能呢?

2.2.3 ArrayList

如果要动态地改变数组所占用内存空间的大小,则需以数组为基础进一步抽象,以实现这个功能。以图2.2的学生宿舍为例,为了使A班的所学生住在连续的宿舍内,可以把A班的学生全部搬迁到连续的5间空宿舍内。其效果如图2.6所示:



 

现实中,为了让一个班新加入的10个学生能跟原来的学生住在一起而把班级整体搬迁,这样的做法显示不合适,因为搬迁的成本太高。但在计算机中,内存成片区域间的拷贝成本是非常低的,这样的解决方案是合理可行的。

但是这个解决方案还存在问题,如果一个班级频繁地有新学生加入,为了保证学生能住在连续的宿舍内,整个班级就不得不频繁地搬迁。可以采用以空间换时间的做法来解决这个问题,在学生每次搬迁时,都让班级宿舍的数量是原来的两倍。也就是说,如果原来一个班级有4间宿舍,搬迁后就变为8间,再次搬迁则变为16间。如图2.2所示,A班的宿舍为201208206208这三间宿舍做为本班备用宿舍,不再允许其他班级的学生搬入。

C#中的ArrayList正是采用上述方法来动态改变数组大小的。ArrayList又被称为动态数组,它的存储空间可以被动态改变,同时还拥有添加、删除元素的功能。

下面列出了ArrayList的部分核心代码:

ArrayList.cs


using System;
namespace LinearList
{
    
public class ArrayList
    {
        
// 成员变量
        private const int _defaultCapacity = 4//默认初始容量
        private object[] _items; //用于存放元素的数组
        private int _size; //指示当前元素个数
        
//当元素个数为零时的数组状态
        private static readonly object[] emptyArray = new object[0];
        
// 方法
        public ArrayList() //默认构造方法
        {   //这样做可以避免元素个数为零时的访问出错
            this._items = emptyArray;
        }
        
//指定ArrayList初始容量的构造方法
        public ArrayList(int capacity)
        {
            
if (capacity < 0)
            {   
//当容量参数为负数时引发异常
                throw new ArgumentOutOfRangeException("capacity",
                    
"为ArrayList指定的初始容量不能为负数");
            }
            
//按照capacity参数指定的长度的值初始化数组
            this._items = new object[capacity]; 
        }
        
//添加一个方法
        public virtual int Add(object value)
        {   
//当空间满时
            if (this._size == this._items.Length)
            {   
//调整空间
                this.EnsureCapacity(this._size + 1);
            }
            
this._items[this._size] = value; //添加元素
            return this._size++//使长度加1
        }
        
//动态调整数组空间
        private void EnsureCapacity(int min)
        {
            
if (this._items.Length < min)
            {   
//空间加倍
                int num = (this._items.Length == 0?
                    _defaultCapacity : (
this._items.Length * 2);
                
if (num < min)
                {
                    num 
= min;
                }
                
//调用Capacity的set访问器以按照num的值调整数组空间
                this.Capacity = num;
            }
        }
        
//在指定索引入插入指定元素
        public virtual void Insert(int index, object value)
        {
            
if ((index < 0|| (index > this._size))
            {
                
throw new ArgumentOutOfRangeException("index""索引超出范围");
            }
            
if (this._size == this._items.Length)
            {   
//当空间满时调整空间
                this.EnsureCapacity(this._size + 1);
            }
            
if (index < this._size)
            {   
//插入点后面的所有元素向后移动一位
                Array.Copy(this._items, index, 
                    
this._items, index + 1this._size - index);
            }
            
this._items[index] = value; //插入元素
            this._size++//使长度加1
        }
        
//移除指定索引的元素
        public virtual void RemoveAt(int index)
        {
            
if ((index < 0|| (index >= this._size))
            {
                
throw new ArgumentOutOfRangeException("index""索引超出范围");
            }
            
this._size--//使长度减1
            if (index < this._size)
            {   
//使被删除元素后的所有元素向前移动一位
                Array.Copy(this._items, index + 1
                    
this._items, index, this._size - index);
            }
            
this._items[this._size] = null//最后一位空出的元素置空
        }
        
//裁减空间,使存储空间正好适合元素个数
        public virtual void TrimToSize()
        {
            
this.Capacity = this._size;
        }

        
// 属性
        public virtual int Capacity //指示ArrayList的存储空间
        {
            
get
            {
                
return this._items.Length;
            }
            
set
            {
                
if (value != this._items.Length)
                {
                    
if (value < this._size)
                    {
                        
throw new ArgumentOutOfRangeException("value""容量太小");
                    }
                    
if (value > 0)
                    {   
//开辟一块新的内存空间存储元素
                        object[] destinationArray = new object[value];
                        
if (this._size > 0)
                        {   
//把元素搬迁到新空间内
                            Array.Copy(this._items, 0,
                                destinationArray, 
0this._size);
                        }
                        
this._items = destinationArray;
                    }
                    
else //最小空间为_defaultCapacity所指定的数目,这里是4
                    {
                        
this._items = new object[_defaultCapacity];
                    }
                }
            }
        }
        
public virtual int Count //只读属性,指示当前元素个数
        {
            
get
            {
                
return this._size;
            }
        }
        
public virtual object this[int index] //索引器
        {
            
get //获取指定索引的元素值
            {
                
if ((index < 0|| (index >= this._size))
                {
                    
throw new ArgumentOutOfRangeException("index""索引超出范围");
                }
                
return this._items[index];
            }
            
set //设置指定索引的元素值
            {
                
if ((index < 0|| (index >= this._size))
                {
                    
throw new ArgumentOutOfRangeException("index""索引超出范围");
                }
                
this._items[index] = value;
            }
        }
    }
}

 

上述代码通过在一个数组(第8行代码的成员变量_items)的基础上做进一步抽象,构建了一个可动态改变空间的顺序表ArrayList,并实现了一些基础操作,下面对之进行一一介绍。

1.    初始化

这里实现了2种初始方法,第一种为1316行代码,它把顺序表空间初始化为一个0长度数组。这样做的目的是为了调用方便。做为成员变量的object类型数组_items默认会被初始化为null,如果不把它初始化为0长度数组,在使用代码 ArrayList arr = new ArrayList() 来创建ArrayList后试图访问它的Count属性将会导致错误发生。

第二种初始化方法为1827行代码,它根据capacity参数所指定的值来初始化_items数组的长度,如果初始化一个长度为100ArrayList数组可以使用如下代码:

ArrayList arr = new ArrayList(100)

当可以预见ArrayList所操作的大概元素个数时,使用这种方法可以在一定程序上避免数组重复创建和数据迁移,以提高性能和减少内存垃圾回收的压力。

2.    动态改变存储空间操作

3952行的EnsureCapacity(int min)方法用于空间不足时使空间加倍,从代码:

int num = (this._items.Length == 0) ? _defaultCapacity : (this._items.Length * 2);

可以得知,当元素个数为0是,空间增长为4,否则将翻倍。改变空间大小的代码是在Capacity属性中的set访问器中实现的(代码99122行)。代码

object[] destinationArray = new object[value];

创建了一个新的object数组,它在内存中开辟了一个新的空间用于存放元素。代码

Array.Copy(this._items, 0, destinationArray, 0, this._size);

_items数组中的元素全部拷贝到新数组destinationArray中,可以把它理解为数据搬新家。最后通过

this._items = destinationArray;

使用于存放数据的成员变量_items指向新的数组对象destinationArray

8891TrimToSize()方法用于裁减多余空间,实际的裁减操作也是在Capacity属性中的set访问器中实现。这个操作也会导致数组的重新创建和数据迁移,建议一般情况下不使用此操作,除非集合中的剩余空间很多。

3.    元素的读写操作

131149行代码实现了一个索引器,这样就可以使用中括号加索引号来读取和给元素赋值,使ArrayList的使用看上去和数组很相似。

4.    元素的添加和插入操作

2937行的Add(object value)方法实现了添加元素的功能。元素添加在集合的末尾,成员变量_size用于指示当前元素个数,它总是指向集合中的最后一个元素。

5471Insert(int index, object value)方法用于在指定索引处插入一个元素。为了保证顺序表中的每个元素物理上相邻,插入点后面的所有元素都将后移一位,其效果如图2.7(a)所示。



 

1.    元素的删除操作

7386行的RemoveAt(int index)方法用于删除指定索引的元素,删除指定元素后,删除点后的所有元素将向前移动一位其效果如图2.7(b)所示。

下面对ArrayList类进行测试。

【例2-1ArrayList的使用

新建一个控制台应用程序,并在项目中把上面的ArrayList.cs文件做为一个【现有项】添加进去。在代码窗体前面使用如下语句加入LinearList命名空间:

using LinearList;

并在Main方法中输入如下代码:

using System;
using LinearList;

namespace Demo2_1
{
    
class Program
    {
        
static void Main(string[] args)
        {
            ArrayList arr 
= new ArrayList();
            Console.WriteLine(
"arr现在的容量为:" + arr.Capacity + "  长度为:" + arr.Count);
            arr.Add(
1); //添加一个元素
            Console.WriteLine("arr现在的容量为:" + arr.Capacity + "  长度为:" + arr.Count);
            
for (int i = 2; i <= 5; i++)
            {   
//添加4个元素,完成后元素总数达到5个
                arr.Add(i);
            }
            Console.WriteLine(
"arr现在的容量为:" + arr.Capacity + "  长度为:" + arr.Count);
            
for (int i = 6; i <= 9; i++)
            {   
//添加4个元素,完成后元素总数达到9个
                arr.Add(i);
            }
            Console.WriteLine(
"arr现在的容量为:" + arr.Capacity + "  长度为:" + arr.Count);
            
for (int i = 0; i < arr.Count; i++//打印所有元素
            {
                Console.Write(i 
+ "  ");
            }
            
//删除两个元素
            arr.RemoveAt(arr.Count - 1);
            arr.RemoveAt(arr.Count 
- 1);
            Console.WriteLine(); 
//换行
            for (int i = 0; i < arr.Count; i++//打印所有元素
            {
                Console.Write(i 
+ "  ");
            }
            Console.WriteLine(); 
//换行
            Console.WriteLine("arr现在的容量为:" + arr.Capacity + "  长度为:" + arr.Count);
            arr.TrimToSize(); 
//载减多余空间
            Console.WriteLine("arr现在的容量为:" + arr.Capacity + "  长度为:" + arr.Count);
            Console.ReadLine();
        }
    }
}

 

运行结果:如图2.8所示。



 

由运行结果可以得知,数组对象arr的容量随着元素的不断增加,从04816不断改变,在删除两个元素之后,容量还保持在16不变,在通过调用TrimToSize()裁减空间后,容量最终变为7

2.2.4 类型安全

数组和ArrayList的本质区别在于前者是类型安全的,而后者不是类型安全的。ArrayList为了兼容所有类型的对象,使用了object数组,这给使用带来了一些的麻烦。如下例所示:

【例2-2】数组和ArrayList的对比

本例使用了C#类库中的ArrayList而不是前面自定义的ArrayList,它存在于System.Collections命名空间中。新建一个控制台应用程序,引入System.Collections命名空间,并在Main()方法中输入如下代码:

using System;
using System.Collections;
namespace Demo2_2
{
    
class Program
    {
        
static void Main(string[] args)
        {
            
int[] arr = new int[2];
            arr[
0= 5;
            arr[
1= 6;
            
int result = arr[0* arr[1];
            Console.WriteLine(result);
            ArrayList arrL 
= new ArrayList();
            arrL.Add(
5);
            arrL.Add(
6);
            result 
= (int)arrL[0* (int)arrL[1];
            Console.WriteLine(result);
            Console.ReadLine();
        }
    }
}

 

运行结果:

30

30

 

本例使用数组和ArrayList分别做了相同的事情,但使用方法却大相径庭。首先数组在创建时就已经确定只接收int类型数据,并且它的长度是固定的。而ArrayList则可以接收任意object类型,而事实上,C#中的所有类均是object类型的子类。

其次数组没有添加元素的功能,因为在数组创建时,各个元素就已经存在,只是被初始化为0而已,只能通过下标改变各个元素的值。而ArrayList只有把元素添加进去后才可以通过下标访问相应的元素。

最后,在使用集合中的元素时,数组不需要进行强制类型转换,而ArrayList必须要经过强制类型转换才能使用。这是因为ArrayList实际存放的是object对象,要按照这些对象原本的类型来使用就必须要使用强制类型转换。

ArrayList的这个特点带来了类型安全问题,如:

ArrayList arrL = new ArrayList();
arrL.Add(
5);
arrL.Add(
"Hello World");
arrL.Add(
new Button());
 

以上代码在集合中存放了各种各样的数据类型,但这样做是被允许的。这种类型的不安全一方面给程序带来了隐患,另一方面如果集合中存放的是值类型还会产生装箱和拆箱操作,降低了程序的性能。

.NET 2.0版本的泛型的出现完美地解决了上述问题,新版本使用System.Collections.Generic命名空间下的List<T>类取代了原来的ArrayList类。下面演示了泛型List<T>类的使用:

List<int> arrL=new List<int>();
arrL.Add(
1);
arrL.Add(
2);
 

可以看到,第一行代码在集合创建时就已经把元素类型限定为int,它是类型安全的,同时避免了装箱和拆箱操作。强烈建议在实际编程中使用List<T>代替ArrayList


posted @ 2008-07-20 09:51  yangjun  阅读(570)  评论(0编辑  收藏