Abrahaml的博客

/// /// 插值查找，是对二分法查找的优化 /// 二分法: mid = low + 1/2 (high - low) /// 插值查找:mid = low + ((point-array[low])/(array[high]-array[low]))(high-low) /// 插值优化了mid，使之更接近查找数值在有序序列的实际位置 /// /// /// /// /// /// private static int InterpolationSearch(int[] arr, int

/// /// 二分法查找，非递归方法实现,二分查找的条件是原数组有序 /// 没有找到，返回-1；找到了，则返回索引 /// /// /// /// /// private static int BinarySearch(int[] arr, int low, int height, int value) { if (arr == null || arr.Length == 0 || low >= height) { return -1; } int hi = height - 1; i

/// /// 顺序查找 /// private static int SequenceSearch(int[] arr, int value) { int length = arr.Length; for (int i = 0; i < length; i++) { if(arr[i] == value) { return i; } } return -1; }

protected void Page_Load(object sender, EventArgs e) { createCalendar(DateTime.Now.Year, DateTime.Now.Month); } private void createCalendar(int year, int month) { int days = DateTime.DaysInMonth(year, month);//得到当月的天数 DateTime dt = new DateTime(year, month

class Matrix { /// <summary> /// 矩阵的转置 /// </summary> /// <param name= "iMatrix "> </param> public static double[,] Transpose(double[,] iMatrix) { int row = iMatrix.GetLength(0);

/// /// 桶排序 /// 类似于哈希表的拉链法，定义一个映射函数，将值放入对应的桶中 /// 最坏时间情况：全部分到一个桶中O(N^2)，一般情况为O(NlogN) /// 最好时间情况：每个桶中只有一个数据时最优O(N) /// int bucketNum = arr.Length; /// 映射函数：int bucketIndex = arr[i] * bucketNum / (max + 1); /// /// /// 数组的最大值 /// private static int[] Bu

/// /// 归并排序 List版本 /// 将两个（或两个以上）有序表合并成一个新的有序表 /// public static List MergeSort(List list) { int count = list.Count; if (count <= 1) { return list; } int mid = count / 2; List left = new List();//定义左侧List List right = new List();//定义右侧List //

/// /// 归并排序 递归版本 /// 将两个（或两个以上）有序表合并成一个新的有序表 /// private static void MergeSort(int[] arr, int length) { int[] temp = new int[length]; MergeInternalSort(arr, 0, length, temp); } private static void MergeInternalSort(int[] arr, int first, int last, in

快速排序在实际应用中会面对大量具有重复元素的数组。相比原生的快排，有巨大的改进潜力。（从O(nlgn)提升到O(n)） E.W.Dijlstra（对，就是Dijkstra最短路径算法的发明者）提出的算法是： 对于每次切分：从数组的左边到右边遍历一次，维护三个指针，其中lt指针使得元素（arr[0]-arr[lt-1]）的值均小于切分元素；gt指针使得元素（arr[gt+1]-arr[N-1]）的值均大于切分元素；i指针使得元素（arr[lt]-arr[i-1]）的值均等于切分元素，（arr[i]-arr[g

//递归算法 static int DiGui(int n) { int sum = 0; if (0 == n) { return 1; } else { sum = n * DiGui(n-1); } return sum; }

/// /// 变异操作; /// private static void VariationOperate() { int rand = random.Next(0, 50); Console.WriteLine("变异的rand " + rand); if (rand < 5)//5/50 = 0.1的概率进行变异;rand<5; { Console.WriteLine(“开始变异”); int col = random.Next(0, 6); int row = random.Next

/// /// 交叉操作; /// private static void CrossOperate() { /** bit[0]~bit[5] fit * 4 000 110 12 * 3 001 010 9 * child1 000 010 14 * child2 001 110 5 */ int rand1 = random.Next(0, 6);//0-5; int rand2

/// /// 更新下一代; /// 基于轮盘选择选择方法，进行基因型的选择; /// private static void UpdateNext() { // 获取总的fit; double totalFitValue = 0; for (int i = 0; i < chromosomes.Count; i++) { //适应度为负数的取0; if (chromosomes[i].fitValue <= 0) { totalFitValue += 0; } else { totalFi

C#算法时间测试类Timing： public class Timing { TimeSpan startingtime; TimeSpan duration; public Timing() { startingtime = new TimeSpan(0); duration = new TimeSpan(0); } public void stoptime() { d

private List calcConvexHull(List list) { List resPoint = new List(); //查找最小坐标点 int minIndex = 0; for (int i = 1; i < list.Count; i++) { if (list[i].Y < list[minIndex].Y) { minIndex = i; } } Point minPoint = list[minIndex]; resPoint.Add(list[minIndex]

using System; using System.Collections.Generic; class program { static void Mian(string[] args) { int N =1000; List<int> primes = new List<int>(); primes.Add(2); Console.Write(2+" "); for(int

static void Mu() { string t = string.Empty; for (int i = 1; i < 10; i++) { for (int j = 1; j <= i; j++) { t = string.Format("{0}*{1}={2} “, j, i, (j * i)); Console.Write(t); //if (j * i < 82) // Console.Write(” “); if (i == j) Console.Write(”

using System; class Program { static in F(int i) { if(i<=0) return 0; else if(i>0 && i<=2) return 1; else return F(i-1) + F(i-2); } static void Main(string[] args) { int n = F(30); Console.WriteLine(n.ToString());

for (int a = 0; a < 10; a++) { for (int b = 0; b < 10; b++) { for (int c = 0; c < 10; c++) { if ((120560 + a + b * 1000) * 123 == 15404987 + c * 10000) { Console.WriteLine(a); Console.WriteLine(b); Console.WriteLine©; } } } } Console.Read();

/* 堆排序是一种选择排序，时间复杂度为O(nlog2n)。 堆排序的特点是： 在排序过程中，将待排序数组看成是一棵完全二叉树的顺序存储结构， 利用完全二叉树中父结点和子结点之间的内在关系，在当前无序区中选择关键字最大（或最小）的记录。 基本思想 1.将待排序数组调整为一个大根堆。大根堆的堆顶元素就是这个堆中最大的元素。 2.将大根堆的堆顶元素和无序区最后一个元素交换，并将无序区最后一个位置列入有序区，然后将新的无序区调整为大根堆。 3.重复操作，直到无序区消失为止。 初始时，整个数组为无序区。每一次