//where T:IComparable 可比较的接口
class MyList<T> where T:IComparable
{
/// <summary>
/// 用来存储元素的数组
/// </summary>
private T[] array;
/// <summary>
/// 当前添加元素的个数
/// </summary>
private int count = 0;
/// <summary>
/// 有参的构造方法
/// </summary>
/// <param name="size"></param>
public MyList(int size)
{
if (size >= 0)
{
//设置数组大小
array = new T[size];
}
}
/// <summary>
/// 无参的构造方法
/// </summary>
public MyList()
{
//MyList(0);
//或者 默认创建空的数组
array = new T[0];
}
/// <summary>
/// 获取容量的大小
/// </summary>
/// <returns>返回容量大小（int类型）</returns>
public int Capacity { get{ return array.Length; } }
/// <summary>
/// 标识位，用来标识当前元素的个数
/// </summary>
/// <returns>返回当前添加的元素的个数</returns>
public int Count { get{ return count; } }
/// <summary>
/// 添加
/// </summary>
/// <param name="item">添加的元素</param>
public void Add(T item)
{
//判断元素个数和列表容量是否一样大，一样大的时候需要创建新的数组
if (Capacity == Count)
{
//当数组长度为0的时候，创建一个长度是4的数组
if (Capacity ==0)
{
array = new T[4];
}
else
{
//不是0的时候不用管，创建一个长度为之前的2倍的数组
var newArray = new T[Capacity * 2];
//把原来数组的元素复制到新的数组中
Array.Copy(array,newArray,Count);
//把新数组的引用给旧数组，可以把旧数组引用删除，换成新的引用。旧引用被GC机制回收
array = newArray;
}
}
//添加数据
array[Count] = item;
count++; //元素个数自增
}
/// <summary>
/// 访问
/// </summary>
/// <param name="index">索引</param>
/// <returns>返回索引对应的元素</returns>
public T Getitem(int index)
{
//索引范围
if (index >= 0 && index < count)
{
return array[index];
}
else
{
//抛出异常
throw new Exception("索引超出范围");
}
}
/// <summary>
/// 索引器
/// </summary>
/// <param name="index">索引</param>
/// <returns>/返回Getitem方法（返回索引对应的元素）</returns>
public T this[int index]
{
get { return Getitem(index); }
//通过索引设置数组索引元素的值
set
{
//索引范围
if (index >= 0 && index < count )
{
array[index] = value;
}
else
{
//抛出异常
throw new Exception("超出索引的范围");
}
}
}
/// <summary>
/// 插入
/// </summary>
/// <param name="index">索引</param>
/// <param name="item">元素</param>
public void Insert(int index, T item)
{
//索引范围
if (index >= 0 && index < count)
{
//判断元素个数和列表容量是否一样大，一样大的时候需要创建新的数组（容量不够，就扩容）
if (Capacity == Count)
{
//创建一个长度为之前的2倍的数组
var newArray = new T[Capacity * 2];
//把原来数组的元素复制到新的数组中
Array.Copy(array, newArray, Count);
//把新数组的引用给旧数组，可以把旧数组引用删除，换成新的引用。旧引用被GC机制回收
array = newArray;
}
//把插入位置的元素和插入位置以后的元素向后移动一个单位，索引加 1
for (int i = Count - 1; i >= index; i--)
{
array[i + 1] = array[i];//向后移动
}
array[index] = item;//插入
count++;//自增数量
}
else
{
throw new Exception("超出索引范围");
}
}
/// <summary>
/// 移除
/// </summary>
/// <param name="index">索引</param>
public void RemoveAt(int index)
{
if (index >= 0 && index < count)
{
// 插入位置以后的元素向前移动一个单位，索引加 - 1，覆盖需要移除的元素
for (int i = index + 1; i < count; i++)
{
array[i - 1] = array[i];
}
count--;//元素个数自减
}
else
{
throw new Exception("索引超出范围");
}
}
/// <summary>
/// 从前往后查找
/// </summary>
/// <param name="item">元素</param>
/// <returns>返回对应索引</returns>
public int IndexOf(T item)
{
for (int i = 0; i < count; i++)
{
//两个泛型之间用无法用双等号，用Equals（确定指定的对象是否等于当前对象）
if (array[i].Equals(item))
{
return i;//找到就返回对应索引
}
}
return -1;//没有返回-1
}
/// <summary>
/// 从后往前查找
/// </summary>
/// <param name="item">元素</param>
/// <returns>返回对应索引</returns>
public int LastIndexOf(T item)
{
for (int i = count - 1; i >= 0; i--)
{
if (array[i].Equals(item))
{
return i;//找到就返回对应索引
}
}
return -1;//没有返回-1
}
/// <summary>
/// 从小到大排序
/// </summary>
public void Sort()
{
//冒泡排序
for (int j = 0; j < count - 1; j++)
{
for (int i = 0; i < count - 1 - j; i++)
{
if (array[i].CompareTo(array[i + 1]) > 0)
{
var temp = array[i];
array[i] = array[i + 1];
array[i + 1] = temp;
}
}
}
}
}
网友评论