数组的进一步使用

数组是数据结构中最基本的结构形式，它是一种顺序式的结构，存储的是同一类型的数据。每个数组元素都拥有下标（index）和元素值（value），下标方便存取数据，而元素值就是被存储的数据。

数组使用静态的内存空间配置方式。这也是数组的一个很不方便的地方，在经常需要重新分配数据的存储空间的应用上，往往使用数组就显得非常影响效率；而且，对数组的添加、删除、排序的操作也是比较麻烦以及低效的。

在.net里提供了一种ArrayList的结构，在过去很长一段时间里，我经常会在需要使用集合对象的时候想到它（主要是受早先starter kits的影响），但是ArrayList还是由数组构成的，虽然它在添加元素，删除元素等方面比数组方便了，但是从效率上讲，毕竟它还是基于数组的结构。所谓换汤不换药。

其实，今天我不是想来说数组怎么怎么不好的，而是发挥数组的一些优点，来作一些原本相对复杂的事情，比如，当我们需要计算一个阶乘，而计算结果又超出了我们的数据类型所能存储的范围。

目的：
设计一个可以容纳40位数字的求n!的程序。

思路：
首先，明确我们要解决的问题，在.net的数据结构中，整形数据类型的最大范围是-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807（0 到 18,446,744,073,709,551,615），而当我们计算的这个结果需要有40位，就没有适合的数据结构来存储这个数据。这个时候我们可以借助数组，预先声明一个大小为40的数组，负责存储每一个位数上的整数。
接下来，就是程序设计的思路，聚个例子作为示范，假如我们要计算5!：

第一步：1!
数组内容

4	3	2	1
0	0	0	1

第二步：2!
数组内容

4	3	2	1
0	0	0	2*1

第三步：3!
数组内容

4	3	2	1
0	0	0	2*3

第二步：4!
数组内容

4	3	2	1
0	0	0	6*4

第二步：2!
数组内容

4	3	2	1
0	0	2*5	4*5

很明显，我们需要做的就是对数组的每一个元素进行累积，超过10以后向前进一位。

程序源码：

1usingSystem;
2
3namespaceDsPractice.Array.Factorial
4{
5/**////<summary>
6///利用数组的方式求解指定数字的阶乘。
7///</summary>
8classDemo
9{
10/**////<summary>
11///应用程序的主入口点。
12///</summary>
13[STAThread]
14staticvoidMain(string[]args)
15{
16DoCalculate();
17}
18
19publicstaticvoidDoCalculate()
20{
21//选择算法
22inttype=newNumberReader("Please choose an algorithm: /r/n1. Type A;/r/n2. Type B.",1,2).GetNumber();
23
24//获取要计算的数字
25intnumber=newNumberReader("Please input a number to calculate factorial:").GetNumber();
26
27//获得存放计算结果的数组的长度
28intlength=newNumberReader("Please input a number of array digit:").GetNumber();
29
30//创建一个阶乘计算对象
31Factorialfactorial=newFactorial(number,length);
32
33//计算并显示结果
34factorial.ShowResult(type);
35
36//提示用户继续或结束
37intres=newNumberReader("Do you wannar try again?/r/n1. Yes;/r/n2. No.",1,2).GetNumber();
38
39//如果继续执行，则返回重新调用
40if(res==1)
41{
42DoCalculate();
43}
44}
45
46publicclassNumberReader
47{
48privateint_min=-999;
49
50privateint_max=999;
51
52privatestring_strNumber;
53
54publicNumberReader(stringtodo)
55{
56//提示输入数字
57Console.WriteLine(todo);
58//获取数字字符串
59_strNumber=Console.ReadLine();
60}
61
62publicNumberReader(stringtodo,intmin,intmax):this(todo)
63{
64this._max=max;
65this._min=min;
66}
67
68publicintGetNumber()
69{
70intnumber=0;
71
72try
73{
74number=int.Parse(this._strNumber);
75
76if(number>this._max||number<this._min)
77{
78thrownewException();
79}
80}
81catch(System.FormatExceptionformatEx)
82{
83number=newNumberReader("Input format error! Please input again: ").GetNumber();
84}
85catch(System.Exceptionex)
86{
87number=newNumberReader("Input error! Please input again: ").GetNumber();
88}
89
90returnnumber;
91}
92}
93
94publicclassFactorial
95{
96//要计算的数字
97privateint_number=0;
98
99//结果的位数
100privateint_digit=1;
101
102//存放结果的数组
103privateint[]_data=null;
104
105//复杂度标记
106privateint_complex=0;
107
108publicFactorial(intnumber):this(number,40)
109{}
110
111publicFactorial(intnumber,intdigit)
112{
113this._number=number;
114this._data=newint[digit];
115this._data[0]=1;
116}
117
118privatevoidCalculateA()
119{
120try
121{
122for(inti=1;i<=this._number;i++)
123{
124intdigit;
125for(digit=this._data.GetLength(0);digit>0;digit--)
126{
127this._complex++;
128this._data[digit-1]=this._data[digit-1]*i;
129
130if(this._data[digit-1]>=10)
131{
132for(intj=digit;j<this._data.GetLength(0);j++)
133{
134this._complex++;
135this._data[j]+=this._data[j-1]/10;
136
137this._complex++;
138this._data[j-1]=this._data[j-1]%10;
139}
140}
141}
142}
143}
144catch
145{
146return;
147}
148}
149
150privatevoidCalculateB()
151{
152//初始位数为个位，也就是1
153try
154{
155for(inti=1;i<=this._number;i++)
156{
157//数组元素的运算
158for(intj=1;j<=this._digit;j++)
159{
160this._complex++;
161this._data[j-1]*=i;
162}
163//从个位开始，根据每一位的数字判断是否需要进位
164for(intj=1;j<=this._digit;j++)
165{
166//如果当前位大于等于10，则依次向前进一位
167if(this._data[j-1]>=10)
168{
169//从当前位开始，根据每一位的数字进行进位
170for(intm=j;m<=this._digit;m++)
171{
172if(this._data[this._digit-1]>=10)
173{
174this._complex++;
175this._digit++;
176}
177
178this._complex++;
179this._data[m]+=this._data[m-1]/10;
180
181this._complex++;
182this._data[m-1]=this._data[m-1]%10;
183}
184}
185}
186}
187}
188catch
189{
190return;
191}
192}
193
194publicvoidShowResult(inttype)
195{
196Console.Write("Resultis");
197switch(type)
198{
199case1:
200this.CalculateA();
201
202for(inti=this._data.GetLength(0)-1;i>=0;i--)
203{
204Console.Write(this._data[i].ToString());
205}
206
207break;
208default:
209this.CalculateB();
210
211for(inti=this._digit-1;i>=0;i--)
212{
213Console.Write(this._data[i].ToString());
214}
215
216break;
217}
218Console.WriteLine();
219Console.WriteLine("Codecomplexis"+this._complex.ToString());
220}
221}
222}
223}
224

以上源码提供了两种算法，各自的复杂度都可以很清楚的查看到，如果有兴趣的朋友可以再提供一些其他的更有效的算法。