基本算法C#实现

/// <summary>
/// 序列号产生器（用闭包实现）。
/// </summary>
/// <returns></returns>
public static Func<string> SerialMaker(string prefix, int sequence)
{
Func<string> maker = delegate
{
var result = prefix + sequence.ToString();
sequence++;
return result;
};
return maker;
}

/// <summary>
/// 序列号产生器（用闭包实现）。
/// </summary>
/// <returns></returns>
public static Func<string> SerialMaker(string prefix, decimal sequence)
{
Func<string> maker = () =>
{
var result = prefix + sequence.ToString(CultureInfo.InvariantCulture);
sequence++;
return result;
};
return maker;
}

/// <summary>
/// 阶乘。
/// </summary>
/// <param name="i"></param>
/// <param name="a"></param>
/// <returns></returns>
public static int Factorial(int i, int a = 1)
{
if (i < 2)
{
return a;
}
return Factorial(i - 1, a * i);
}

/// <summary>
/// 阶乘。
/// </summary>
/// <param name="n"></param>
/// <returns></returns>
public static int Factorial(int n)
{
return n < 2 ? 1 : n * Factorial(n - 1);
}

/// <summary>
/// 汉诺塔。
/// </summary>
/// <param name="disc">圆盘个数。</param>
/// <param name="src">源柱子。</param>
/// <param name="aux">辅助柱子。</param>
/// <param name="dst">目标柱子。</param>
public static void Hanoi(int disc, string src, string aux, string dst)
{
if (disc > 0)
{
Hanoi(disc - 1, src, dst, aux);
Console.WriteLine("Move disc {0} from {1} to {2}",
disc, src, dst);
Hanoi(disc - 1, aux, src, dst);
}
}

/// <summary>
/// 自动解析字节单位。
/// </summary>
/// <param name="size">字节大小。</param>
/// <returns>返回带单位的字节大小字符串。</returns>
public static string ParseUnitOfByte(long size)
{
const int GB = 1024 * 1024 * 1024;
const int MB = 1024 * 1024;
const int KB = 1024;
if (size / (float)GB >= 0.6)
{
return string.Format("{0} GB", Math.Round(size / (float)GB, 2));
}
else if (size / (float)MB >= 0.6)
{
return string.Format("{0} MB", Math.Round(size / (float)MB, 2));
}
else if (size / (float)KB >= 0.6)
{
return string.Format("{0} KB", Math.Round(size / (float)KB, 2));
}
else
{
return string.Format("{0} Byte", size);
}
}

/// <summary>
/// 计算斐波纳契（Fibonacci）数列（最前面的两个数字是0和1）。
/// </summary>
/// <returns></returns>
public static Func<int, int> Fibonacci()
{
List<int> memory = new List<int> { 0, 1 };
return n => { return Fib(n, memory); };
}

/// <summary>
/// 利用递归函数计算斐波纳契（Fibonacci）数列，并用记忆技术优化递归过程。
/// </summary>
/// <param name="n">第n项</param>
/// <param name="memory">缓存</param>
/// <returns></returns>
private static int Fib(int n, List<int> memory)
{
int result;
if (n < memory.Count)
{
result = memory
;
}
else
{
result = Fib(n - 1, memory) + Fib(n - 2, memory);
memory.Add(result);
}
return result;
}

/// <summary>
/// 计算斐波纳契（Fibonacci）数列（最前面的两个数字是0和1）。
/// </summary>
/// <param name="n">第n项</param>
/// <returns></returns>
public static decimal Fibonacci(int n)
{
return n < 2 ? n : Fibonacci(n - 1) + Fibonacci(n - 2);
}

/// <summary>
/// 查找水仙花数（水仙花数是一个三位数，其中每一位数的立方之和等于这个三位数本身）。
/// </summary>
/// <returns></returns>
public static IEnumerable<int> FindDaffodils()
{
var list = new List<int>();
int x, y, z;
for (int i = 100; i <= 999; i++)
{
x = Math.DivRem(i, 100, out y);
y = Math.DivRem(y, 10, out z);
x = (int)Math.Pow(x, 3);
y = y * y * y;
z = (int)Math.Pow(z, 3);
if (x + y + z == i)
{
list.Add(i);
}
}
return list;
}

/// <summary>
/// 韩信点兵算法（韩信带兵不足百人，3人一行排列多一人，7人一行排列少2人，5人一行排列正好。
/// 请问韩信究竟带了多少兵？）。
/// </summary>
/// <returns></returns>
public static IEnumerable<int> HanxinDianBing()
{
var list = new List<int>();
int x, y, z;
for (int i = 1; i < 100; i++)
{
Math.DivRem(i, 3, out x);
Math.DivRem(i, 7, out y);
Math.DivRem(i, 5, out z);
if (x==1&&y==5&&z==0)
{
list.Add(i);
}
}
return list;
}

/// <summary>
/// 百钱百鸡算法（如何用100元钱买100只鸡，其中公鸡5元一只，母鸡3元一只，小鸡3只一元。）。
/// </summary>
/// <returns></returns>
public static IEnumerable<HundredChicken> CalculateHundredMoneyHundredChicken()
{
int i, j, c, r;
var list = new List<HundredChicken>();
for (i = 1; i < 20; i++)
{
for (j = 1; j < 32; j++)
{
c = 100 - i - j;
Math.DivRem(c, 3, out r);
if (r == 0 && (5 * i + 3 * j + c / 3) == 100)
{
list.Add(new HundredChicken { Cock = i, Hen = j, Chicken = c });
}
}
}
return list;
}

/// <summary>
/// 鸡
/// </summary>
public class HundredChicken
{
/// <summary>
/// 公鸡
/// </summary>
public int Cock { get; set; }

/// <summary>
/// 母鸡
/// </summary>
public int Hen { get; set; }

/// <summary>
/// 小鸡
/// </summary>
public int Chicken { get; set; }
}

/// <summary>
/// 冒泡排序（升级版）。
/// </summary>
/// <param name="data">数列</param>
public static void BubbleSortPlus(int[] data)
{
int temp, i = 0;
bool done = false;
while (i < data.Length - 1 && !done)
{
done = true;
for (int j = 0; j < data.Length - 1 - i; j++)
{
if (data[j] > data[j + 1])
{
done = false;
temp = data[j];
data[j] = data[j + 1];
data[j + 1] = temp;
}
}
i++;
}
}

/// <summary>
/// 冒泡排序。
/// </summary>
/// <param name="data">数列</param>
public static void BubbleSort(int[] data)
{
int temp;
for (int i = 0; i < data.Length - 1; i++)
{
for (int j = 0; j < data.Length - 1 - i; j++)
{
if (data[j] > data[j + 1])
{
temp = data[j];
data[j] = data[j + 1];
data[j + 1] = temp;
}
}
}
}

/// <summary>
/// 选择排序。
/// </summary>
/// <param name="data">数列</param>
public static void SelectionSort(int[] data)
{
int min,temp;
for (int i = 0; i < data.Length-1; i++)
{
min = i;
for (int j = i+1; j < data.Length; j++)
{
if (data[j]<data[min])
{
min = j;
}
}
temp = data[min];
data[min] = data[i];
data[i] = temp;
}
}

/// <summary>
/// 直接插入排序(对于“基本有序”的较小的数列效率较高)。
/// </summary>
/// <param name="data">数列</param>
public static void InsertionSort(int[] data)
{
int j,temp;
for (int i = 1; i < data.Length; i++)
{
temp = data[i];
j = i;
while (j>0&&data[j-1]>temp)
{
data[j] = data[j - 1];
j--;
}
data[j] = temp;     //if(j!=i) data[j] = temp;
}
}