查找

在面试的时候二分查找是用的比较多一种查找算法，如何在面试官面前快速准确得的写出代码决定你是否能够被录取。以前一直以为二分查找很简单，所以就没怎么重视，但是真要在面试官面前对着黑板手写出来，还是漏洞百出。今天自己在电脑面前敲出了二分查找的代码，也花了将近半个小时。对于这种基础排序查找算法，还是得好好重视。

1. 二分查找的时间复杂度是O(log(n))，最坏情况下的时间复杂度是O(n)。
2. 二分查找的一个条件是待查询的数组是有序的，我们假设这里的数组是升序的。
3. 二分查找的主要思路就是设定两个指针start和end分别指向数组元素的收尾两端，然后比较数组中间结点arry[mid]和待查找元素。如果待查找元素小于中间元素，那么表明带查找元素在数组的前半段，那么将end=mid-1，如果待查找元素大于中间元素，那么表明该元素在数组的后半段，将start=mid+1;如果中间元素等于待查找元素，那么返回mid的值。

二分查找可以使用递归和非递归的方法来解决，下面给出代码实例。

#include<iostream>
#include<stdlib.h>
using namespace std;


//不适用递归，如果存在返回数组位置，不存在则返回-1
int BinarySearch(int arry[],int len,int value)
{
    //如果传入的数组为空或者数组长度<=0那么就返回-1。防御性编程
    if(arry==NULL||len<=0)
        return -1;

    int start=0;
    int end=len-1;
    
    while(start<=end)//判断清是否有=
    {
        int mid=start+(end-start)/2;
        if(arry[mid]==value)
            return mid;
        else if(value<arry[mid])
            end=mid-1;
        else
            start=mid+1;
    }
    return -1;

}

//改进思路:1.不要传参，而是传引用调用，减少垃圾
//        2.使用模板
int BinarySearchRecursion(int arry[],int value,int start,int end)
{
    if(start>end)
        return -1;

    int mid=start+(end-start)/2;
    if(arry[mid]==value)
        return mid;

    else if(value<arry[mid])
        return    BinarySearchRecursion(arry,value,start,mid-1);
    else
        return    BinarySearchRecursion(arry,value,mid+1,end);

}

int BinarySearchRecursion(int arry[],int len,int value)
{
    //如果传入的数组为空或者数组长度<=0那么就返回-1。防御性编程
    if(arry==NULL||len<=0)
        return -1;
    return BinarySearchRecursion(arry,value,0,len-1);
}

void main()
{
    int arry[]={1,2,3,4,5,6,7,8};
    int len=sizeof(arry)/sizeof(int);

    int index=BinarySearch(arry,len,4);
    cout<<"index:"<<index<<endl;

    int index2=BinarySearchRecursion(arry,len,9);
    cout<<"index2:"<<index2<<endl;

    system("pause");
}

在上述递归的二分查找方法中：

int BinarySearchRecursion(int arry[],int value,int start,int end)

我们可以发现这个方法中的后三个参数value，start，end采用的是传值调用，只有第一个参数arry是传址调用。我们知道在效率方面，传值调用要比传址调用来的低，因为传值调用要进行一次变量的拷贝，而传址调用则是直接对这个变量进行操作。因此这里我们可以将后面的三个参数改为传址调用

改进后的代码实例如下：

int BinarySearchRecursion(int arry[],int &value,int &start,int &end)
{
    if(start>end)
        return -1;

    int mid=start+(end-start)/2;
    if(arry[mid]==value)
        return mid;

    else if(value<arry[mid])
    {
        end=mid-1;
        return BinarySearchRecursion(arry,value,start,end);
    }
    else
    {
        start=mid+1;
        return BinarySearchRecursion(arry,value,start,end);
    }
}

int BinarySearchRecursion(int arry[],int &len,int &value)
{
    //如果传入的数组为空或者数组长度<=0那么就返回-1。防御性编程
    if(arry==NULL||len<=0)
        return -1;
    int start=0;
    int end=len-1;
    return BinarySearchRecursion(arry,value,start,end);
}

void main()
{
    int arry[]={1,2,3,4,5,6,7,8};
    int len=sizeof(arry)/sizeof(int);
    int especteNum1=4;
    int especteNum2=9;
    int index=BinarySearch(arry,len,especteNum1);
    cout<<"index:"<<index<<endl;

    int index2=BinarySearchRecursion(arry,len,especteNum2);
    cout<<"index2:"<<index2<<endl;

    system("pause");
}

http://www.cnblogs.com/xwdreamer/archive/2012/05/07/2487246.html

暴雪公司有个经典的字符串的hash公式

先提一个简单的问题，假如有一个庞大的字符串数组，然后给你一个单独的字符串，让你从这个数组中查找是否有这个字符串并找到它，你会怎么做？ 

有一个方法最简单，老老实实从头查到尾，一个一个比较，直到找到为止，我想只要学过程序设计的人都能把这样一个程序作出来，但要是有程序员把这样的程序交给用户，我只能用无语来评价，或许它真的能工作，但也只能如此了。 
最合适的算法自然是使用HashTable（哈希表），先介绍介绍其中的基本知识，所谓Hash，一般是一个整数，通过某种算法，可以把一个字符串"压缩" 成一个整数，这个数称为Hash，当然，无论如何，一个32位整数是无法对应回一个字符串的，但在程序中，两个字符串计算出的Hash值相等的可能非常小，下面看看在MPQ中的Hash算法 

unsigned long HashString(char *lpszFileName, unsigned long dwHashType)  
{  
unsigned char *key = (unsigned char *)lpszFileName;  
unsigned long seed1 = 0x7FED7FED, seed2 = 0xEEEEEEEE;  
int ch;  
while(*key != 0)  
{  
ch = toupper(*key );  
seed1 = cryptTable[(dwHashType < < 8) ch] ^ (seed1 seed2);  
seed2 = ch seed1 seed2 (seed2 < < 5) 3;  
}  
return seed1;  
}  

Blizzard的这个算法是非常高效的，被称为"One-Way Hash"，举个例子，字符串"unitneutralacritter.grp"通过这个算法得到的结果是0xA26067F3。 
是不是把第一个算法改进一下，改成逐个比较字符串的Hash值就可以了呢，答案是，远远不够，要想得到最快的算法，就不能进行逐个的比较，通常是构造一个哈希表(Hash Table)来解决问题，哈希表是一个大数组，这个数组的容量根据程序的要求来定义，例如1024，每一个Hash值通过取模运算 (mod)对应到数组中的一个位置，这样，只要比较这个字符串的哈希值对应的位置又没有被占用，就可以得到最后的结果了，想想这是什么速度？是的，是最快的O(1)，现在仔细看看这个算法吧 

int GetHashTablePos(char *lpszString, SOMESTRUCTURE *lpTable, int nTableSize)  
{  
int nHash = HashString(lpszString), nHashPos = nHash % nTableSize;  
if (lpTable[nHashPos].bExists && !strcmp(lpTable[nHashPos].pString, lpszString))  
return nHashPos;  
else  
return -1; //Error value  
}  

看到此，我想大家都在想一个很严重的问题："假如两个字符串在哈希表中对应的位置相同怎么办？",究竟一个数组容量是有限的，这种可能性很大。解决该问题的方法很多，我首先想到的就是用"链表",感谢大学里学的数据结构教会了这个百试百灵的法宝，我碰到的很多算法都可以转化成链表来解决，只要在哈希表的每个入口挂一个链表，保存所有对应的字符串就OK了。 
事情到此似乎有了完美的结局，假如是把问题独自交给我解决，此时我可能就要开始定义数据结构然后写代码了。然而Blizzard的程序员使用的方法则是更精妙的方法。基本原理就是：他们在哈希表中不是用一个哈希值而是用三个哈希值来校验字符串。 
中国有句古话"再一再二不能再三再四"，看来Blizzard也深得此话的精髓，假如说两个不同的字符串经过一个哈希算法得到的入口点一致有可能，但用三个不同的哈希算法算出的入口点都一致，那几乎可以肯定是不可能的事了，这个几率是1:18889465931478580854784，大概是10的 22.3次方分之一，对一个游戏程序来说足够安全了。 
现在再回到数据结构上，Blizzard使用的哈希表没有使用链表，而采用"顺延"的方式来解决问题，看看这个算法： 

int GetHashTablePos(char *lpszString, MPQHASHTABLE *lpTable, int nTableSize)  
{  
const int HASH_OFFSET = 0, HASH_A = 1, HASH_B = 2;  
int nHash = HashString(lpszString, HASH_OFFSET);  
int nHashA = HashString(lpszString, HASH_A);  
int nHashB = HashString(lpszString, HASH_B);  
int nHashStart = nHash % nTableSize, nHashPos = nHashStart;  
while (lpTable[nHashPos].bExists)  
{  
if (lpTable[nHashPos].nHashA == nHashA && lpTable[nHashPos].nHashB == nHashB)  
return nHashPos;  
else  
nHashPos = (nHashPos 1) % nTableSize;  
if (nHashPos == nHashStart)  
break;  
}  
return -1; //Error value  
}  

1. 计算出字符串的三个哈希值（一个用来确定位置，另外两个用来校验) 
2. 察看哈希表中的这个位置 
3. 哈希表中这个位置为空吗？假如为空，则肯定该字符串不存在，返回 
4. 假如存在，则检查其他两个哈希值是否也匹配，假如匹配，则表示找到了该字符串，返回 
5. 移到下一个位置，假如已经越界，则表示没有找到，返回 
6. 看看是不是又回到了原来的位置，假如是，则返回没找到 
7. 回到3 
怎么样，很简单的算法吧，但确实是天才的idea, 其实最优秀的算法往往是简单有效的算法。

举例：

查找，也可称检索，是在大量的数据元素中找到某个特定的数据元素而进行的工作。查找是一种操作。

二、顺序查找

针对无序序列的一种最简单的查找方式。

时间复杂度为O(n)。

三、折半查找

针对已排序序列的一种查找方式。并且只适用于顺序存储结构的序列。要求序列中的元素基本不变，在需要做删除和插入操作的时候，会影响检索效率。

时间复杂度为O(logN)。

四、B树

B树又称二叉排序树（Binary Sort Tree）。

1、概念：

   它或者是一棵空树；或者是具有下列性质的二叉树：

　　(1)若左子树不空，则左子树上所有结点的值均小于左子树所在树的根结点的值；

　　(2)若右子树不空，则右子树上所有结点的值均大于右子树所在树的根结点的值；

　　(3)左、右子树也分别为二叉排序树；

2、B树的查找：

时间复杂度与树的深度的有关。

　　步骤：若根结点的关键字值等于查找的关键字，成功。

　　否则：若小于根结点的关键字值，递归查左子树。

　　若大于根结点的关键字值，递归查右子树。

　　若子树为空，查找不成功。

3、B树的插入：

首先执行查找算法，找出被插结点的父亲结点。

　　判断被插结点是其父亲结点的左儿子还是右儿子。将被插结点作为叶子结点插入。

　　若二叉树为空。则首先单独生成根结点。

　　注意：新插入的结点总是叶子结点，所以算法复杂度是O(h)。

4、B树的删除：

　　如果删除的结点没有孩子，则删除后算法结束；

　　如果删除的结点只有一个孩子，则删除后该孩子取代被删除结点的位置；

　　如果删除的结点有两个孩子，则选择该结点的后继结点（该结点右孩子为根的树中的左子树中的值最小的点）作为新的根，同时在该后继结点开始，执行前两种删除算法，删除算法结束。

5、B+树

一棵m阶的B+树满足下列条件：

（1）每个结点最多m个孩子。

（2）除根结点和叶子结点外，其它每个结点至少有ém/2ù个孩子。

（3）根结点至少有两个孩子。

（4）所有的叶子结点在同一层，且包含了所有关键字信息。

（5）有k个孩子的分支结点包含k个关键字。

例如:

五、散列（hash）表

关键字：哈希函数、装填因子、冲突、同义词；

关键字和和存储的地址建立一个对应的关系：

Add = Hash(key)；

解决冲突方法：

开放定址法 – 探测方式：线性探测、二次探测。

分离链接法 – 利用链表的方式。

查找找效率不依赖于数据长度n，查找效率非常快，很多能达到O(1)，查找的效率是a（装填因子）的函数，而不是n的函数。因此不管n多大都可以找到一个合适的装填因子以便将平均查找长度限定在一个范围内。

举例：