任务

静态数组的实现任务

实现目标：（1）实现一个静态数组

　　　　　（2）数组可以增，删，改，查；

　　　　　（3）可以输出数组信息；

实现过程：

（1）创建一个新的类，包含字段元素存储，元素个数；

（2）创建构造函数，分别是一个参数的构造函数与无参数的构造函数；

（3）实现增功能，允许按照下标添加；

（4）实现查询功能，按照下标查询，按照给出元素查询；

（5）实现删除功能，按照下标删除某个元素，按照给出元素删除，删除所有元素；

（7）实现修改功能，按照下标修改，按照给出元素修改；

（8）实现输出函数；

动态数组的实现任务

实现目标：（1）对静态数组容量进行修改，使得数组可以通过实际存储的数据多少进行改变。

实现过程：（1）在原有的静态数组上新增一个自动扩容缩容的方法

重点：

（1）无参构造函数的实现方法

1 public Array1() : this(10) { }
2         //与上面无参数函数等价
3         //public Array1()
4         //{
5         //    data = new int[10];
6         //    N = 0;
7         //}

（2）ToString()方法的重写

 1 /// <summary>
 2         /// 重写ToString方法否则不能正常输出
 3         /// </summary>
 4         /// <returns></returns>
 5         public override string ToString()
 6         {
 7             //实例化
 8             StringBuilder res = new StringBuilder();
 9             //重写格式1：输出数组元素个数以及长度
10             res.Append(string.Format("Array1:   count={0}    capacity={1}\n",N,data.Length));
11             res.Append('[');
12             //输出元素
13             for (int i = 0; i < N; i++)
14             {
15                 res.Append(data[i]);
16                 if (i!=N-1)
17                 {
18                     res.Append(',');
19                 }
20             }
21             res.Append(']'+"\n");
22             //返回
23             return res.ToString();
24         }
25     }

（3）动态数组扩容缩容实现方法1

 1         /// <summary>
 2         /// 扩容缩容数组
 3         /// </summary>
 4         /// <param name="newcapacity"></param>
 5         private void ResetCapacity(int newcapacity)
 6         {
 7             int[] newdata = new int[newcapacity];
 8             for (int i = 0; i < N; i++)
 9             {
10                 newdata[i] = data[i]; 
11             }
12             data = newdata;
13         }

完整代码：

  1 using System;
  2 using System.Collections.Generic;
  3 using System.Linq;
  4 using System.Text;
  5 using System.Threading.Tasks;
  6 
  7 namespace DataStructrue
  8 {
  9     class Array1
 10     {
 11         /// <summary>
 12         /// 数组的元素存储
 13         /// </summary>
 14         private int[] data;
 15         /// <summary>
 16         /// 数组元素数量
 17         /// </summary>
 18         private int N;
 19 
 20         public Array1(int capacity)
 21         {
 22             data = new int[capacity];
 23             N = 0;
 24         }
 25         public Array1() : this(10) { }
 26         //与上面无参数函数等价
 27         //public Array1()
 28         //{
 29         //    data = new int[10];
 30         //    N = 0;
 31         //}
 32         
 33         /// <summary>
 34         /// 在某位置添加新元素
 35         /// </summary>
 36         /// <param name="index"></param>
 37         /// <param name="d"></param>
 38         public void Add(int index,int d)
 39         {
 40             if (index>N || index <0)
 41             {
 42                 throw new ArgumentException("数组索引越界");
 43             }
 44             else if (N==data.Length)
 45             {
 46                 ResetCapacity(2*N);
 47             }
 48             for (int i = N; i >= index; i--)
 49             {
 50                 if (N != data.Length-1)
 51                 {
 52                     data[i + 1] = data[i];
 53                 }
 54             }
 55             data[index] = d;
 56             N++;
 57         }
 58         public void Addlast(int d)
 59         {
 60             Add(N, d);
 61         }
 62         /// <summary>
 63         /// 删除下标元素
 64         /// </summary>
 65         /// <param name="index"></param>
 66         public void RemoveAt(int index)
 67         {
 68             if (index > N || index < 0)
 69             {
 70                 throw new ArgumentException("数组索引越界");
 71             }
 72             for (int i = index; i < N; i++)
 73             {
 74                 data[i] = data[i + 1];
 75             }
 76             N--;
 77             if (N==(data.Length/4))
 78             {
 79                 ResetCapacity(data.Length / 2);
 80             }
 81             data[N] = default;
 82         }
 83         /// <summary>
 84         /// 删除特定元素
 85         /// </summary>
 86         /// <param name="d"></param>
 87         public void Remove(int d)
 88         {
 89             if (Find(d)!=-1)
 90             {
 91                 RemoveAt(Find(d));
 92             }
 93         }
 94         public void RemoveLast()
 95         {
 96             RemoveAt(N - 1);
 97         }
 98         /// <summary>
 99         /// 清空数组
100         /// </summary>
101         public void Clear()
102         {
103             for (int i = N-1; i >=0; i--)
104             {
105                 data[i] = default;
106                 N--;
107             }
108         }
109         /// <summary>
110         /// 查询特定元素
111         /// </summary>
112         /// <param name="d"></param>
113         /// <returns></returns>
114         public int Find(int d)
115         {
116             for (int i = 0; i < N; i++)
117             {
118                 if (data[i] == d)
119                 {
120                     return i;
121                 }
122             }
123             return -1;
124         }
125         /// <summary>
126         /// 查询是否包含元素
127         /// </summary>
128         /// <param name="d"></param>
129         /// <returns></returns>
130         public bool Contain(int d)
131         {
132             if (Find(d)==-1)
133             {
134                 return false;
135             }
136             return true;
137         }
138         /// <summary>
139         /// 修改元素
140         /// </summary>
141         /// <param name="index"></param>
142         /// <param name="d"></param>
143         public void Change(int index,int d)
144         {
145             if (index > N || index < 0)
146             {
147                 throw new ArgumentException("数组索引越界");
148             }
149             data[index] = d;
150         }
151         /// <summary>
152         /// 扩容缩容数组
153         /// </summary>
154         /// <param name="newcapacity"></param>
155         private void ResetCapacity(int newcapacity)
156         {
157             int[] newdata = new int[newcapacity];
158             for (int i = 0; i < N; i++)
159             {
160                 newdata[i] = data[i]; 
161             }
162             data = newdata;
163         }
164         /// <summary>
165         /// 重写ToString方法否则不能正常输出
166         /// </summary>
167         /// <returns></returns>
168         public override string ToString()
169         {
170             //实例化
171             StringBuilder res = new StringBuilder();
172             //重写格式1：输出数组元素个数以及长度
173             res.Append(string.Format("Array1:   count={0}    capacity={1}\n",N,data.Length));
174             res.Append('[');
175             //输出元素
176             for (int i = 0; i < N; i++)
177             {
178                 res.Append(data[i]);
179                 if (i!=N-1)
180                 {
181                     res.Append(',');
182                 }
183             }
184             res.Append(']'+"\n");
185             //返回
186             return res.ToString();
187         }
188     }
189 }