数据结构与算法(C#):数组和ArrayList

数组和ArrayList
数组是最通用的数据结构,它出现在几乎所有的编程语言里.ArrayList是一种需要更多空间来动态生长的数组.对于无法精确知道数组最终大小的情况,或者对于程序声明周期内数组大小可能会发生一点变化的情况,用ArrayList比用数组合适
2.1 数组基本概念
数组是可索引的集合.数据既可以是内置类型,也可以是用户自定义的类型.
2.1.1 数组的声明和初始化
以int类型为例,
声明 :int[] temp;
初始化: temp=new int[5](这里直接给出了数组所能包含元素的数量)
temp=new int[]{1,2,3,4,5};(这里采用了初始化列表的方式,不需要给数组所能保研元素的数量)
2.12 数组元素的设置和存取访问
这里有两种方法一种是直接存取和使用Array类提供的SetValue方法和GetValue方法.
例:temp[0]=1;/temp.SetValue(1,0);
Int i=temp[0];/int i=temp.GetValue(0);
2.1.3 检索数组元数据的方法和属性
Array类为检索数组元素提供了几种属性和方法
u Length :获得一个32位整数,该整数表示Array的所有维数中元素的总数.
u Rank :获取Array的秩（维数）.
u Clear():将Array中的一系列元素设置为零、false 或 nullNothingnullptrnull引用
u ,具体取决于元素类型.
u ConvertAll():将一种类型的数组转换为另一种类型的数组.
u Copy():将一个Array的一部分元素复制到另一个Array中，并根据需要执行类型强制转换和装箱.
u CopyTo():将当前一维Array的所有元素复制到指定的一维Array中.
u GetLength():获取一个 32 位整数,该整数表示Array的指定维中的元素数.
u GetLowerBound():获取Array中指定维度的下限.
u GetType():获取当前实例的 Type.
u GetUpperBound(): 获取Array的指定维度的上限.
u GetValue(): 获取当前Array中指定元素的值.
u IndexOf(): 返回一维Array或部分Array中某个值第一个匹配项的索引.
u LastIndexOf():返回一维Array或部分Array中某个值的最后一个匹配项的索引.
u Reverse():反转一维Array或部分Array中元素的顺序.
u SetValue():将当前Array中的指定元素设置为指定值.
u Sort();对一维Array对象中的元素进行排序.
2.1.4 多维数组
以二维数组为例int[,] temp=new int[2,3]; 此语句声明了一个2行3列的数组.当然多维数组也可以使用初始化表的方式来进行初始化操作.如:int[,] temp=new int[,]{{1,2,3},{456}}.存取访问和一维数组是一样的
2.1.5 参数数组
用param 关键字可以在方法定义的参数列表中指明参数数组.
2.1.6 锯齿状数组
锯齿状数组是一种每行都能组成一个数组的数组.锯齿状数组的每一维就是一个一维数组.锯齿状数组的声明需要通过在数组变量名后放置两组方括号的方式来完成的.第一组方括号说明了数组的行数,第二组方括号则是留白的,这位存储在每行内的一维数组标记了位置,通常情况下,声明语句的初始化列表会设置行数
2.2 ArrayList
ArrayList对象拥有可存储数组大小尺寸的Capacity属性,该属性的初始值为4,当ArrayList中元素的数量达到此界限值时,Capacity属性就会为ArrayList的存储空间另外增加4个元素.
2.2.1 ArrayList类的成员
ArrayList最常用到的一些方法和属性
u Add():向ArrayList添加一个元素
u AddRange():在ArrayList末尾处添加群集的元素
u Capacity:存储ArrayList所能包含的元素的数量
u Clear():从ArrayList中移除所有元素
u Contains():确定指定的对象是否在ArrayList内
u Copy To():把ArrayList或其中某一段复制给一个数组
u Count:返回ArrayList当前元素的数量
u GetEnumerator():返回迭代ArrayList的计数器
u GetRange():返回ArrayList的子集作为ArrayList
u IndexOf():返回指定数据项首次出现的索引
u Insert():在ArrayList的指定索引处插入一个元素
u InsertRange():从ArrayList指定索引处开始插入群集的元素
u Item():在指定索引处获取或设置一个元素
u Remove():移除指定数据项的首次出现
u RemoveAt():在指定索引处移除一个元素
u Reverse():对ArrayList中元素的顺序进行反转
u Sort():对ArrayList中的元素按照阿拉伯字母表顺序进行排序
u ToArray():把ArrayList的元素复制给一个数组
u TrimToSize():将ArrayList的容量设置成ArrayList忠的元素数量

下面是我自己用数组实现ArrayList的部分方法.由于能力有限可能实现上存在或多或少的问题,请大家指教.谢谢

public class MyArrayList<T>
{

/// <summary>
/// 声明T类型数组的容器。
/// </summary>
private T[] listT;
/// <summary>
/// 获取或设置MyArrayList中容器指定索引处的元素。
/// </summary>
/// <param name="index">要获取或设置的元素的从零开始的索引。</param>
/// <returns>要获取或设置的元素</returns>
public T this[int index]
{
get { return listT[index]; }
set { listT[index] = value; }
}
/// <summary>
///  获取 MyArrayList 中实际包含的元素数。
/// </summary>
private int count;
public int Count
{
get { return count; }
}
/// <summary>
///  获取或设置 MyArrayList 可包含的元素数。
/// </summary>
public int capacity = 4;
public int Capacity
{
get { return capacity; }
set {
if (capacity != value)
{

T[] oldList = listT;
listT = new T[value];
System.Array.Copy(oldList,listT, count);
oldList = null;

}
capacity = value;

}
}

/// <summary>
/// 初始化 MyArrayList 类的新实例，该实例为空并且具有默认初始容量。
/// </summary>
public MyArrayList()
{
listT =new T[4];

}
/// <summary>
/// 将对象添加到 MyArrayList 的结尾处。
/// </summary>
/// <param name="value">要添加到 MyArrayList 的末尾处的泛型类元素。该值可以为 null。</param>
/// <returns> MyArrayList 索引，已在此处添加了 value。</returns>
public int Add(T value)
{
RangeCheck();
listT[count] = value;
count++;

return count - 1;
}
/// <summary>
/// 将 IEnumerable 的元素添加到 MyArrayList 的末尾。
/// </summary>
/// <param name="c">IEnumerable，其元素应被添加到 MyArrayList 的末尾。集合本身不能为
///     null，但它可以包含为 null 的元素。</param>
public void  AddRange(IEnumerable<T> c)
{
foreach (T obj in c)
{
Add(obj);
}
}
/// <summary>
/// 从 MyArrayList 中移除所有元素。
/// </summary>
public void Clear()
{
listT = new T[4];
count = 0;
}
/// <summary>
/// 确定某元素是否在 MyArrayList 中。
/// </summary>
/// <param name="item">要在 MyArrayList 中查找的泛型类元素。该值可以为 null。</param>
/// <returns>如果在 MyArrayList 中找到 item，则为 true；否则为 false。</returns>
public bool Contains(T item)
{
foreach (T obj in listT)
{
if (obj.Equals(item))
{
return true;
}
}
return false;
}
/// <summary>
/// 将集合中的某个元素插入 MyArrayList 的指定索引处。
/// </summary>
/// <param name="index">应在此处插入新元素的从零开始的索引。</param>
/// <param name="value">  要插入的 泛型类元素。该值可以为 null。</param>
public void Insert(int index, T value)
{
count++;
RangeCheck();
T obj = default(T);
for (int i = count-1; i >index; i--)
{
obj = listT[i];
listT[i] = listT[i - 1];
listT[i - 1] = obj;

}
listT[index] = value;

}

/// <summary>
/// 将集合中的某个元素插入 MyArrayList 的指定索引处。
/// </summary>
/// <param name="index">应在此处插入新元素的从零开始的索引。</param>
/// <param name="c">IEnumerable，应将其元素插入到 MyArrayList 中。集合本身不能为
///     null，但它可以包含为 null 的元素。</param>
public void InsertRange(int index, IEnumerable<T> c)
{
foreach (T obj in c)
{
Insert(index, obj);
index++;
}
}
/// <summary>
/// 搜索指定的 泛型，并返回 MyArrayList 中从指定的索引开始并包含指定的元素数的元素范围内第一个匹配项的从零开始的索引。
/// </summary>
/// <param name="value">要在 MyArrayList 中查找的泛型类元素。该值可以为 null。</param>
/// <param name="startIndex">从零开始的搜索的起始索引。</param>
/// <param name="count">要搜索的部分中的元素数。</param>
/// <returns>如果在 MyArrayList 中从 startIndex 开始并包含 count 个元素的元素范围内找到 value
///    的第一个匹配项，则为该项的从零开始的索引；否则为 -1。</returns>
public  int IndexOf(T value, int startIndex, int count)
{
for (int i = startIndex; i < count; i++)
{
if (listT[i].Equals(value))
{
return i;
}
}
return -1;
}
/// <summary>
/// 搜索指定的泛型类元素，并返回 MyArrayList 中从指定的索引开始并包含指定的元素数的元素范围内第一个匹配项的从零开始的索引。
/// </summary>
/// <param name="value">要在 MyArrayList 中查找的泛型类元素。该值可以为 null。</param>
/// <param name="startIndex">从零开始的搜索的起始索引。</param>
/// <returns>如果在 MyArrayList 中从 startIndex 开始并包含 count 个元素的元素范围内找到 value
///    的第一个匹配项，则为该项的从零开始的索引；否则为 -1。</returns>
public int IndexOf(T value, int startIndex)
{
return IndexOf(value, startIndex, count);
}
/// <summary>
/// 搜索指定的泛型类元素，并返回 MyArrayList 中从指定的索引开始并包含指定的元素数的元素范围内第一个匹配项的从零开始的索引。
/// </summary>
/// <param name="value">要在 MyArrayList 中查找的泛型类元素。该值可以为 null。</param>
/// <returns>如果在 MyArrayList 中从 startIndex 开始并包含 count 个元素的元素范围内找到 value
///    的第一个匹配项，则为该项的从零开始的索引；否则为 -1。</returns>
public int IndexOf(T value)
{
return IndexOf(value, 0, count);
}
/// <summary>
/// 搜索指定的泛型类元素，并返回 MyArrayList 中包含指定的元素数并在指定索引处结束的元素范围内最后一个匹配项的从零开始的索引。
/// </summary>
/// <param name="value">要在 MyArrayList 中查找的泛型类元素。该值可以为 null。</param>
/// <param name="startIndex">向后搜索的从零开始的起始索引。</param>
/// <param name="count">要搜索的部分中的元素数</param>
/// <returns>如果在 MyArrayList 中包含 count 个元素、在 startIndex 处结尾的元素范围内找到 value
///   的最后一个匹配项，则为该项的从零开始的索引；否则为 -1。</returns>
public int LastIndexOf(T value, int startIndex, int count)
{
int result = -1;
for (int i = startIndex; i < count + startIndex; i++)
{
if (listT[i].Equals(value))
{
result = i;
}
}
return result;
}
/// <summary>
/// 搜索指定的泛型类元素，并返回 MyArrayList 中包含指定的元素数并在指定索引处结束的元素范围内最后一个匹配项的从零开始的索引。
/// </summary>
/// <param name="value">要在 MyArrayList 中查找的泛型类元素。该值可以为 null。</param>
/// <param name="startIndex">向后搜索的从零开始的起始索引。</param>
/// <returns>如果在 MyArrayList 中包含 count 个元素、在 startIndex 处结尾的元素范围内找到 value
///   的最后一个匹配项，则为该项的从零开始的索引；否则为 -1。</returns>
public int LastIndexOf(T value, int startIndex)
{
return LastIndexOf(value, startIndex, count);
}
/// <summary>
/// 搜索指定的泛型类元素，并返回 MyArrayList 中包含指定的元素数并在指定索引处结束的元素范围内最后一个匹配项的从零开始的索引。
/// </summary>
/// <param name="value">要在 MyArrayList 中查找的 泛型。该值可以为 null。</param>
/// <returns>如果在 MyArrayList 中包含 count 个元素、在 startIndex 处结尾的元素范围内找到 value
///   的最后一个匹配项，则为该项的从零开始的索引；否则为 -1。</returns>
public  int LastIndexOf(T value)
{
return LastIndexOf(value, 0, count);
}
/// <summary>
/// 自动设置MyArrayList的Capacity大小。
/// </summary>
private void RangeCheck()
{
if (count == Capacity)
{
Capacity += 4;
}
if (count != 0)
{
if (Capacity - count > 4)
{
Capacity -= 4;
}
}
}

/// <summary>
/// 从 MyArrayList 中移除特定对象的第一个匹配项。
/// </summary>
/// <param name="obj">要从 MyArrayList 移除的泛型类元素。该值可以为 null。</param>
public  void Remove(T obj)
{
RemoveAt(IndexOf(obj));
}
/// <summary>
/// 移除 MyArrayList 的指定索引处的元素。
/// </summary>
/// <param name="index">要移除的元素的从零开始的索引。</param>
public  void RemoveAt(int index)
{

for (int i = index; i < count; i++)
{
if (i ==count - 1)
{
break;
}
listT[i] = listT[i + 1];
}
listT[count - 1] = default(T);
count--;
RangeCheck();
}
/// <summary>
/// 从 MyArrayList 中移除一定范围的元素。
/// </summary>
/// <param name="index">要移除的元素的范围从零开始的起始索引。</param>
/// <param name="count">要移除的元素数。</param>
public  void RemoveRange(int index, int count)
{
for (int i = 0; i < count; i++)
{
RemoveAt(index);
}
}
/// <summary>
/// 将整个 MyArrayList 中元素的顺序反转。
/// </summary>
public  void Reverse()
{
Reverse(0, count);
}
/// <summary>
/// 将指定范围中元素的顺序反转。
/// </summary>
/// <param name="index">要反转的范围的从零开始的起始索引。</param>
/// <param name="count">要反转的范围内的元素数。</param>
public  void Reverse(int index, int count)
{
T obj = default(T);
for (int i = index; i < index + count; i++)
{
obj = listT[i];
if (count - i > i)
{

listT[i] = listT[count - i - 1];
listT[count - i - 1] = obj;
}
else {
break;
}

}
}
/// <summary>
/// 使用指定的比较器对 MyArrayList 中某个范围内的元素进行排序。
/// </summary>
public void Sort()
{
Sort(0, count, new Comparer(new CultureInfo("zh-CN", false)));
}
/// <summary>
/// 使用指定的比较器对 MyArrayList 中某个范围内的元素进行排序。
/// </summary>
/// <param name="comparer">比较元素时要使用的 System.Collections.IComparer 实现。- 或 - 若为 null，则使用每个元素的 System.IComparable 实现。</param>
public void Sort(IComparer comparer)
{
Sort(0, count, comparer);
}
/// <summary>
/// 使用指定的比较器对 MyArrayList 中某个范围内的元素进行排序。
/// </summary>
/// <param name="index">要排序的范围的从零开始的起始索引。</param>
/// <param name="count">要排序的范围的长度。</param>
/// <param name="comparer">比较元素时要使用的 System.Collections.IComparer 实现。- 或 - 若为 null，则使用每个元素的 System.IComparable 实现。</param>
public virtual void Sort(int index, int count, IComparer comparer)
{
T obj = default(T);
for (int i = index; i < count - index; i++)
{
for (int j = index; j <count -i-1; j++)
if (comparer.Compare(listT[j], listT[j + 1]) > 0)
{
obj = listT[j];
listT[j] = listT[j + 1];
listT[j + 1] = obj;
}
}
}
/// <summary>
/// 将 MyArrayList 的元素复制到新 泛型数组中。
/// </summary>
/// <returns> 泛型数组，它包含 MyArrayList 中元素的副本。</returns>
public  T[] ToArray()
{
return listT;
}
/// <summary>
///  将 MyArrayList 的元素复制到指定元素类型的新数组中。
/// </summary>
/// <param name="type">要创建并向其复制元素的目标数组的元素type。</param>
/// <returns>指定元素类型的数组，它包含 MyArrayList 中元素的副本。</returns>
public Array ToArray(Type type)
{
Array array=Array.CreateInstance(type, count);
array.CopyTo(listT, 0);
return array;

}

}