我有一个梦想

计数排序虽然时间复杂度为线性,但是该排序有很多使用限制,请自行百度#include#include#include#include#includeusing namespace std;class solution{public: solution(vector &vec):   //构造函数,传入一个待排序数组     base(vec),     n(vec.siz

1.Bloom filter 适用范围：可以用来实现数据字典，进行数据的判重，或者集合求交集 基本原理及要点： 对于原理来说很简单，位数组+k个独立hash函数。将hash函数对应的值的位数组置1，查找时如果发现所有hash函数对应位都是1说明存在，很明显这个过程并不保证查找的结果是100%正确的。同时也不支持删除一个已经插入的关键字，因为该关键字对应的位会牵动到其他的关键字。

//将有二个有序数列a[first...mid]和a[mid...last]合并。 void mergearray(int a[], int first, int mid, int last, int temp[]) { int i = first, j = mid + 1; int m = mid, n = last;

sunday算法就不详细介绍了,网上有很多详解,直接上代码#include #include #include #define MAX 256   //所有字符static int move[MAX]; //每次的移动距离typedef struct{     //存储着所有匹配的下标,可能文本串含有多个目标串,全部找出来并记录位置 int  arr[64];

int BinarySort(int arr[],int n,int key){ if(arr==NULL||n<1) return -1; int left=0,right=n-1; while(left<=right){ int mid=left+(right-left)/2; if(arr[mid]<ke

在数组中找到第k大的元素您在真实的面试中是否遇到过这个题？ Yes样例给出数组[9,3,2,4,8]，第三大的元素是4给出数组 [1,2,3,4,5]，第一大的元素是5，第二大的元素是4，第三大的元素是3，以此类推class Solution {public: void insert(vector &heap,int e){

直接插入排序(Insertion Sort)的基本思想是：每次将一个待排序的记录，按其关键字大小插入到前面已经排好序的子序列中的适当位置，直到全部记录插入完成为止。 设数组为a[0…n-1]。1.      初始时，a[0]自成1个有序区，无序区为a[1..n-1]。令i=12.      将a[i]并入当前的有序区a[0…i-1]中形成a[0…i]的有序区间。3.

快速排序称为分治法，但分治法这三个字显然无法很好的概括快速排序的全部步骤。因此我的对快速排序作了进一步的说明：挖坑填数+分治法：先来看实例吧，定义下面再给出（最好能用自己的话来总结定义，这样对实现代码会有帮助）。 以一个数组作为示例，取区间第一个数为基准数。01234567

基本思想设初始序列有n个元素，选定一个小于n大于或等于1的整数gap作为间隔，将全部元素分成gap个子序列，所有距离为gap的元素放在同一个子序列中，在每个子序列中分别采用直接插入算法进行排序；然后缩小间隔gap，如令gap=gap/2，重复上面的子序列划分和子序列排序动作；直到最后去gap=1，将所有的元素放到一个序列中为止。简单示例初始序列：21 25 49 25 16 8第一

int solution(int a[],int n,int b[],int m){    if(!a||!b)        return 0;    int dp[n+1][m+1];    int res=INT_MIN;    memset(dp,sizeof(dp),0);    for(int i=1;i        for(int j=1;j

边赋以权值的图称为网或带权图，带权图的生成树也是带权的，生成树T各边的权值总和称为该树的权。最小生成树（MST）：权值最小的生成树。生成树和最小生成树的应用：要连通n个城市需要n－1条边线路。可以把边上的权值解释为线路的造价。则最小生成树表示使其造价最小的生成树。构造网的最小生成树必须解决下面两个问题：    1、尽可能选取权值小的边，但不能构成回路；    2、选取n－1条恰

迪杰斯特拉(Dijkstra)算法是典型最短路径算法，用于计算一个节点到其他节点的最短路径。 它的主要特点是以起始点为中心向外层层扩展(广度优先搜索思想)，直到扩展到终点为止。基本思想     通过Dijkstra计算图G中的最短路径时，需要指定起点s(即从顶点s开始计算)。     此外，引进两个集合S和U。S的作用是记录已求出最短路径的顶点(以及相应的最短路径长度)，而U则

strcpy函数char* strcpy(char *dest,const char *src) {        assert(dest!=NULL&&src!=NULL);        char *res=dest;        while(*dest++=*src++)            continue;        return res;}str

一致性hash算法提出了在动态变化的Cache环境中，判定哈希算法好坏的四个定义：1、平衡性(Balance)：平衡性是指哈希的结果能够尽可能分布到所有的缓冲中去，这样可以使得所有的缓冲空间都得到利用。很多哈希算法都能够满足这一条件。2、单调性(Monotonicity)：单调性是指如果已经有一些内容通过哈希分派到了相应的缓冲中，又有新的缓冲加入到系统中。哈希的结果应能够保证原

暴雪公司的魔兽、星际等游戏都一样一个非常大的MPQ文件，该文件存储了游戏中的大部分数据，想要把这些文字找出来，简单的办法是从数组头开始，一个个字符串读过去，比较每一个，直到找到对应的内容。Blizzard的天才和牛人们当然不会这样做，他们用了更聪明的方法: 用某种算法，把一个字符串压缩成一个整数，即hash。然后，根据这个整数值，直接得到此字符串在整个文件中的位置，从而直接读取之。 Bli

工作原理看完代码之后，让我们看看它对数组都做了写什么。首先，该方法选中数组的最后一个元素：接下来确定挑选随机元素的范围，从数组的第一个元素到上一步选中的元素都属于这一范围：确定范围后，从中随机挑选一个数，这里假设随机选中的元素为 4：然后交换最后一个元素和随机选中的元素的值：上面的交换完成后，相当于我们完成了对数组最后一个元素

深度优先遍历 1．深度优先遍历的递归定义　　假设给定图G的初态是所有顶点均未曾访问过。在G中任选一顶点v为初始出发点(源点)，则深度优先遍历可定义如下：首先访问出发点v，并将其标记为已访问过；然后依次从v出发搜索v的每个邻接点w。若w未曾访问过，则以w为新的出发点继续进行深度优先遍历，直至图中所有和源点v有路径相通的顶点(亦称为从源点可达的顶点)均已被访问为止。若此时图中仍有未访问的顶

拓扑排序 算法思想1、在AOV网络中选一个没有直接前驱的顶点, 并输出之;2、从图中删去该顶点, 同时删去所有它发出的有向边;3、重复以上步骤, 直到◆ 全部顶点均已输出，拓扑有序序列形成，拓扑排序完成；◆ 或者图中还有未输出的顶点，但已跳出处理循环。这说明图中还剩下一些顶点，它们都有直接前驱，再也找不到没有前驱的顶点了。这时AOV网络中必定存在有向环。

无向图:1 并查集                                                                             首先我们把每个点看成独立的集合{0} ，{1}， {2}, 然后规定如果两个点之间有边相连，如果这两个点不属于同一个集合，那就将他们所属的结合合并，看边0-1，直接将这两个点代表的集合合并{0， 1},

原理如果想判断一个元素是不是在一个集合里，一般想到的是将集合中所有元素保存起来，然后通过比较确定。链表、树、散列表（又叫哈希表，Hash table）等等数据结构都是这种思路。但是随着集合中元素的增加，我们需要的存储空间越来越大。同时检索速度也越来越慢。Bloom Filter 是一种空间效率很高的随机数据结构，Bloom filter 可以看做是对 bit-map 的扩展,

题目：输入两棵二叉树A和B，判断树B是不是A的子结构递归判断：如果当前结点值相等，就判断左子树和右子树是否是子结构[cpp] view plaincopybool IsChildTree(Node * father, Node * son)  {      if(father == NULL && son == NULL)          return true;

采用的是先序遍历/** * Definition of TreeNode: * class TreeNode { * public: * int val; * TreeNode *left, *right; * TreeNode(int val) { * this->val = val; * this->left

用字符串d分割s例如 d="."          s="www.baidu.com"         ret={"www","baidu","com"}#include#include#include#includeusing namespace std;vector split(const string &s,const string &d){

#include#includeusing namespace std;void foo(string &a,string &b,string &c)  //把字符串a中的子串b替换成子串c{ string::size_type pos=0; string::size_type begin=0; string ret; while((pos=a.find(b,pos))

using namespace std;void helper(vector &A,int &maxp,int &minp){    if(A.empty())        return ;    int n=A.size();    maxp=A[0],minp=A[0];    for(int i=0;i<n;i+=2){        if(i+1==n

s="http://www.bai.com"t={"http://","."}ret={"www","baidu","com"}算法有点low,有好的算法后再更新#include#include#include#includeusing namespace std;vector split(const string &s,vector &t){    //在

直接上代码,不懂horspool算法请先百度#include #include #include #define MAX 256typedef struct{ int arr[64]; int count ;}info;static int move[MAX] ;void init(const char *str , int n){ in

每对朋友都存在pair中#include#include#includeusing namespace std;static int p[100];int Find(int x)          //返回x的父节点{ if(p[x]!=x) p[x]=Find(p[x]); //这两步包含了路径压缩    return p[x];  }

#include#include#include#includeusing namespace std;bool cmp(const char *a,const char *b) //比较两个字符串的大小{ for(;*a==*b;++a,++b) if('\0'==*a) return false; return *a>*b?false:tr

#define MAXSIZE 256string foo(const string &s){     string ret; int begin,end,size=s.length(); int maxp=0,check[MAXSIZE]; for(int i=0;i<MAXSIZE;++i) check[i]=-1;            //记录字符的位置  

arr={[2,6],[3,8]}        ret=6arr={[0,8],[10,12]}   ret=10arr={[2,3]}                ret=1using namespace std;typedef struct { int begin; int end;}interval;bool cmp(const interv

#include#includeusing namespace std;void solve(int n){    if(n=-9)        cout<<n<<endl;    bool open=false;    if(n<0){ n=-n; open=true;    }    stack st; while(n){        int tmp

Bucket sort is mainly useful when input is uniformly distributed over a range. For example, consider the following problem.Sort a large set of floating point numbers which are in range from 0.0 to

给你a、b两个文件，各存放50亿条url，每条url各占用64字节，内存限制是4G，让你找出a、b文件共同的url  可以估计每个文件的大小为5G*64=300G，远大于4G。所以不可能将其完全加载到内存中处理。考虑采取分而治之的方法。   遍历文件a，对每个url求取hash(url)%1000，然后根据所得值将url分别存储到1000个小文件（设为a0,a1,...a999

有时，我们会碰到对字符串的排序，若采用一些经典的排序算法，则时间复杂度一般为O(n*lgn)，但若采用Trie树，则时间复杂度仅为O(n)。Trie树又名字典树，从字面意思即可理解，这种树的结构像英文字典一样，相邻的单词一般前缀相同，之所以时间复杂度低，是因为其采用了以空间换取时间的策略。下图为一个针对字符串排序的Trie树(我们假设在这里字符串都是小写字母)，每个结点有26个分支

#include#include#include#include#includeusing namespace std;map level;void init(){ level['+']=0; level['-']=0; level['*']=1; level['/']=1; level['(']=2; level[')']=2

Rabin-Karp字符串匹配算法, 实际应用中，Rabin和Karp建议的字符串匹配算法能较好地运行，还可以归纳出有关问题地其他算法，如二维模式匹配。 假定字符集Σ ＝{0, 1, 2, ……， 9}， 每一个字符对应一个十进制数字（一般情况, 假定每个字符是基数为d的表示法中的一个数字， d=|Σ|。)可以用一个长度为k的十进制数字来表示由k个连续字符组成的字符串.因此

#include#include#include#includeusing namespace std;vector > *m; //cmp的operator()用到class cmp{public:        bool operator()(const pair &a,const pair &b){    //注意,形参是坐标对,函数体內比较的却是形参对应的元素大

Lucky numbers are subset of integers. Rather than going into much theory, let us see the process of arriving at lucky numbers,Take the set of integers1,2,3,4,5,6,7,8,9,10,11,12,14,15,16,17,18,19

求两个排序数组中位数，这道题是很有意思的一道题目，算法导论中9.3-8题，这题必须在O(logn)的时间复杂度求解，否则肯定悲剧。。。这题有个关键的条件，那就是这两个数组长度相等思路如下：数组A：1, 3, 5, 7, 9数组B：2, 4, 6, 8, 10首先取二者的中位数，在O(1)时间复杂度内求出，那么数组A的midValue = 5，数组B的midValue = 6，则