熊晓杰 -- (暴熊 || kongbu0621 || kongbu0622) 的专栏

转自http://blog.vckbase.com/panic/archive/2005/03/20/3778.htmlA*寻路算法 GameDev.net作者： Patrick Lester译者：Panic 2005年3月18日译者序：很久以前就知道了A*算法，但是从未认真读过相关的文章，也没有看过代码，只是脑子里有个模糊的概念。这次决定从头开始，研究一下这个被人推崇备至的简单方

      Huffman 编码是应用很广泛的一种文本压缩编码方式。它的原理就是用不等长的编码来表示不同出现频率的字符。出现频率高的字符，就用比较短的编码来表示，出现频率低的，就是较长的编码来表示。      Huffman编码是一种前缀编码方式，所谓前缀编码，即，在编码集合中，没有任何一个编码是另一个编码的前缀。      使用Huffman编码的时候，一般要生成对应文本的编码集合（Hu

  templateclass AVLtree {public: AVLtree() {root = 0;} ~AVLtree() {Erase(root);} bool Search(const K& k, E& e) const; AVLtree& Insert(const E& e); AVLtree& Delete(const K& k, E& e)

      此AVLTree的实现 比上一篇的实现，从代码的观赏性和简洁性来看，更加棒，更加好看，不过效率上没有上一个实现快,初学者看这个实现更容易理解AVLTree两个关键性操作的实现templateclass AVLtree2{private: AVLNode* root; void LeftSingleRotate(AVLNode*& p

Dijkstra算法一种贪婪算法，可以解决图的单源最短路径问题void Dijkstra(int s, T d[], int p[]){ //寻找从顶点s出发的最短路径,在d中存储的是s->i的最短距离 //p中存储的是i的父节点 if (s n) throw OutOfBounds(); //路径可到达的顶点列表,这里可以用最小堆 Chain L;

kruskal算法也遵循贪婪原则，所以也属于贪婪算法，它用来生成一棵最小消耗生成树templatebool Kruskal(EdgeNode t[]){ //如果不连通则返回false //如果连通,则在t[0->n-2]中返回最小生成树 int n = Vertices(); int e = Edges(); InitializePos(); EdgeNo

归并排序采用的是分而治之的思想来进行的排序,效率确实不错分而治之的思想: 是将一个规模为n的问题分解为k个规模较小的子问题,这些子问题相互独立且与原问题类似或相同，递归的解这些子问题，然后将子问题的解合并得到原问题的解。templatevoid Merge(T c[], T d[], int l, int m, int r){ // 把 c[l:m]] 和 c[m:r] 归并到

分快速排序采用的是分而治之的思想来进行的排序，测试下来比归并排序 更快一点为什么更快一点？我的理解：是n个元素被分成 左, 中, 右三段,中段只有一个元素,左段中各个元素都小于等于中段元素，右端中各个元素都大于等于终端元素，因此左右两端中的元素集合不仅变成了可以独立处理的小集合，而且还不必对他们在进行各自的排序后的结果再进行合并, 而归并排序多了这步，所以快速排序比归并排序更快点 

图的点对最短路径算法：运用了动态规划的思想设图G中n 个顶点的编号为1到n。令c (i, j, k)表示从i 到j 的最短路径的长度，其中k 表示该路径中的最大顶点。因此，如果G中包含边i, j>，则c(i, j, 0) =边i, j> 的长度；若i= j ，则c(i,j, 0)=0；如果G中不包含边i, j>，则c (i, j, 0)= +∞。c(i, j, n) 则是从i 到j 的最短路径

prim算法也遵循贪婪原则，所以也属于贪婪算法，它用来生成一棵最小消耗生成树templatebool Prim(EdgeNode t[]){ //如果不连通则返回false //如果连通,则在t[0->n-2]中返回最小生成树 int n = Vertices(); bool *selected = new bool [n+1]; VertexNode1 *VN1 =

内存足够的情况下，寻找第k大或第k小的算法1:递归:templateT select(T a[], int l, int r, int k){ //在a[l:r]中选择第k小的元素 if (l >= r) return a[l]; int i = l, // 从左至右的游标 j = r + 1; // 从右至左的游标 T pivot =

最大值最小值查找算法 运用了分而治之的思想templatebool MinMax(T w[], int n, T& Min, T& Max){ //寻找w[0:n-1]中的最小和最大值 if (n < 1) return false; if (n == 1) { Min = Max = 0; return true; } // 对

 bool Topological(int v[]){ //计算有向图中顶点的拓扑次序 //如果找到了一个拓扑次序,则返回true, 此时, 在v[0->n-1]中记录拓扑次序 //如果不存在拓扑次序,则返回false int n = Vertices(); //计算入度 int *InDegree = new int [n+1]; Initialize

最小堆:templateclass MinHeap {public: MinHeap(int MinHeapSize = 10); ~MinHeap() {delete [] heap;} int Size() const {return CurrentSize;} T Min() {if (CurrentSize == 0) throw OutOfBoun

快速计算乘方的算法:如计算2^13，则传统做法需要进行12次乘法。//计算n^punsigned power(unsigned n,unsigned p){ for(int i = 0; i < p; i++) n *= n; return n;}  优化如下:把2*2的结果保存起来：4*4*4*4*4*4*2 再把4*4的结果保存起来：

递归算法:x->y    z 为临时塔void move(unsigned int x, unsigned int y){ printf("%d->%d,", x, y);}void TowersOfHanoi(int n, int x, int y, int z){ if (n > 0) { TowersOfHanoi(n-1, x,

   转自 http://www.embhelp.com/drew/algorithm/shortpath.htm    作者:Drew     据 Drew 所知最短路经算法现在重要的应用有计算机网络路由算法，机器人探路，交通路线导航，人工智能，游戏设计等等。美国火星探测器核心的寻路算法就是采用的D*（D Star）算法。    最短路经计算分静态最短路计算和动态最短路计算。  

你有两个玻璃球和一个１００层的大高楼，你想测出最低在那一层将玻璃球丢下，玻璃球便会破碎。用什么样的战术可以确保得到结果（i.e. 你的战术不能出现两个球都碎了，还找不到答案的情况），并且总共丢球的次数最小化？如果你有 N 个玻璃球，你的战术会是什么？ 在http://www.xycq.net/forum/thread-123745-1-6.html 看到比较巧妙的分析，受益匪浅，所以决定记

templateint BinarySearch(T a[], const T& x, int n){ int left = 0; int right = n - 1; while (left <= right) { int middle = (left + right)/2; if (x == a[middle]) return middle;

templatevoid InsertionSort(T a[], int n){ for (int i = 1; i < n; i++) { T t = a[i]; int j; for (j = i-1; j >= 0 && t < a[j]; j--) a[j+1] = a[j]; a[j+1] = t; }}

templatevoid Chain::BinSort(int range, int(*value)(T& x)){ int i, j; ChainNode **bottom, **top; //初始化箱子 bottom = new ChainNode* [range + 1]; top = new ChainNode* [range

bool ParenthesisMatched(char *expr){ Stack s(MaxLength); int j, length = strlen(expr); for (int i = 1; i <= length; i++) { if (expr[i - 1] == () s.Add(i); else if (expr[i -

int GCD(int m, int n){ int r1 = m, r2 = n, r3; for( ; ; ) { int q = r1 / r2; r3 = r1 - q * r2; if( r3 == 0) //根据算法r3必定越来越小，最后一定会等于0，所以不会死循环 break; r1 = r2; r2 = r3; }

 //========================================================在1000如此小的素数判断，在不考虑效率的情况下可以利用素数的定义来判断printf("2 ");//2是唯一一个偶素数 for( int a = 3; a <= 1000; a+=2) //步进为2, 因为只有奇数才有可能是素数（已排除了2） { bool b

template void HeapSort(T a[], int n){ //创建一个最大堆 MaxHeap H(1); H.Initialize(a,n,n); T x; for (int i = n-1; i >= 1; i--) { H.DeleteMax(x); a[i+1] = x; } H.Deactivate();

templatevoid Perm(T list[], int k, int m){ int i; if (k == m) { for (i = 0; i <= m; i++) cout << list[i]; cout << endl; } else { for (i = k; i <= m; i++) { Swap(

templatevoid SelectionSort(T a[], int n){ bool sorted = false; int swapcnt = 0; for (int size = n; !sorted && (size > 1); size--) { int pos = 0; sorted = true; for (int

templatebool Bubble(T a[], int n){ bool swapped = false; for (int i = 0; i < n - 1; i++) { if (a[i] > a[i+1]) { Swap(a[i], a[i + 1]); swapped = true; swapcnt_2++; }

 从10月14日b-树第1个版本，经过1天多的反复测试和修改，终于出了今天10月16日的最终版本，哈哈，b-树顺利拿下templateclass BMTree{public: BMTree() {root = 0; height = 0;} ~BMTree() { } bool Search(const K& k, E& e) const; BMTree& I