查找算法

时间 2019-11-07

标签查找算法栏目应用数学繁體版

原文原文链接

1. 基本概念

查找结构一般有四种操做：查询某个特定元素是否在表中，检索知足条件的某个特定元素的各类属性，在查找表中插入某一数据元素，从查找表中删除某个元素html

只涉及前两种操做的称为静态查找，包括顺序查找，二分（折半）查找，散列查找等，涉及到后面两种操做的称为动态查找，包括二叉排序树查找，散列查找等
平均查找长度：全部查找过程当中关键码比较次数的平均值，衡量查找算法效率的主要指标

2. 折半查找（二分查找）

二分查找仅适用于事先已经排序过的线性表顺序存储结构（须要方便定位查找区域，存储结构具备随机存储的特色）
二分查找的时间复杂度为O（log2N），查找成功或者查找不成功，最坏状况下须要log2N + 1次检索

3. 键树

键树称为数字查找树，是度大于等于2的书，书的每一个结点包含的是组成关键字的符号，若是关键字是数值，则结点包含一个数位，若是关键字是单词，则结点包含一个字母字符，以下图所示。node

3.1 双链树（树的孩子-兄弟链来表示键树）

每一个Node有三个域：ios

symbol域：存储关键字的一个字符
son域:存储指向第一个子树的根针
brother域：指向右兄弟指针
查找过程是，从根结点出发，顺着son查找，若是相等，继续下一个son。不然沿着brother查找。直到到了空指针为止。此时若仍未完成key的匹配，查找不成功。

3.2 字典树

字典树，又叫作Trie树，单词查找树，或者前缀树，是一种用于快速检索的多叉树结构，树的每一个结点包含d个指针域，d是关键字符的基，好比英文字母的字典树是26叉树，数字字典树是10叉树。算法

Trie树基本性质：
1. 根结点不包含字符，除了根结点以外每一个结点包含一个字符
2. 从根结点到某一个叶子节点，路径上通过的字符链接起来，为一个字符串
3. 每一个结点所包含的子结点包含的字符串不一样
Trie树经过字符串的公共前缀来下降开销，它的优势是最大限度减小无谓的字符串比较，其典型应用是用于统计和排序大量字符串。
Trie的缺点是：若是存在大量字符串，而这些字符串基本没有公共前缀，那么Trie树将很是消耗内存。编程
Trie树的实现：数组

#include<iostream>
#include<cstdlib>
using namespace std;

const int branchNum = 26;
struct Trie_node{
    bool isStr; // 记录此处是否构成一个串
    Trie_node * next[branchNum]; //指向各个子树的指针
    
    // 初始化
    Trie_node() :isStr(false){ memset(next, NULL, sizeof(next)); }
};

class Trie{
private:
    Trie_node *root;
public:
    Trie(){ root = new Trie_node(); }
    void insert(const char * str);
    bool search(char * str);
    void deleteTrie(Trie_node * root);
    Trie_node * getTrie(){ return root; }
};

void Trie::insert(const char * str){
    Trie_node * location = root;
    while (*str){
        // 若是不存在则创建结点
        if (location->next[*str - 'a'] == NULL){
            Trie_node *temp = new Trie_node();
            location->next[*str - 'a'] = temp;
        }
        location = location->next[*str - 'a'];
        // 每插入一步，至关于新串路过，指针移动
        str++;
    }
    location->isStr = true;//标记一个串

    // Trie *temp = (Trie *) malloc(sizeof(Trie));
    // for(int i =0;i<26,i++)
    // temp->next[i] = NULL:
}


bool Trie::search(char * str){
    Trie_node * location = root;
    while (*str && location){  // *str!='\0'
        location = location->next[*str - 'a'];
        str++;
    }
    return (location != NULL && location->isStr);
}

void Trie::deleteTrie(Trie_node *root){
    for (int i = 0; i < branchNum; i++){
        if (root->next[i] != NULL)
            deleteTrie(root->next[i]);
    }
    delete(root);
}

int main(){
    char *str = "abcdefg";
    Trie trie;
    trie.insert(str);
    if (trie.search(str)) cout << "true";
    system("pause");
    return 0;
}

Trie树的应用：
1. 给定一个单词a，若是经过交换字幕的顺序能够获得另外的单词b，那么称a和b是是兄弟单词，如今要求给一个字典，用户输入一个单词，能够根据字典找到该单词的兄弟单词，要求时间和空间效率尽量高。
  答：解法一：hash_map 和链表，定义一个ID，使得兄弟单词有相同的id，不是兄弟单词有不一样的id，这个id能够是将单词从小到大排序后做为其ID，也能够是将单词各个字母对应一个质数，将质数相乘当作hash id。建立一个hash_map,它的key为单词的id，value为兄弟单词链表的起始地址。全部的兄弟单词存放在一个链表中。当须要找到该兄弟单词时，只须要计算单词id，而后到map中找到对应的链表便可。
  解法二：利用Trie树，单词插入Trie树前，先按照字母排序，将排序后的字母放入Trie树，在树的结点中增长一个vector，用于记录全部的兄弟单词安全
2. 数据文件A：1000万条关键词，数据文件Ｂ：关键词与ＩＤ的对应表，100万条左右，如今将A中关键词替换为ID，可用内存为1GB，硬盘不限
  答：使用文件B生成Trie树，而后用Trie树实现关键词对ID 的快速查找，Trie_node结点中包含ID信息，主要是实际应用中关键词之间可能有不少前缀相同现象，因此空间耗费不会很高。
参考：
1. 海量数据处理之Tire树（字典树）
2. 字典树(Trie树)实现与应用

4.后缀树和后缀数组（suffix tree）

后缀树

5. 哈希表

哈希表的设计目的：空间换取时间，基于快速存取的角度设计，根据关键字直接访问的数据结构，经过某种规则将关键字映射到数组某个位置，这个映射规则称为哈希函数/散列函数。
哈希冲突：不一样的关键字经过哈希函数计算获得了相同的数组下标，在设计hash函数应该尽可能避免这样的冲突，同时还要设计处理好可能产生的冲突。
哈希函数：若是两个hash值不一样，那么对应的这两个hash值的原始输入是不相同的，可是两个hash值相同，原始输入的两个key值不必定是相同的。
1. 经常使用hash函数：直接定址法，数字分析法，平方取中法，除留余数法，折叠法
2. MD四、MD5（更安全）、SHA-1；（用于文件检验，数字签名，鉴权协议）
处理冲突的方法：链地址法（同义词存储在同一个线性链表中），开放定址法，再散列法（发生冲突时利用另外一个哈希函数从新计算），创建一个公共溢出区（填入溢出表）

6. 一致性哈希

集群问题（待续）

7. 海量数据处理

7.1 hash映射-分治处理

对大文件处理时，若文件过大，没法一次性读入内存，将hash映射将文件元素映射到不一样小文件中，在依次处理各个小文件，最后合并处理结果。
例子：a、b文件，各存放50个url，请找出a、b共同的URL？
答：遍历a，hash（url）%1024，将a分别存放在1024个文件中，对b进行一样操做，处理后，**全部可能相同的url都在对应的小文件中，如a0对应b0，而后分别对小文件进行遍历搜索处理等便可数据结构

7.2 Top K问题

常见问题：最大的k个数或者最小的k个数
若是数据可以一次性读入内存，快排的一次排序，时间复杂度为O（n）
若是海量数据，咱们一般使用堆，（最大k个数为小根堆，最小K个数使用大根堆）

【编程之美】读书笔记：寻找最大的K个数
 《编程之美》——寻找最大的K个数函数

// 快排 咱们基于数组的第K个数字来调整时，最小的k个数
void getleastNumber(int *input, int n, int *output, int k){
    if (input == NULL || output == NULL || k>n || n <= 0 || k <= 0)
        return;

    int start = 0;
    int end = n - 1;
    int index = Partition(input,  start, end);
    while (index != k - 1){
        if (index > k - 1){
            end = index - 1;
            // 一趟快排
            index = Partition(input, start, end);
        }
        else{
            start = index + 1;
            index = Partition(input,  start, end);
        }
    }

    for (int i = 0; i < k; ++i)
        output[i] = input[i];
}

int Partition(int *a, int low, int high){
    int pivot = a[low];
    while (low < high){
        while (low < high && a[high] >= pivot) --high;
        a[low] = a[high];
        while (low < high && a[low] <= pivot) ++low;
        a[high] = a[low];
    }
    a[low] = pivot;
    return low;
}

// 基于multiset的实现
void getLeastNumbers(const vector<int> &data, multiset<int, int> & leastNumbers, int k){
    leastNumbers.clear();

    if (k < 1 || data.size() < k)
        return;

    vector<int>::const iterator = data.begin();
    for (; iter != data.end(); ++iter){
        if (leastNumbers.size() < k)
            leastNumbers.insert(*iter);
        else{
            mutiset<int, int>::iterator setiter = leastNumbers.begin();
            if (*iter < *(leastNumbers.begin())){
                leastNumbers.erase(setiter);
                leastNumbers.insert(iter);
            }
        }
    }
}

7.3 Bit-map

使用位数组来表示某些元素是否存在，采用bit做为单位存储数据
时间复杂度为O(n),以空间换时间，根据具体状况须要n位的串url
例1： 40亿个不重复的unsigned int的值，没排过序，再给一个数，如何判断这个数是否在40个亿数中？
答：unsigned int 最多2^32个数，须要申请512M的内存，一个bit位表明一个unsigned int的值，读入40亿个数，设置对应bit位，读入数，查询相应的位
例2:4,7,2,5,3排序答：申请一个8位byte位，读入第一个值4，则将byte第5位置1，而后依次置位，最后遍历bit区域，将该位是1的编号输出