静态数组和动态数组

1. using System;
   using System.Collections.Generic;
   using System.Linq;
   using System.Text;
   using System.Threading.Tasks;
   
   namespace DataStructure.Review
   {
       public class Array2<T>
       {
           //静态数组
           public T[] data;
           //数组当前长度
           public int N;
   
           //构造函数设置容量
           public Array2(int capacity)
           {
               data = new T[capacity];
               this.N = 0;
           }
   
           public Array2():this(10)
           {
           }
   
   
           //数组当前存在的元素个数
           public int Count
           {
               get { return this.N; }
           }
   
           //数组容量
           public int Capacity
           {
               get { return this.data.Length; }
           }
   
   
           public void Add(int index, T e)
           {
               if(index<0||index>N)
               {
                   throw new Exception("数组越界");
               }
   
               //如果数组当前存储的元素达到动态数组的容量，开启扩容。注意：不是index=capacity
               if (N==this.Capacity)
               {
                   //throw new Exception("数组容量已满");
   
                   //扩容
                   ResetCapacity(data.Length*2);
               }
   
               for (int i = N-1; i >=index; i--)
               {
                   data[i + 1] = data[i];
               }
               data[index] = e;
               N++;
           }
   
           public void AddFirst(T e)
           {
               Add(0,e);
           }
   
           public void AddLast(T e)
           {
               Add(N, e);
           }
   
   
           public T RemoveAt(int index)
           {
               if (index < 0 || index >= N)
               {
                   throw new Exception("数组越界");
               }
               T curE = data[index];
               //当前索引后面的元素前移
               for (int i = index+1; i < N; i++)
               {
                   data[i - 1] = data[i];
               }
   
               /**
                * N--;
               data[N] = default(T);
               可以互换，但是要注意data[]的索引
                */
               N--;
   
               //移动完成后，重置最后一个元素
               data[N] = default(T);
   
               if (N==data.Length/4)
               {
                   ResetCapacity(data.Length/2);
               }
               return curE;
   
           }
   
           public void RemoveFirst()
           {
               RemoveAt(0);
           }
   
           public void RemoveLast()
           {
               RemoveAt(N-1);
           }
   
   
           public void Set(int index, T e)
           {
               if (index < 0 || index >= N)
               {
                   throw new Exception("数组越界");
               }
               data[index] = e;
           }
   
           public T Get(int index)
           {
               if (index < 0 || index >= N)
               {
                   throw new Exception("数组越界");
               }
               return data[index];
           }
   
           public T GetFirst()
           {
               return data[0];
           }
   
           public T GetLast()
           {
               return data[N-1];
           }
   
           public bool Contains(int e)
           {
               for (int i = 0; i < N; i++)
               {
                   if (data[i].Equals(e))
                   {
                       return true;
                   }
               }
               return false;
           }
   
           public int IndexOf(int e)
           {
               for (int i = 0; i < N; i++)
               {
                   if (data[i].Equals(e))
                   {
                       return i;
                   }
               }
               return -1;
           }
   
           //重置容量
           private void ResetCapacity(int capacity)
           {
               T[] newData = new T[capacity];
               for (int i = 0; i < N; i++)
               {
                   newData[i] = data[i];
               }
   
               data = newData;
           }
   
           
           public override string ToString()
           {
               StringBuilder sb = new StringBuilder();
               sb.Append($"当前数组的容量是{this.data.Length},元素个数是{this.N}……数组元素依次是：");
               sb.Append("[");
               for (int i = 0; i < this.N; i++)
               {
                   if (i < this.N - 1)
                   {
                       sb.Append(data[i] + "，");
                   }
                   else
                   {
                       sb.Append(data[N-1]);
                   }
               }
               
               sb.Append("]");
               return sb.ToString();
           }
       }
   }
   

   静态数组

特点：可以通过索引可以访问任意元素；

缺点：在初始化的时候就需要知道元素的数量；

 

1. 动态数组

可以解决静态数组的缺点。

但是空间还是不能充分利用。