基本算法C#实现

  1         /// <summary>
  2         /// 序列号产生器（用闭包实现）。
  3         /// </summary>
  4         /// <returns></returns>
  5         public static Func<string> SerialMaker(string prefix, int sequence)
  6         {
  7             Func<string> maker = delegate
  8             {
  9                 var result = prefix + sequence.ToString();
 10                 sequence++;
 11                 return result;
 12             };
 13             return maker;
 14         }
 15 
 16         /// <summary>
 17         /// 序列号产生器（用闭包实现）。
 18         /// </summary>
 19         /// <returns></returns>
 20         public static Func<string> SerialMaker(string prefix, decimal sequence)
 21         {
 22             Func<string> maker = () =>
 23             {
 24                 var result = prefix + sequence.ToString(CultureInfo.InvariantCulture);
 25                 sequence++;
 26                 return result;
 27             };
 28             return maker;
 29         }
 30 
 31         /// <summary>
 32         /// 阶乘。
 33         /// </summary>
 34         /// <param name="i"></param>
 35         /// <param name="a"></param>
 36         /// <returns></returns>
 37         public static int Factorial(int i, int a = 1)
 38         {
 39             if (i < 2)
 40             {
 41                 return a;
 42             }
 43             return Factorial(i - 1, a * i);
 44         }
 45 
 46         /// <summary>
 47         /// 阶乘。
 48         /// </summary>
 49         /// <param name="n"></param>
 50         /// <returns></returns>
 51         public static int Factorial(int n)
 52         {
 53             return n < 2 ? 1 : n * Factorial(n - 1);
 54         }
 55 
 56         /// <summary>
 57         /// 汉诺塔。
 58         /// </summary>
 59         /// <param name="disc">圆盘个数。</param>
 60         /// <param name="src">源柱子。</param>
 61         /// <param name="aux">辅助柱子。</param>
 62         /// <param name="dst">目标柱子。</param>
 63         public static void Hanoi(int disc, string src, string aux, string dst)
 64         {
 65             if (disc > 0)
 66             {
 67                 Hanoi(disc - 1, src, dst, aux);
 68                 Console.WriteLine("Move disc {0} from {1} to {2}",
 69                     disc, src, dst);
 70                 Hanoi(disc - 1, aux, src, dst);
 71             }
 72         }
 73        
 74         /// <summary>
 75         /// 自动解析字节单位。
 76         /// </summary>
 77         /// <param name="size">字节大小。</param>
 78         /// <returns>返回带单位的字节大小字符串。</returns>
 79         public static string ParseUnitOfByte(long size)
 80         {
 81             const int GB = 1024 * 1024 * 1024;
 82             const int MB = 1024 * 1024;
 83             const int KB = 1024;
 84             if (size / (float)GB >= 0.6)
 85             {
 86                 return string.Format("{0} GB", Math.Round(size / (float)GB, 2));
 87             }
 88             else if (size / (float)MB >= 0.6)
 89             {
 90                 return string.Format("{0} MB", Math.Round(size / (float)MB, 2));
 91             }
 92             else if (size / (float)KB >= 0.6)
 93             {
 94                 return string.Format("{0} KB", Math.Round(size / (float)KB, 2));
 95             }
 96             else
 97             {
 98                 return string.Format("{0} Byte", size);
 99             }
100         }
101 
102         /// <summary>
103         /// 计算斐波纳契（Fibonacci）数列（最前面的两个数字是0和1）。
104         /// </summary>
105         /// <returns></returns>
106         public static Func<int, int> Fibonacci()
107         {
108             List<int> memory = new List<int> { 0, 1 };
109             return n => { return Fib(n, memory); };
110         }
111 
112         /// <summary>
113         /// 利用递归函数计算斐波纳契（Fibonacci）数列，并用记忆技术优化递归过程。
114         /// </summary>
115         /// <param name="n">第n项</param>
116         /// <param name="memory">缓存</param>
117         /// <returns></returns>
118         private static int Fib(int n, List<int> memory)
119         {
120             int result;
121             if (n < memory.Count)
122             {
123                 result = memory[n];
124             }
125             else
126             {
127                 result = Fib(n - 1, memory) + Fib(n - 2, memory);
128                 memory.Add(result);
129             }
130             return result;
131         }
132 
133         /// <summary>
134         /// 计算斐波纳契（Fibonacci）数列（最前面的两个数字是0和1）。
135         /// </summary>
136         /// <param name="n">第n项</param>
137         /// <returns></returns>
138         public static decimal Fibonacci(int n)
139         {
140             return n < 2 ? n : Fibonacci(n - 1) + Fibonacci(n - 2);
141         }
142 
143         /// <summary>
144         /// 查找水仙花数（水仙花数是一个三位数，其中每一位数的立方之和等于这个三位数本身）。
145         /// </summary>
146         /// <returns></returns>
147         public static IEnumerable<int> FindDaffodils()
148         {
149             var list = new List<int>();
150             int x, y, z;
151             for (int i = 100; i <= 999; i++)
152             {
153                 x = Math.DivRem(i, 100, out y);
154                 y = Math.DivRem(y, 10, out z);
155                 x = (int)Math.Pow(x, 3);
156                 y = y * y * y;
157                 z = (int)Math.Pow(z, 3);
158                 if (x + y + z == i)
159                 {
160                     list.Add(i);
161                 }
162             }
163             return list;
164         }
165 
166         /// <summary>
167         /// 韩信点兵算法（韩信带兵不足百人，3人一行排列多一人，7人一行排列少2人，5人一行排列正好。
168         /// 请问韩信究竟带了多少兵？）。
169         /// </summary>
170         /// <returns></returns>
171         public static IEnumerable<int> HanxinDianBing()
172         {
173             var list = new List<int>();
174             int x, y, z;
175             for (int i = 1; i < 100; i++)
176             {
177                 Math.DivRem(i, 3, out x);
178                 Math.DivRem(i, 7, out y);
179                 Math.DivRem(i, 5, out z);
180                 if (x==1&&y==5&&z==0)
181                 {
182                     list.Add(i);
183                 }
184             }
185             return list;
186         }
187 
188         /// <summary>
189         /// 百钱百鸡算法（如何用100元钱买100只鸡，其中公鸡5元一只，母鸡3元一只，小鸡3只一元。）。
190         /// </summary>
191         /// <returns></returns>
192         public static IEnumerable<HundredChicken> CalculateHundredMoneyHundredChicken()
193         {
194             int i, j, c, r;
195             var list = new List<HundredChicken>();
196             for (i = 1; i < 20; i++)
197             {
198                 for (j = 1; j < 32; j++)
199                 {
200                     c = 100 - i - j;
201                     Math.DivRem(c, 3, out r);
202                     if (r == 0 && (5 * i + 3 * j + c / 3) == 100)
203                     {
204                         list.Add(new HundredChicken { Cock = i, Hen = j, Chicken = c });
205                     }
206                 }
207             }
208             return list;
209         }
210 
211         /// <summary>
212         /// 鸡
213         /// </summary>
214         public class HundredChicken 
215         {
216             /// <summary>
217             /// 公鸡
218             /// </summary>
219             public int Cock { get; set; }
220 
221             /// <summary>
222             /// 母鸡
223             /// </summary>
224             public int Hen { get; set; }
225 
226             /// <summary>
227             /// 小鸡
228             /// </summary>
229             public int Chicken { get; set; }
230         }
231 
232         /// <summary>
233         /// 冒泡排序（升级版）。
234         /// </summary>
235         /// <param name="data">数列</param>
236         public static void BubbleSortPlus(int[] data)
237         {
238             int temp, i = 0;
239             bool done = false;
240             while (i < data.Length - 1 && !done)
241             {
242                 done = true;
243                 for (int j = 0; j < data.Length - 1 - i; j++)
244                 {
245                     if (data[j] > data[j + 1])
246                     {
247                         done = false;
248                         temp = data[j];
249                         data[j] = data[j + 1];
250                         data[j + 1] = temp;
251                     }
252                 }
253                 i++;
254             }
255         }
256 
257         /// <summary>
258         /// 冒泡排序。
259         /// </summary>
260         /// <param name="data">数列</param>
261         public static void BubbleSort(int[] data)
262         {
263             int temp;
264             for (int i = 0; i < data.Length - 1; i++)
265             {
266                 for (int j = 0; j < data.Length - 1 - i; j++)
267                 {
268                     if (data[j] > data[j + 1])
269                     {
270                         temp = data[j];
271                         data[j] = data[j + 1];
272                         data[j + 1] = temp;
273                     }
274                 }
275             }
276         }
277 
278         /// <summary>
279         /// 选择排序。
280         /// </summary>
281         /// <param name="data">数列</param>
282         public static void SelectionSort(int[] data)
283         {
284             int min,temp;
285             for (int i = 0; i < data.Length-1; i++)
286             {
287                 min = i;
288                 for (int j = i+1; j < data.Length; j++)
289                 {
290                     if (data[j]<data[min])
291                     {
292                         min = j;
293                     }
294                 }
295                 temp = data[min];
296                 data[min] = data[i];
297                 data[i] = temp;
298             }
299         }
300 
301         /// <summary>
302         /// 直接插入排序(对于“基本有序”的较小的数列效率较高)。
303         /// </summary>
304         /// <param name="data">数列</param>
305         public static void InsertionSort(int[] data)
306         {
307             int j,temp;
308             for (int i = 1; i < data.Length; i++)
309             {
310                 temp = data[i];
311                 j = i;
312                 while (j>0&&data[j-1]>temp)
313                 {
314                     data[j] = data[j - 1];
315                     j--;
316                 }
317                 data[j] = temp;     //if(j!=i) data[j] = temp; 
318             }
319         }

 

转载于:https://www.cnblogs.com/zhijianblogs/p/5326263.html